Esta página se ha traducido con Cloud Translation API.

Configurar un despliegue personalizado de kube-dns

Estándar

En esta página se explica cómo ejecutar un Deployment personalizado de kube-dns en clústeres del modo Estándar de Google Kubernetes Engine (GKE). Esta página no se aplica a Autopilot de GKE, donde Google gestiona kube-dns.

Información general

Para configurar la CPU, la memoria y otros parámetros de kube-dns, debes ejecutar un Deployment personalizado e inhabilitar el Deployment que proporciona GKE. También puedes ejecutar una implementación personalizada de CoreDNS o de cualquier otro proveedor de DNS que siga la especificación de DNS de Kubernetes con las instrucciones de esta página.

Para obtener más información sobre cómo implementa GKE el descubrimiento de servicios, consulta Descubrimiento de servicios y DNS.

Crear un despliegue personalizado

Crea un manifiesto de Deployment para kube-dns, CoreDNS u otro proveedor de DNS.

El siguiente manifiesto de kube-dns de ejemplo incluye la marca -q para registrar los resultados de las consultas. Guarda el archivo de manifiesto como 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

Sustituye DNS_DEPLOYMENT_NAME por el nombre del despliegue personalizado de kube-dns.

Aplica el manifiesto al clúster:
```
kubectl create -f custom-kube-dns.yaml
```
Verifica que los pods se estén ejecutando:
```
kubectl get pods -n kube-system -l=k8s-app=kube-dns
```
La salida es similar a la siguiente, que muestra los pods de kube-dns personalizados:
```
NAME                               READY   STATUS    RESTARTS   AGE
custom-kube-dns-5685645b44-kzs8w   3/3     Running   0          22h
```
El nuevo Deployment tiene el mismo selector que kube-dns, lo que significa que los pods usan la misma dirección IP de servicio de kube-dns para comunicarse con los pods que ejecutan el Deployment de kube-dns personalizado.

Una vez completado este paso, debes seguir los pasos de la siguiente sección para reducir la escala de kube-dns.

Reducir la escala de kube-dns

Inhabilita kube-dns gestionado por GKE escalando a cero el Deployment y el escalador automático de kube-dns con el siguiente comando:

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

Crear una herramienta de escalado automático personalizada

Si tu DNS personalizado requiere autoescalado, debes configurar e implementar un autoescalador independiente. kube-dns-autoscaler solo escala el kube-dns Deployment predeterminado en el clúster. También debes configurar un ClusterRole personalizado para tu herramienta de escalado automático y añadir permisos para modificar tus despliegues personalizados de kube-dns.

Crea un manifiesto de ClusterRole y Deployment para el escalador automático y guárdalo como 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

Aplica el manifiesto al clúster:

kubectl create -f custom-dns-autoscaler.yaml

Siguientes pasos

Consulta una descripción general de cómo proporciona GKE DNS gestionado.
Consulta DNS para servicios y pods para obtener una descripción general de cómo se usa el DNS en los clústeres de Kubernetes.