Diese Seite wurde von der Cloud Translation API übersetzt.

Benutzerdefiniertes kube-dns-Deployment einrichten

Standard

In diesem Dokument wird erläutert, wie Sie die DNS-Einrichtung in Ihrem GKE-Standardcluster (Google Kubernetes Engine) anpassen, indem Sie das standardmäßige, von GKE verwaltete kube-dns durch Ihr eigenes Deployment ersetzen. So haben Sie mehr Kontrolle über den DNS-Anbieter Ihres Clusters. Beispiele:

CPU- und Arbeitsspeicherressourcen für DNS-Komponenten optimieren.
Eine bestimmte kube-dns-Image-Version verwenden
Stellen Sie einen alternativen DNS-Anbieter wie CoreDNS bereit, der die Kubernetes-DNS-Spezifikation einhält.

Dieses Dokument gilt nur für Standardcluster. Google verwaltet die DNS-Konfiguration in Autopilot-Clustern. Weitere Informationen zu DNS-Anbietern in GKE finden Sie unter Informationen zur Service Discovery und kube-dns.

Achtung:Wenn Sie ein benutzerdefiniertes DNS-Deployment ausführen, sind Sie für die laufende Wartung verantwortlich. Dazu gehört, dass die kube-dns- und Autoscaler-Container-Images auf dem neuesten Stand sind und die neuesten Versionen und Sicherheitspatches enthalten. Die neuesten empfohlenen Images finden Sie im Standard-Deployment kube-dns im Namespace kube-system eines GKE-Cluster.

Dieses Dokument richtet sich an GKE-Nutzer, einschließlich Entwickler, Administratoren und Architekten. Weitere Informationen zu gängigen Rollen und Beispielaufgaben in Google Cloudfinden Sie unter Häufig verwendete GKE Enterprise-Nutzerrollen und -Aufgaben.

In diesem Dokument wird davon ausgegangen, dass Sie mit Folgendem vertraut sind:

Benutzerdefiniertes kube-dns-Deployment einrichten

In diesem Abschnitt wird beschrieben, wie Sie die von GKE verwaltete kube-dns durch Ihre eigene Bereitstellung ersetzen.

Benutzerdefiniertes Manifest erstellen und bereitstellen

Speichern Sie das folgende Deployment-Manifest als custom-kube-dns.yaml. In diesem Manifest wird kube-dns verwendet.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: DNS_DEPLOYMENT_NAME
  namespace: kube-system
  labels:
    k8s-app: kube-dns
  annotations:
    deployment.kubernetes.io/revision: "1"
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.22.28
        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.22.28
        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.22.28
        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 den Namen Ihres benutzerdefinierten DNS-Deployments.

Wenden Sie das Manifest auf den Cluster an:
```
kubectl create -f custom-kube-dns.yaml
```

Von GKE verwalteten `kube-dns` herunterskalieren

Um Konflikte zu vermeiden, deaktivieren Sie die von GKE verwalteten kube-dns- und kube-dns-autoscaler-Deployments, indem Sie sie auf null Replikate skalieren:

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

Benutzerdefiniertes Autoscaling konfigurieren

Mit dem Standardwert kube-dns-autoscaler wird nur das von GKE verwaltete kube-dns-Deployment skaliert. Wenn für Ihren benutzerdefinierten DNS-Anbieter Autoscaling erforderlich ist, müssen Sie ein separates Autoscaling bereitstellen und ihm Berechtigungen zum Ändern Ihrer benutzerdefinierten DNS-Bereitstellung erteilen.

Erstellen Sie das folgende Manifest und speichern Sie es als custom-dns-autoscaler.yaml.

apiVersion: v1
kind: ConfigMap
metadata:
  name: custom-dns-autoscaler
  namespace: kube-system
data:
  linear: |-
    {
      "coresPerReplica": 256,
      "nodesPerReplica": 16,
      "preventSinglePointFailure": true
    }
---
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
    spec:
      priorityClassName: system-cluster-critical
      securityContext:
        seccompProfile:
          type: RuntimeDefault
        supplementalGroups: [ 65534 ]
        fsGroup: 65534
      nodeSelector:
        kubernetes.io/os: linux
      containers:
      - name: autoscaler
        image: registry.k8s.io/autoscaling/cluster-proportional-autoscaler:1.8.9
        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

Ersetzen Sie DNS_DEPLOYMENT_NAME im Feld resourceNames und im Feld command durch den Namen Ihres benutzerdefinierten DNS-Deployments.

Wenden Sie das Manifest auf den Cluster an:

kubectl create -f custom-dns-autoscaler.yaml

Deployment prüfen

Prüfen Sie, ob Ihre benutzerdefinierten DNS-Pods ausgeführt werden:

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

Da Sie das von GKE verwaltete kube-dns-Deployment auf null Replikate skaliert haben, werden in der Ausgabe nur Pods aus Ihrem benutzerdefinierten Deployment angezeigt. Prüfen Sie, ob der Status Running lautet.

Von GKE verwaltetes kube-dns wiederherstellen

Wenn Sie eine benutzerdefinierte kube-dns-Konfiguration bereitgestellt haben und zur standardmäßigen von GKE verwalteten Einrichtung zurückkehren möchten, müssen Sie Ihre benutzerdefinierten Ressourcen löschen und die verwaltete kube-dns-Bereitstellung wieder aktivieren.

So stellen Sie die von GKE verwaltete kube-dns wieder her:

Löschen Sie das benutzerdefinierte kube-dns-Deployment und den zugehörigen Autoscaler. Wenn Sie die Manifeste als custom-kube-dns.yaml und custom-dns-autoscaler.yaml gespeichert haben, führen Sie die folgenden Befehle aus, um die Ressourcen zu löschen:
```
kubectl delete -f custom-dns-autoscaler.yaml
kubectl delete -f custom-kube-dns.yaml
```
Wenn Sie die Manifeste nicht gespeichert haben, löschen Sie das Deployment, die ClusterRole und die ClusterRoleBinding, die Sie für Ihr benutzerdefiniertes Deployment erstellt haben, manuell.
Stellen Sie die von GKE verwaltete kube-dns-autoscaler wieder her. Führen Sie den folgenden Befehl aus, um das kube-dns-autoscaler-Deployment auf ein Replikat zu skalieren:
```
kubectl scale deployment --replicas=1 kube-dns-autoscaler --namespace=kube-system
```
Mit diesem Befehl wird die verwaltete kube-dns-autoscaler wieder aktiviert. Die Bereitstellung der verwalteten kube-dns wird dann automatisch auf die entsprechende Anzahl von Replikaten für die Größe Ihres Clusters skaliert.
Prüfen Sie die Wiederherstellung.

Prüfen Sie, ob die Pods kube-dns und kube-dns-autoscaler ordnungsgemäß ausgeführt werden:
```
kubectl get pods -n kube-system -l k8s-app=kube-dns
```
Die Ausgabe sollte zeigen, dass sich die von GKE verwalteten kube-dns-Pods im Status Running befinden.

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

Benutzerdefiniertes kube-dns-Deployment einrichten Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Benutzerdefiniertes kube-dns-Deployment einrichten

Benutzerdefiniertes Manifest erstellen und bereitstellen

Von GKE verwalteten kube-dns herunterskalieren

Benutzerdefiniertes Autoscaling konfigurieren

Deployment prüfen

Von GKE verwaltetes kube-dns wiederherstellen

Nächste Schritte

Benutzerdefiniertes kube-dns-Deployment einrichten

Von GKE verwalteten `kube-dns` herunterskalieren