Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Benutzerdefiniertes kube-dns-Deployment einrichten

Standard

In diesem Dokument wird erläutert, wie Sie die DNS-Einrichtung in Ihrem Google Kubernetes Engine-Standardcluster (GKE) 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-Imageversion verwenden
Einen alternativen DNS-Anbieter wie CoreDNS bereitstellen, der der Kubernetes-DNS-Spezifikation entspricht

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 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 Container-Images kube-dns und Autoscaling auf dem neuesten Stand sind und die neuesten Versionen und Sicherheitspatches enthalten. Die neuesten empfohlenen Images finden Sie im Standard-kube-dns-Deployment 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-Nutzerrollen und -Aufgaben.

In diesem Dokument wird davon ausgegangen, dass Sie mit den folgenden Themen vertraut sind:

Benutzerdefiniertes kube-dns-Deployment einrichten

In diesem Abschnitt wird erläutert, wie Sie das von GKE verwaltete kube-dns durch Ihr eigenes Deployment ersetzen.

Benutzerdefiniertes Manifest erstellen und bereitstellen

Speichern Sie das folgende Deployment-Manifest als custom-kube-dns.yaml. Dieses Manifest verwendet kube-dns.

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 verwaltetes `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

Das Standard-kube-dns-autoscaler skaliert nur das von GKE verwaltete kube-dns Deployment. Wenn für Ihren benutzerdefinierten DNS-Anbieter Autoscaling erforderlich ist, müssen Sie einen separaten Autoscaler bereitstellen und ihm Berechtigungen zum Ändern Ihres benutzerdefinierten DNS-Deployments gewähren.

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 ist.

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 das verwaltete kube-dns-Deployment wieder aktivieren.

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

Löschen Sie das benutzerdefinierte kube-dns-Deployment und das zugehörige Autoscaling. 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 das von GKE verwaltete kube-dns-autoscaler wieder her. Führen Sie den folgenden Befehl aus, um das kube-dns-autoscaler-Deployment wieder auf ein Replikat zu skalieren:
```
kubectl scale deployment --replicas=1 kube-dns-autoscaler --namespace=kube-system
```
Mit diesem Befehl wird das verwaltete kube-dns-autoscaler wieder aktiviert, das dann das verwaltete kube-dns-Deployment 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 kube-dns und kube-dns-autoscaler Pods korrekt 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 verwaltetes 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 verwaltetes `kube-dns` herunterskalieren