Questa pagina è stata tradotta dall'API Cloud Translation.

Configura un deployment personalizzato di kube-dns

Standard

Questo documento spiega come personalizzare la configurazione DNS nel cluster Google Kubernetes Engine (GKE) Standard sostituendo kube-dns predefinito gestito da GKE con il tuo deployment. In questo modo, avrai un maggiore controllo sul provider DNS del tuo cluster. Ad esempio, puoi:

Ottimizza le risorse di CPU e memoria per i componenti DNS.
Utilizza una versione specifica dell'immagine kube-dns.
Esegui il deployment di un provider DNS alternativo, ad esempio CoreDNS, che rispetti la specifica DNS di Kubernetes.

Questo documento riguarda solo i cluster Standard. Google gestisce la configurazione DNS nei cluster Autopilot. Per una comprensione più approfondita dei provider DNS in GKE, consulta Informazioni sul rilevamento dei servizi e kube-dns.

Attenzione:se esegui un deployment DNS personalizzato, sei responsabile della sua manutenzione continua. Ciò include la garanzia che le immagini container di kube-dns e dello strumento di scalabilità automatica siano aggiornate con le versioni e le patch di sicurezza più recenti. Per trovare le immagini consigliate più recenti, esamina il deployment kube-dns predefinito nello spazio dei nomi kube-system di un cluster GKE.

Questo documento è rivolto agli utenti di GKE, inclusi sviluppatori, amministratori e architetti. Per saperne di più sui ruoli comuni e sulle attività di esempio in Google Cloud, consulta Ruoli e attività comuni degli utenti di GKE Enterprise.

Questo documento presuppone che tu abbia familiarità con quanto segue:

Configurare un deployment kube-dns personalizzato

Questa sezione spiega come sostituire kube-dns gestito da GKE con il tuo deployment.

Creare e implementare il manifest personalizzato

Salva il seguente manifest Deployment come custom-kube-dns.yaml. Questo manifest utilizza 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

Sostituisci DNS_DEPLOYMENT_NAME con il nome del tuo deployment DNS personalizzato.

Applica il manifest al cluster:
```
kubectl create -f custom-kube-dns.yaml
```

Ridimensiona il `kube-dns` gestito da GKE

Per evitare conflitti, disabilita i deployment kube-dns e kube-dns-autoscaler gestiti da GKE impostando il numero di repliche su zero:

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

Configura un gestore della scalabilità automatica personalizzato

Il valore predefinito kube-dns-autoscaler scala solo il deployment kube-dns gestito da GKE. Se il tuo provider DNS personalizzato richiede lo scaling automatico, devi implementare uno strumento di scalabilità automatica separato e concedergli le autorizzazioni per modificare l'implementazione DNS personalizzata.

Crea il seguente manifest e salvalo come 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

Sostituisci DNS_DEPLOYMENT_NAME nel campo resourceNames e nel campo command con il nome del tuo deployment DNS personalizzato.

Applica il manifest al cluster:

kubectl create -f custom-dns-autoscaler.yaml

Verifica il deployment

Verifica che i pod DNS personalizzati siano in esecuzione:

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

Poiché hai scalato il deployment kube-dns gestito da GKE a zero repliche, nell'output vengono visualizzati solo i pod del tuo deployment personalizzato. Verifica che il suo stato sia Running.

Ripristina kube-dns gestito da GKE

Se hai eseguito il deployment di una configurazione kube-dns personalizzata e devi ripristinare la configurazione gestita da GKE predefinita, devi eliminare le risorse personalizzate e riattivare il deployment kube-dns gestito.

Segui questi passaggi per ripristinare kube-dns gestito da GKE:

Elimina il deployment personalizzato di kube-dns e il relativo gestore della scalabilità automatica. Se hai salvato i manifest come custom-kube-dns.yaml e custom-dns-autoscaler.yaml, esegui i seguenti comandi per eliminare le risorse:
```
kubectl delete -f custom-dns-autoscaler.yaml
kubectl delete -f custom-kube-dns.yaml
```
Se non hai salvato i manifest, elimina manualmente Deployment, ClusterRole e ClusterRoleBinding che hai creato per il deployment personalizzato.
Ripristina kube-dns-autoscaler gestito da GKE. Esegui questo comando per ridurre lo scale down del deployment kube-dns-autoscaler a una replica:
```
kubectl scale deployment --replicas=1 kube-dns-autoscaler --namespace=kube-system
```
Questo comando riattiva kube-dns-autoscaler gestito, che poi scala automaticamente il deployment di kube-dns gestito al numero appropriato di repliche per le dimensioni del cluster.
Verifica il ripristino.

Controlla i pod kube-dns e kube-dns-autoscaler per assicurarti che siano in esecuzione correttamente:
```
kubectl get pods -n kube-system -l k8s-app=kube-dns
```
L'output dovrebbe mostrare che i pod kube-dns gestiti da GKE sono nello stato Running.

Passaggi successivi

Leggi una panoramica di come GKE fornisce DNS gestito.
Leggi la sezione DNS per servizi e pod per una panoramica generale di come viene utilizzato il DNS nei cluster Kubernetes.

Configura un deployment personalizzato di kube-dns Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.