NetScaler CPXs als lokale DNS-Caches für Kubernetes-Knoten bereitstellen

Anwendungs-Pods in einem Kubernetes-Cluster verlassen sich auf DNS, um mit anderen Anwendungs-Pods zu kommunizieren. DNS-Anfragen von Anwendungen innerhalb eines Kubernetes-Clusters werden von Kubernetes DNS (kube-dns) verarbeitet. Aufgrund der zunehmenden Verbreitung von Microservices-Architekturen steigen die DNS-Anfrageraten innerhalb eines Kubernetes-Clusters. Infolgedessen ist Kubernetes DNS (kube-dns) überlastet. Sie können NetScaler CPX jetzt als lokalen DNS-Cache auf jedem Kubernetes-Knoten bereitstellen und DNS-Anfragen von Anwendungs-Pods auf dem Knoten an NetScaler CPX weiterleiten. Dadurch können Sie DNS-Anfragen schneller auflösen und die Last auf Kubernetes DNS erheblich reduzieren.

Um NetScaler CPXs bereitzustellen, wird eine Kubernetes DaemonSet-Entität verwendet, um NetScaler CPX-Pods auf jedem Knoten im Kubernetes-Cluster zu planen. Ein Kubernetes DaemonSet stellt sicher, dass auf jedem Kubernetes-Knoten im Cluster eine Instanz von NetScaler CPX vorhanden ist. Damit Anwendungs-Pods den Datenverkehr an CPX DNS-Pods leiten, müssen Sie einen Kubernetes-Dienst mit Endpunkten als NetScaler CPX-Pods erstellen. Die Cluster-IP dieses Dienstes wird als DNS-Endpunkt für die Anwendungs-Pods verwendet. Um sicherzustellen, dass die Anwendungs-Pods die Cluster-IP-Adresse des NetScaler CPX-Dienstes für die DNS-Auflösung verwenden, müssen Sie die kubelet-Konfigurationsdatei auf jedem Knoten mit der Cluster-IP des NetScaler CPX-Dienstes aktualisieren.

Die folgenden Umgebungsvariablen wurden eingeführt, um die Bereitstellung von NetScaler CPX als NodeLocal DNS-Cache zu unterstützen:

• KUBE_DNS_SVC_IP: Gibt die Cluster-IP-Adresse des kube-dns-Dienstes an, die ein obligatorisches Argument ist, um die Konfiguration auf einem NetScaler CPX-Pod auszulösen. Der NetScaler CPX-Pod leitet DNS-Abfragen an diese IP-Adresse weiter, wenn die DNS-Abfrageantwort nicht im NetScaler CPX-Cache verfügbar ist.

• CPX_DNS_SVC_IP: Gibt die Cluster-IP-Adresse des NetScaler CPX-Dienstes an. Die Umgebungsvariable CPX_DNS_SVC_IP wird verwendet, um lokales DNS auf Knoten zu konfigurieren. Wenn Sie diese Variable konfigurieren, wird eine iptables-Regel hinzugefügt, um die von Anwendungs-Pods ausgehenden DNS-Anfragen an den lokalen NetScaler CPX-Pod innerhalb des Knotens zu leiten.

• NS_DNS_FORCE_TCP: Diese Umgebungsvariable erzwingt die Verwendung von TCP für DNS-Anfragen, auch wenn die Abfragen über UDP empfangen werden.

• NS_DNS_EXT_RESLV_IP: Gibt die IP-Adresse des externen Nameservers an, an den die DNS-Anfragen für eine bestimmte Domäne weitergeleitet werden sollen.

• NS_DNS_MATCH_DOMAIN: Gibt die externe Domänenzeichenfolge an, mit der abgeglichen werden soll, um die Abfragen an den externen Nameserver zu leiten.

NetScaler CPXs als DNS-Caches auf Knoten bereitstellen

Die Bereitstellung von NetScaler CPX als lokaler DNS-Cache für einen Kubernetes-Cluster umfasst die folgenden Aufgaben:

Auf dem Master-Knoten:

• Erstellen Sie einen Kubernetes-Dienst mit Endpunkten als NetScaler CPX-Pods

• Erstellen Sie eine ConfigMap zur Definition von Umgebungsvariablen für NetScaler CPX-Pods

• Planen Sie NetScaler CPX-Pods auf jedem Knoten im Kubernetes-Cluster mithilfe eines Kubernetes DaemonSet.

Auf Worker-Knoten:

• Ändern Sie die kubelet-Konfigurationsdatei mit der Cluster-IP-Adresse des NetScaler CPX-Dienstes, um DNS-Anfragen an NetScaler CPXs weiterzuleiten.

Konfiguration auf dem Kubernetes-Masterknoten

Führen Sie die folgenden Schritte auf dem Kubernetes-Masterknoten aus, um NetScaler CPX als lokalen DNS-Cache für Knoten bereitzustellen:

1. Erstellen Sie einen Dienst mit NetScaler CPX-Pods als Endpunkte unter Verwendung der Datei cpx_dns_svc.yaml.

   kubectl apply -f cpx_dns_svc.yaml
   

   Die Datei cpx_dns_svc.yaml wird wie folgt bereitgestellt:

           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. Rufen Sie die IP-Adresse des NetScaler CPX-Dienstes ab.

   kubectl get svc cpx-dns-svc
   

3. Rufen Sie die IP-Adresse des Kube DNS-Dienstes ab.

   kubectl get svc -n kube-system
   

4. Erstellen Sie eine ConfigMap zum Definieren von Umgebungsvariablen für NetScaler CPX-Pods. Diese Umgebungsvariablen werden verwendet, um IP-Adressen des NetScaler CPX-Dienstes und des Kube DNS-Dienstes zu übergeben. In diesem Schritt wird eine Beispiel-ConfigMap cpx-dns-cache unter Verwendung der als Daten (Schlüssel-Wert-Paare) in einer Datei angegebenen Umgebungsvariablen erstellt.

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

   Im Folgenden finden Sie eine Beispieldatei mit den Umgebungsvariablen als Schlüssel-Wert-Paare.

     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
   

   Im Folgenden finden Sie eine Beispiel-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. Erstellen Sie ein Kubernetes DaemonSet für NetScaler CPX auf dem Masterknoten.

   kubectl apply -f cpx_daemonset.yaml
   

   Die Datei cpx_daemonset.yaml wird wie folgt bereitgestellt:

   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
   

Konfiguration auf Worker-Knoten im Kubernetes-Cluster

Nachdem Sie die Konfiguration auf dem Masterknoten abgeschlossen haben, führen Sie den folgenden Schritt auf den Worker-Knoten aus:

1. Ändern Sie die kubelet-Konfigurationsdatei, damit Anwendungspods die Cluster-IP des NetScaler CPX-Dienstes für die DNS-Auflösung verwenden können, indem Sie einen der folgenden Schritte ausführen:

   • Befolgen Sie die Schritte unter kubelet eines Knotens neu konfigurieren und ändern Sie den Wert des Arguments --cluster-dns im folgenden Format.

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

     oder

   • Bearbeiten Sie die Datei /etc/systemd/system/kubelet.service.d/10-kubeadm.conf und ändern Sie das Argument --cluster-dns mit den folgenden Schritten.

     1. Bearbeiten Sie die kubelet-Konfiguration und geben Sie die Cluster-IP-Adresse des NetScaler CPX-Dienstes und die Dienst-IP-Adresse kube-dns für das Argument --cluster-dns an.

         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. Laden Sie das kubelet der Knoten mit den folgenden Befehlen neu:

         # systemctl daemon-reload
         # service kubelet restart