Configurer un déploiement kube-dns personnalisé


Cette page explique comment exécuter un déploiement personnalisé de kube-dns pour les clusters en mode standard de Google Kubernetes Engine (GKE). Cette page ne s'applique pas à GKE Autopilot, pour lequel Google gère kube-dns.

Présentation

Pour configurer le processeur, la mémoire et d'autres paramètres kube-dns, vous devez exécuter un déploiement personnalisé et désactiver le déploiement fourni par GKE. Vous pouvez également exécuter un déploiement personnalisé de Core DNS ou de tout autre fournisseur DNS en suivant les spécifications DNS de Kubernetes, comme décrit sur cette page.

Pour en savoir plus sur la mise en œuvre de la détection de services par GKE, consultez la page Détection de services et DNS.

Créer un déploiement personnalisé

  1. Créez un fichier manifeste de déploiement pour kube-dns, Core DNS ou tout autre fournisseur DNS.

    L'exemple de fichier manifeste kube-dns suivant inclut l'option -q pour consigner les résultats des requêtes. Enregistrez le manifeste sous le nom 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
    

    Remplacez DNS_DEPLOYMENT_NAME par le nom du déploiement kube-dns personnalisé.

  2. Appliquez le fichier manifeste au cluster :

    kubectl create -f custom-kube-dns.yaml
    
  3. Vérifiez que les pods sont en cours d'exécution :

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

    Le résultat ressemble à ce qui suit, avec les pods kube-dns personnalisés :

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

    Le nouveau déploiement utilise le même sélecteur que kube-dns, ce qui signifie que les pods utilisent la même adresse IP de service kube-dns pour communiquer avec les pods exécutant le déploiement kube-dns personnalisé.

    Une fois cette étape terminée, vous devez suivre les étapes de la section suivante pour réduire la capacité de kube-dns.

Réduire la capacité de kube-dns

Désactivez kube-dns géré par GKE en procédant à un scaling du déploiement kube-dns et de l'autoscaler à zéro à l'aide de la commande suivante :

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

Créer un autoscaler personnalisé

Si votre DNS personnalisé nécessite un autoscaling, vous devez configurer et déployer un autoscaler distinct. kube-dns-autoscaler n'applique le scaling qu'au déploiement par défaut de kube-dns sur le cluster. Vous devez également configurer un ClusterRole personnalisé pour votre autoscaler et ajouter des autorisations pour modifier vos déploiements kube-dns personnalisés.

  1. Créez un ClusterRole et un fichier manifeste de déploiement pour l'autoscaler et enregistrez le fichier manifeste en tant que 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. Appliquez le fichier manifeste au cluster :

    kubectl create -f custom-dns-autoscaler.yaml
    

Étape suivante

  • Consultez une présentation de la façon dont GKE fournit le DNS géré.
  • Consultez la page DNS pour les services et les pods pour obtenir une présentation générale de l'utilisation du DNS dans les clusters Kubernetes.