Questa pagina è stata tradotta dall'API Cloud Translation.

Configurazione di un deployment personalizzato di kube-dns

Standard

Questa pagina spiega come eseguire un deployment personalizzato di kube-dns per i cluster in modalità standard di Google Kubernetes Engine (GKE). Questa pagina non si applica a GKE Autopilot, in cui Google gestisce kube-dns.

Panoramica

Per configurare la CPU, la memoria e altri parametri di kube-dns, devi eseguire un deployment personalizzato e disattivare il deployment fornito da GKE. Puoi anche eseguire un deployment personalizzato di Core DNS o di qualsiasi altro provider DNS che segue la specifica DNS di Kubernetes utilizzando le istruzioni riportate in questa pagina.

Per scoprire di più su come GKE implementa la Service Discovery, consulta Service Discovery e DNS.

Creazione di un deployment personalizzato

Crea un manifest di deployment per kube-dns, Core DNS o un altro provider DNS.

Il seguente manifest kube-dns di esempio include il flag -q per registrare i risultati delle query. Salva il file manifest come 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

Sostituisci DNS_DEPLOYMENT_NAME con un nome per il deployment personalizzato di kube-dns.

Applica il manifest al cluster:
```
kubectl create -f custom-kube-dns.yaml
```
Verifica che i pod siano in esecuzione:
```
kubectl get pods -n kube-system -l=k8s-app=kube-dns
```
L'output è simile al seguente, mostrando i pod kube-dns personalizzati:
```
NAME                               READY   STATUS    RESTARTS   AGE
custom-kube-dns-5685645b44-kzs8w   3/3     Running   0          22h
```
Il nuovo deployment ha lo stesso selettore di kube-dns, il che significa che i pod utilizzano lo stesso indirizzo IP del servizio kube-dns per comunicare con i pod che eseguono il deployment personalizzato di kube-dns.

Al termine di questo passaggio, devi seguire i passaggi riportati nella sezione successiva per eseguire fare lo scale down di kube-dns.

Riduzione della scala di kube-dns

Disabilita kube-dns gestito da GKE impostando su zero il deployment e il gestore della scalabilità automatica di kube-dns utilizzando il seguente comando:

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

Creazione di un gestore della scalabilità automatica personalizzato

Se il tuo DNS personalizzato richiede la scalabilità automatica, devi configurare ed eseguire il deployment di un variatore automatico separato. Il programma di scalabilità automatica kube-dns ridimensiona solo il deployment kube-dns predefinito nel cluster. Devi anche configurare un ClusterRole personalizzato per il gestore della scalabilità automatica e aggiungere autorizzazioni per modificare i deployment di kube-dns personalizzati.

Crea un ClusterRole e un manifest di deployment per il gestore della scalabilità automatica e salva il manifest come 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

Applica il manifest al cluster:

kubectl create -f custom-dns-autoscaler.yaml

Passaggi successivi

Leggi una panoramica di come GKE fornisce DNS gestito.
Leggi DNS per servizi e pod per una panoramica generale dell'utilizzo del DNS nei cluster Kubernetes.