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.