Configurer un déploiement kube-dns personnalisé

Ce document explique comment personnaliser la configuration DNS de votre cluster standard Google Kubernetes Engine (GKE) en remplaçant le kube-dns par défaut géré par GKE par votre propre déploiement. Vous pouvez ainsi mieux contrôler le fournisseur DNS de votre cluster. Par exemple, vous pouvez :

  • Ajuster les ressources de processeur et de mémoire pour les composants DNS.
  • Utiliser une version d'image kube-dns spécifique.
  • Déployer un autre fournisseur DNS, tel que CoreDNS, qui respecte la spécification DNS de Kubernetes.

Ce document ne concerne que les clusters standard. Google gère la configuration DNS dans les clusters Autopilot. Pour en savoir plus sur les fournisseurs DNS dans GKE, consultez À propos de la découverte de services et kube-dns.

Attention : Si vous exécutez un déploiement DNS personnalisé, vous êtes responsable de sa maintenance continue. Vous devez notamment vous assurer que les images de conteneur kube-dns et autoscaler sont à jour avec les dernières versions et les derniers correctifs de sécurité. Pour trouver les dernières images recommandées, inspectez le déploiement kube-dns par défaut dans l'espace de noms kube-system d'un cluster GKE.

Ce document s'adresse aux utilisateurs de GKE, y compris les développeurs, les administrateurs et les architectes. Pour en savoir plus sur les rôles courants et les exemples de tâches dans GKE, consultez Rôles utilisateur et tâches courantes de GKE. Google Cloud

Ce document suppose que vous connaissez les éléments suivants :

Configurer un déploiement kube-dns personnalisé

Cette section explique comment remplacer le kube-dns géré par GKE par votre propre déploiement.

Créer et déployer le fichier manifeste personnalisé

  1. Enregistrez le fichier manifeste Deployment suivant sous le nom custom-kube-dns.yaml. Ce fichier manifeste utilise 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

    Remplacez DNS_DEPLOYMENT_NAME par le nom de votre déploiement DNS personnalisé.

  2. Appliquez le fichier manifeste au cluster :

    kubectl create -f custom-kube-dns.yaml

Réduire le scaling du kube-dns géré par GKE

Pour éviter les conflits, désactivez les déploiements kube-dns et kube-dns-autoscaler gérés par GKE en réduisant leur scaling à zéro instance dupliquée :

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

Configurer un autoscaler personnalisé

L'autoscaler par défaut kube-dns-autoscaler ne met à l'échelle que le déploiement géré par GKE kube-dns. Si votre fournisseur DNS personnalisé nécessite un autoscaling, vous devez déployer un autoscaler distinct et lui accorder des autorisations pour modifier votre déploiement DNS personnalisé.

  1. Créez le fichier manifeste suivant et enregistrez-le sous le nom 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

    Remplacez DNS_DEPLOYMENT_NAME dans le champ resourceNames et dans le champ command par le nom de votre déploiement DNS personnalisé.

  2. Appliquez le fichier manifeste au cluster :

    kubectl create -f custom-dns-autoscaler.yaml

Vérifier le déploiement

Vérifiez que vos pods DNS personnalisés sont en cours d'exécution :

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

Étant donné que vous avez réduit le scaling du déploiement kube-dns géré par GKE à zéro instance dupliquée, seuls les pods de votre déploiement personnalisé apparaissent dans le résultat. Vérifiez que leur état est Running.

Restaurer le kube-dns géré par GKE

Si vous avez déployé une configuration kube-dns personnalisée et que vous devez revenir à la configuration par défaut gérée par GKE, vous devez supprimer vos ressources personnalisées et réactiver le déploiement kube-dns géré.

Pour restaurer le kube-dns géré par GKE, procédez comme suit :

  1. Supprimez le déploiement kube-dns personnalisé et son autoscaler. Si vous avez enregistré les fichiers manifestes sous les noms custom-kube-dns.yaml et custom-dns-autoscaler.yaml, exécutez les commandes suivantes pour supprimer les ressources :

    kubectl delete -f custom-dns-autoscaler.yaml
kubectl delete -f custom-kube-dns.yaml

    Si vous n'avez pas enregistré les fichiers manifestes, supprimez manuellement le déploiement, le ClusterRole et le ClusterRoleBinding que vous avez créés pour votre déploiement personnalisé.

  2. Restaurez l'autoscaler kube-dns-autoscaler géré par GKE. Exécutez la commande suivante pour remettre le scaling du déploiement kube-dns-autoscaler à une instance dupliquée :

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

    Cette commande réactive le kube-dns-autoscaler géré, qui met ensuite automatiquement à l'échelle le déploiement kube-dns géré au nombre approprié d'instances dupliquées pour la taille de votre cluster.

  3. Vérifiez la restauration.

    Vérifiez que les pods kube-dns et kube-dns-autoscaler sont en cours d'exécution :

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

    Le résultat doit indiquer que les pods kube-dns gérés par GKE sont à l'état Running.

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