Configurer un déploiement kube-dns personnalisé

Standard

Ce document explique comment personnaliser la configuration DNS de votre cluster Google Kubernetes Engine (GKE) Standard 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 :

• Ajustez précisément les ressources de processeur et de mémoire pour les composants DNS.
• Utilisez une version spécifique de l'image kube-dns.
• Déployez un autre fournisseur DNS, tel que CoreDNS, qui respecte les spécifications DNS de Kubernetes.

Ce document ne concerne que les clusters Standard. Google gère la configuration DNS dans les clusters Autopilot. Pour mieux comprendre les fournisseurs DNS dans GKE, consultez À propos de la découverte des services et kube-dns.

Attention : Si vous exécutez un déploiement DNS personnalisé, vous êtes responsable de sa maintenance continue. Cela inclut de s'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 Google Cloud, consultez Rôles utilisateur et tâches courantes de l'utilisateur dans GKE Enterprise.

Dans ce document, nous partons du principe que vous connaissez les éléments suivants :

• Service Kubernetes.
• Services multiclusters
• À propos de la découverte des services
• Découverte des services et DNS dans GKE
• À propos de Cloud DNS

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

Effectuez le scaling à la baisse de 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 les réduisant à zéro réplica :

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

Configurer un autoscaler personnalisé

Le kube-dns-autoscaler par défaut ne met à l'échelle que le déploiement kube-dns géré par GKE. Si votre fournisseur DNS personnalisé nécessite un autoscaling, vous devez déployer un autoscaler distinct et lui accorder les autorisations nécessaires 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 les champs resourceNames et 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

Comme vous avez défini le scaling du déploiement kube-dns géré par GKE sur zéro réplica, seuls les pods de votre déploiement personnalisé apparaissent dans le résultat. Vérifiez que son état est Running.

Restaurer 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é.

Suivez ces étapes pour restaurer le kube-dns géré par GKE :

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 le kube-dns-autoscaler géré par GKE. Exécutez la commande suivante pour redimensionner le déploiement kube-dns-autoscaler et le ramener à une réplique :

   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é de répliques pour la taille de votre cluster.

3. Vérifiez la restauration.

   Vérifiez que les pods kube-dns et kube-dns-autoscaler s'exécutent correctement :

   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.

Étapes suivantes

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