Benutzerdefiniertes kube-dns-Deployment einrichten

Standard

---

Auf dieser Seite wird erläutert, wie Sie ein benutzerdefiniertes Deployment von kube-dns für Cluster im GKE Standard-Modus (Google Kubernetes Engine) ausführen. Diese Seite gilt nicht für GKE Autopilot, bei dem Google kube-dns verwaltet.

Achtung: Wenn Sie ein benutzerdefiniertes Deployment von kube-dns ausführen, müssen Sie das kube-dns-Image mit Sicherheitspatches und Updates aktualisieren. Sie können das neueste Image aus dem kube-dns-Deployment im kube-system-Namespace abrufen.

Überblick

Zum Konfigurieren von CPU, Arbeitsspeicher und anderen Parametern von kube-dns müssen Sie ein benutzerdefiniertes Deployment ausführen und das von GKE bereitgestellte Deployment deaktivieren. Sie können auch ein benutzerdefiniertes Deployment von Core DNS oder einen anderen DNS-Anbieter ausführen, der die Kubernetes-DNS-Spezifikation befolgt, anhand der Anleitung auf dieser Seite ausführen.

Weitere Informationen zur Implementierung der Service Discovery durch GKE finden Sie unter Service Discovery und DNS.

Benutzerdefiniertes Deployment erstellen

1. Erstellen Sie ein Deployment-Manifest für kube-dns, Core DNS oder einen anderen DNS-Anbieter.

   Das folgende Beispiel für ein kube-dns-Manifest enthält das Flag -q, um die Ergebnisse von Abfragen zu protokollieren. Speichern Sie das Manifest als custom-kube-dns.yaml.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: DNS_DEPLOYMENT_NAME
     namespace: kube-system
     annotations:
       deployment.kubernetes.io/revision: "1"
       k8s-app: kube-dns
   spec:
     selector:
       matchLabels:
         k8s-app: kube-dns
     strategy:
       rollingUpdate:
         maxSurge: 10%
         maxUnavailable: 0
       type: RollingUpdate
     template:
       metadata:
         creationTimestamp: null
         labels:
           k8s-app: kube-dns
       spec:
         containers:
         - name: kubedns
           image: registry.k8s.io/dns/k8s-dns-kube-dns:1.17.3
           resources:
             limits:
               memory: '170Mi'
             requests:
               cpu: 100m
               memory: '70Mi'
           livenessProbe:
             httpGet:
               path: /healthcheck/kubedns
               port: 10054
               scheme: HTTP
             initialDelaySeconds: 60
             timeoutSeconds: 5
             successThreshold: 1
             failureThreshold: 5
           readinessProbe:
             httpGet:
               path: /readiness
               port: 8081
               scheme: HTTP
             initialDelaySeconds: 3
             timeoutSeconds: 5
           args:
           - --domain=cluster.local.
           - --dns-port=10053
           - --config-dir=/kube-dns-config
           - --v=2
           env:
           - name: PROMETHEUS_PORT
             value: "10055"
           ports:
           - containerPort: 10053
             name: dns-local
             protocol: UDP
           - containerPort: 10053
             name: dns-tcp-local
             protocol: TCP
           - containerPort: 10055
             name: metrics
             protocol: TCP
           volumeMounts:
           - name: kube-dns-config
             mountPath: /kube-dns-config
           securityContext:
             allowPrivilegeEscalation: false
             readOnlyRootFilesystem: true
             runAsUser: 1001
             runAsGroup: 1001
         - name: dnsmasq
           image: registry.k8s.io/dns/k8s-dns-dnsmasq-nanny:1.17.3
           livenessProbe:
             httpGet:
               path: /healthcheck/dnsmasq
               port: 10054
               scheme: HTTP
             initialDelaySeconds: 60
             timeoutSeconds: 5
             successThreshold: 1
             failureThreshold: 5
           args:
           - -v=2
           - -logtostderr
           - -configDir=/etc/k8s/dns/dnsmasq-nanny
           - -restartDnsmasq=true
           - --
           - -k
           - --cache-size=1000
           - --no-negcache
           - --dns-forward-max=1500
           - --log-facility=-
           - --server=/cluster.local/127.0.0.1#10053
           - --server=/in-addr.arpa/127.0.0.1#10053
           - --server=/ip6.arpa/127.0.0.1#10053
           ports:
           - containerPort: 53
             name: dns
             protocol: UDP
           - containerPort: 53
             name: dns-tcp
             protocol: TCP
           resources:
             requests:
               cpu: 150m
               memory: 20Mi
           volumeMounts:
           - name: kube-dns-config
             mountPath: /etc/k8s/dns/dnsmasq-nanny
           securityContext:
             capabilities:
               drop:
               - all
               add:
               - NET_BIND_SERVICE
               - SETGID
         - name: sidecar
           image: registry.k8s.io/dns/k8s-dns-sidecar:1.17.3
           livenessProbe:
             httpGet:
               path: /metrics
               port: 10054
               scheme: HTTP
             initialDelaySeconds: 60
             timeoutSeconds: 5
             successThreshold: 1
             failureThreshold: 5
           args:
           - --v=2
           - --logtostderr
           - --probe=kubedns,127.0.0.1:10053,kubernetes.default.svc.cluster.local,5,SRV
           - --probe=dnsmasq,127.0.0.1:53,kubernetes.default.svc.cluster.local,5,SRV
           ports:
           - containerPort: 10054
             name: metrics
             protocol: TCP
           resources:
             requests:
               memory: 20Mi
               cpu: 10m
           securityContext:
             allowPrivilegeEscalation: false
             readOnlyRootFilesystem: true
             runAsUser: 1001
             runAsGroup: 1001
         dnsPolicy: Default
         restartPolicy: Always
         schedulerName: default-scheduler
         securityContext: {}
         serviceAccount: kube-dns
         serviceAccountName: kube-dns
         terminationGracePeriodSeconds: 30
         tolerations:
         - key: CriticalAddonsOnly
           operator: Exists
         volumes:
         - configMap:
             defaultMode: 420
             name: kube-dns
             optional: true
           name: kube-dns-config
   

   Ersetzen Sie DNS_DEPLOYMENT_NAME durch einen Namen für das benutzerdefinierte Deployment von kube-dns.

2. Wenden Sie das Manifest auf den Cluster an:

   kubectl create -f custom-kube-dns.yaml
   

3. Prüfen Sie, ob die Pods ausgeführt werden:

   kubectl get pods -n kube-system -l=k8s-app=kube-dns
   

   Die Ausgabe sieht in etwa so aus, wobei die benutzerdefinierten kube-dns-Pods angezeigt werden:

   NAME                               READY   STATUS    RESTARTS   AGE
   custom-kube-dns-5685645b44-kzs8w   3/3     Running   0          22h
   

   Das neue Deployment hat den gleichen Selektor wie kube-dns. Das bedeutet, dass Pods dieselbe IP-Adresse des kube-dns-Dienstes verwenden, um mit den Pods zu kommunizieren, die das benutzerdefinierte kube-dns-Deployment ausführen.

   Nach Abschluss dieses Schritts müssen Sie die Schritte im nächsten Abschnitt ausführen, um kube-dns herunterzuskalieren.

Kube-dns herunterskalieren

Deaktivieren Sie das von GKE verwaltete kube-dns durch das Skalieren des kube-dns-Deployments und des Autoscalings auf null mit dem folgenden Befehl:

kubectl scale deployment --replicas=0 kube-dns-autoscaler --namespace=kube-system
kubectl scale deployment --replicas=0 kube-dns --namespace=kube-system

Benutzerdefiniertes Autoscaling erstellen

Wenn für Ihr benutzerdefiniertes DNS Autoscaling erforderlich ist, müssen Sie ein separates Autoscaling konfigurieren und bereitstellen. Das kube-dns-Autoscaling skaliert nur das standardmäßige kube-dns-Deployment im Cluster. Außerdem müssen Sie eine benutzerdefinierte ClusterRole für Ihr Autoscaling konfigurieren und Berechtigungen hinzufügen, um Ihre benutzerdefinierten kube-dns-Bereitstellungen zu ändern.

1. Erstellen Sie ein ClusterRole- und Deployment-Manifest für das Autoscaling und speichern Sie das Manifest als custom-dns-autoscaler.yaml:

   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: system:custom-dns-autoscaler
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: ClusterRole
     name: system:custom-dns-autoscaler
   subjects:
   - kind: ServiceAccount
     name: kube-dns-autoscaler
     namespace: kube-system
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRole
   metadata:
     name: system:custom-dns-autoscaler
   rules:
   - apiGroups:
     - ""
     resources:
     - nodes
     verbs:
     - list
     - watch
   - apiGroups:
     - apps
     resourceNames:
     - DNS_DEPLOYMENT_NAME
     resources:
     - deployments/scale
     verbs:
     - get
     - update
   - apiGroups:
     - ""
     resources:
     - configmaps
     verbs:
     - get
     - create
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: custom-dns-autoscaler
     namespace: kube-system
     labels:
       k8s-app: custom-dns-autoscaler
   spec:
     selector:
       matchLabels:
         k8s-app: custom-dns-autoscaler
     template:
       metadata:
         labels:
           k8s-app: custom-dns-autoscaler
         annotations:
           seccomp.security.alpha.kubernetes.io/pod: 'docker/default'
       spec:
         priorityClassName: system-cluster-critical
         securityContext:
           supplementalGroups: [ 65534 ]
           fsGroup: 65534
         nodeSelector:
           kubernetes.io/os: linux
         containers:
         - name: autoscaler
           image: registry.k8s.io/cluster-proportional-autoscaler-amd64:1.7.1
           resources:
               requests:
                   cpu: "20m"
                   memory: "10Mi"
           command:
             - /cluster-proportional-autoscaler
             - --namespace=kube-system
             - --configmap=custom-dns-autoscaler
             - --target=Deployment/DNS_DEPLOYMENT_NAME
             - --default-params={"linear":{"coresPerReplica":256,"nodesPerReplica":16,"preventSinglePointFailure":true}}
             - --logtostderr=true
             - --v=2
         tolerations:
         - key: "CriticalAddonsOnly"
           operator: "Exists"
         serviceAccountName: kube-dns-autoscaler
   

2. Wenden Sie das Manifest auf den Cluster an:

   kubectl create -f custom-dns-autoscaler.yaml
   

Nächste Schritte

• Bereitstellung von verwaltetem DNS in GKE
• Eine Übersicht zur Verwendung von DNS in Kubernetes-Clustern finden Sie unter DNS for Services and Pods