Déployer des NetScaler CPX en tant que caches DNS locaux pour les nœuds Kubernetes

Les pods d’application dans un cluster Kubernetes s’appuient sur le DNS pour communiquer avec d’autres pods d’application. Les requêtes DNS provenant d’applications au sein d’un cluster Kubernetes sont gérées par Kubernetes DNS (kube-dns). En raison de l’adoption plus large des architectures de microservices, les taux de requêtes DNS au sein d’un cluster Kubernetes augmentent. Par conséquent, Kubernetes DNS (kube-dns) est surchargé. Vous pouvez désormais déployer NetScaler CPX en tant que cache DNS local sur chaque nœud Kubernetes et transférer les requêtes DNS des pods d’application du nœud vers NetScaler CPX. Ainsi, vous pouvez résoudre les requêtes DNS plus rapidement et réduire considérablement la charge sur Kubernetes DNS.

Pour déployer des NetScaler CPX, une entité Kubernetes DaemonSet est utilisée pour planifier les pods NetScaler CPX sur chaque nœud du cluster Kubernetes. Un Kubernetes DaemonSet garantit qu’il y a une instance de NetScaler CPX sur chaque nœud Kubernetes du cluster. Pour que les pods d’application dirigent le trafic vers les pods DNS CPX, vous devez créer un service Kubernetes avec des points de terminaison en tant que pods NetScaler CPX. L’adresse IP de cluster de ce service est utilisée comme point de terminaison DNS pour les pods d’application. Pour vous assurer que les pods d’application utilisent l’adresse IP de cluster du service NetScaler CPX pour la résolution DNS, vous devez mettre à jour le fichier de configuration kubelet sur chaque nœud avec l’adresse IP de cluster du service NetScaler CPX.

Les variables d’environnement suivantes sont introduites pour prendre en charge le déploiement de NetScaler CPX en tant que cache DNS NodeLocal :

• KUBE_DNS_SVC_IP : Spécifie l’adresse IP de cluster du service kube-dns, qui est un argument obligatoire pour déclencher la configuration sur un pod NetScaler CPX. Le pod NetScaler CPX dirige les requêtes DNS vers cette adresse IP lorsque la réponse à la requête DNS n’est pas disponible dans le cache NetScaler CPX.

• CPX_DNS_SVC_IP : Spécifie l’adresse IP de cluster du service NetScaler CPX. La variable d’environnement CPX_DNS_SVC_IP est utilisée pour configurer le DNS local sur les nœuds. Lorsque vous configurez cette variable, une règle iptables est ajoutée pour diriger les requêtes DNS provenant des pods d’application vers le pod NetScaler CPX local à l’intérieur du nœud.

• NS_DNS_FORCE_TCP : Cette variable d’environnement force l’utilisation de TCP pour les requêtes DNS même si les requêtes sont reçues via UDP.

• NS_DNS_EXT_RESLV_IP : Spécifie l’adresse IP du serveur de noms externe pour diriger les requêtes DNS pour un domaine spécifique.

• NS_DNS_MATCH_DOMAIN : Spécifie la chaîne de domaine externe à faire correspondre pour diriger les requêtes vers le serveur de noms externe.

Déployer des NetScaler CPX en tant que caches DNS sur les nœuds

Le déploiement de NetScaler CPX en tant que cache DNS local pour un cluster Kubernetes comprend les tâches suivantes :

Sur le nœud maître :

• Créer un service Kubernetes avec des points de terminaison en tant que pods NetScaler CPX

• Créer une ConfigMap pour définir les variables d’environnement pour les pods NetScaler CPX

• Planifier les pods NetScaler CPX sur chaque nœud du cluster Kubernetes à l’aide d’un Kubernetes DaemonSet.

Sur les nœuds de travail :

• Modifiez le fichier de configuration kubelet avec l’adresse IP du cluster du service NetScaler CPX pour transférer les requêtes DNS aux NetScaler CPX.

Configuration sur le nœud maître Kubernetes

Effectuez les étapes suivantes sur le nœud maître Kubernetes pour déployer NetScaler CPX en tant que cache DNS local pour les nœuds :

1. Créez un service avec les pods NetScaler CPX comme points de terminaison en utilisant le fichier cpx_dns_svc.yaml.

   kubectl apply -f cpx_dns_svc.yaml
   

   Le fichier cpx_dns_svc.yaml est fourni comme suit :

           apiVersion: v1
           kind: Service
           metadata:
             name: cpx-dns-svc
             labels:
               app: cpxd
           spec:
             ports:
             - protocol: UDP
               port: 53
               name: dns
             - protocol: TCP
               port: 53
               name: dns-tcp
             selector:
               app: cpx-daemon
   

2. Obtenez l’adresse IP du service NetScaler CPX.

   kubectl get svc cpx-dns-svc
   

3. Obtenez l’adresse IP du service Kube DNS.

   kubectl get svc -n kube-system
   

4. Créez une ConfigMap pour définir les variables d’environnement des pods NetScaler CPX. Ces variables d’environnement sont utilisées pour transmettre les adresses IP du service NetScaler CPX et du service Kube DNS. Dans cette étape, un exemple de ConfigMap cpx-dns-cache est créé en utilisant les variables d’environnement spécifiées comme données (paires clé-valeur) dans un fichier.

   kubectl create configmap cpx-dns-cache --from-file <path-to-file>
   

   Voici un exemple de fichier avec les variables d’environnement sous forme de paires clé-valeur.

     CPX_DNS_SVC_IP: 10.111.95.145
     EULA: "yes"
     KUBE_DNS_SVC_IP: 10.96.0.10
     NS_CPX_LITE: "1"
     NS_DNS_EXT_RESLV_IP: 10.102.217.142
     NS_DNS_MATCH_DOMAIN: citrix.com
     PLATFORM: CP1000
   

   Voici un exemple de ConfigMap :

   apiVersion: v1
   data:
     CPX_DNS_SVC_IP: 10.111.95.145
     EULA: "yes"
     KUBE_DNS_SVC_IP: 10.96.0.10
     NS_CPX_LITE: "1"
     NS_DNS_EXT_RESLV_IP: 10.102.217.142
     NS_DNS_MATCH_DOMAIN: citrix.com
     PLATFORM: CP1000
   kind: ConfigMap
   metadata:
     creationTimestamp: "2019-10-15T07:45:54Z"
     name: cpx-dns-cache
     namespace: default
     resourceVersion: "8026537"
     selfLink: /api/v1/namespaces/default/configmaps/cpx-dns-cache
     uid: 8d06f6ee-133b-4e1a-913c-9963cbf4f48
   

5. Créez un DaemonSet Kubernetes pour NetScaler CPX sur le nœud maître.

   kubectl apply -f cpx_daemonset.yaml
   

   Le fichier cpx_daemonset.yaml est fourni comme suit :

   apiVersion: apps/v1
   kind: DaemonSet
   metadata:
     name: cpx-daemon
     labels:
           app: cpxd
   spec:
      selector:
           matchLabels:
             app: cpx-daemon
   template:
      metadata:
           labels:
             app: cpx-daemon
      spec:
          containers:
          - name: cpxd
           imagePullPolicy: IfNotPresent
           image: localhost:5000/dev/cpx
           volumeMounts:
            - mountPath: /netns/default/
           name: test-vol
           ports:
           - containerPort: 53
      envFrom:
          - configMapRef:
          name: cpx-dns-cache
      securityContext:
      privileged: true
      allowPrivilegeEscalation: true
      capabilities:
       add: ["NET_ADMIN"]
      volumes:
         -  name: test-vol
         hostPath:
         path: /proc/1/ns
         type: Directory
   

Configuration sur les nœuds de travail dans le cluster Kubernetes

Une fois la configuration terminée sur le nœud maître, effectuez l’étape suivante sur les nœuds de travail :

1. Modifiez le fichier de configuration kubelet afin que les pods d’application puissent utiliser l’adresse IP de cluster du service NetScaler CPX pour la résolution DNS en suivant l’une des étapes suivantes :

   • Suivez les étapes de reconfigurer le kubelet d’un nœud et modifiez la valeur de l’argument --cluster-dns au format suivant.

          --cluster-dns=<CPX_DNS_SVC_IP>,<KUBE_DNS_SVC_IP>
     

     ou

   • Modifiez le fichier /etc/systemd/system/kubelet.service.d/10-kubeadm.conf et modifiez l’argument --cluster-dns en suivant les étapes suivantes.

     1. Modifiez la configuration kubelet et spécifiez l’adresse IP de cluster du service NetScaler CPX et l’adresse IP du service kube-dns pour l’argument --cluster-dns.

         root@node:~# cat /etc/systemd/system/kubelet.service.d/10-kubeadm.conf | grep KUBELET\_DNS\_ARGS
        
         Environment="KUBELET_DNS_ARGS=--cluster-dns=10.111.95.145,10.96.0.10 --cluster-domain=cluster.local"
         ExecStart=/usr/bin/kubelet $KUBELET_KUBECONFIG_ARGS $KUBELET_CONFIG_ARGS $KUBELET_DNS_ARGS
        

     2. Rechargez le kubelet des nœuds à l’aide des commandes suivantes :

         # systemctl daemon-reload
         # service kubelet restart