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

Les espaces d’application d’un cluster Kubernetes dépendent du DNS pour communiquer avec les autres espaces d’application. Les demandes DNS provenant d’applications à l’intérieur 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. En conséquence, le DNS Kubernetes (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 provenant des espaces d’applications du nœud vers NetScaler CPX. Vous pouvez ainsi résoudre les demandes DNS plus rapidement et réduire considérablement la charge sur le DNS Kubernetes.

Pour déployer NetScaler CPX, une entité Kubernetes DaemonSet est utilisée pour planifier les pods NetScaler CPX sur chaque nœud du cluster Kubernetes. Un daemonSet Kubernetes garantit qu’il existe une instance de NetScaler CPX sur chaque nœud Kubernetes du cluster. Pour que les pods d’applications dirigent le trafic vers les pods DNS CPX, vous devez créer un service Kubernetes avec des points de terminaison sous forme de pods NetScaler CPX. L’adresse IP du cluster de ce service est utilisée comme point de terminaison DNS pour les espaces d’application. Pour vous assurer que les modules d’applications utilisent l’adresse IP du cluster de services NetScaler CPX pour la résolution DNS, vous devez mettre à jour le fichier de configuration Kubelet sur chaque nœud avec l’adresse IP du cluster de services 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 du cluster du kube-dns service 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 du cluster du service NetScaler CPX. La variable d’ CPX_DNS_SVC_IP environnement est utilisée pour configurer le DNS local sur les nœuds. Lorsque vous configurez cette variable, une iptables règle est ajoutée pour diriger les requêtes DNS provenant des espaces d’applications 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 demandes DNS pour un domaine spécifique.

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

Déployez des CPX NetScaler sous forme de caches DNS sur des nœuds

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

Sur le nœud maître :

• Création d’un service Kubernetes avec des points de terminaison sous forme de pods NetScaler CPX

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

• Planifiez des 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 vers NetScaler CPX.

Configuration sur le nœud maître Kubernetes

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

1. Créez un service avec des pods NetScaler CPX comme points de terminaison à l’aide du 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 DNS Kube.

   kubectl get svc -n kube-system
   

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

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

   Voici un exemple de fichier contenant 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 principal.

   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’applications puissent utiliser l’adresse IP du cluster de services NetScaler CPX pour la résolution DNS en suivant l’une des étapes suivantes :

   • Suivez les étapes de la section 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 du kubelet et spécifiez l’adresse IP du 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 de nœuds à l’aide des commandes suivantes :

         # systemctl daemon-reload
         # service kubelet restart