Documentación de Oracle Cloud Infrastructure

Configuración de servidores DNS para clusters Kubernetes

Descubra cómo configurar servidores DNS para clusters de Kubernetes que ha creado mediante Container Engine for Kubernetes (OKE).

Configuración de servidores DNS incorporados (kube-dns, CoreDNS)

Los clusters creados por Container Engine for Kubernetes incluyen un servidor DNS como servicio de Kubernetes incorporado que se inicia automáticamente. El proceso kubelet de cada nodo de trabajador dirige contenedores individuales al servidor DNS para convertir nombres DNS en direcciones IP.

Antes de versión 1.14 de Kubernetes, Container Engine for Kubernetes creó clusters con kube-dns como servidor DNS. Sin embargo, a partir de la versión 1.14 de Kubernetes, Container Engine for Kubernetes crea clusters con CoreDNS como servidor DNS. CoreDNS es un servidor DNS autorizado para fines generales que es modular y conectable.

El comportamiento por defecto de CoreDNS está controlado por un archivo de configuración denominado Corefile. Corefile es un mapa de configuración de Kubernetes, con una sección Corefile que define el comportamiento de CoreDNS. No puede modificar Corefile directamente. Si necesita personalizar el comportamiento de CoreDNS, cree y aplique su propio mapa de configuración para sustituir la configuración del archivo principal (como se describe en este tema). Tenga en cuenta que con los clusters básicos, si personaliza el comportamiento por defecto CoreDNS, las personalizaciones se suprimen periódicamente durante las actualizaciones internas del cluster (con los clusters mejorados, las personalizaciones no se suprimen).

Al actualizar un cluster creado por Container Engine for Kubernetes desde una versión anterior a Kubernetes 1.14 o posterior, el servidor kube-dns del cluster se sustituye automáticamente por el servidor CoreDNS. Tenga en cuenta que si personaliza el comportamiento kube-dns mediante el mapa de configuración de kube-dns original, esas personalizaciones no se transfieren al mapa de configuración de CoreDNS. Tendrá que crear y aplicar un nuevo mapa de configuración que contenga las personalizaciones para sustituir la configuración en el archivo del núcleo central de CoreDNS.

Para obtener más información sobre la personalización de CoreDNS y Kubernetes, consulte la documentación de Kubernetes y la documentación de CoreDNS.

Para crear un mapa de configuración que sustituya la configuración del archivo de núcleo de CoreDNS:

  1. Defina un mapa de configuarción en un archivo yaml con el formato:

    apiVersion: v1
kind: ConfigMap
metadata:  
  name: coredns-custom  
  namespace: kube-system 
data:
  <customization-options>

    Por ejemplo:

    apiVersion: v1
kind: ConfigMap
metadata:  
  name: coredns-custom  
  namespace: kube-system 
data:
  example.server: | # All custom server files must have a ".server" file extension. 
    # Change example.com to the domain you wish to forward.
    example.com {
      # Change 1.1.1.1 to your customer DNS resolver.
      forward . 1.1.1.1
    }

    Para obtener más información sobre las opciones de mapa de configuración que se deben utilizar para personalizar el comportamiento de CoreDNS, consulte la documentación de Kubernetes y la documentación de CoreDNS.

  2. Cree ConfigMap introduciendo:

    kubectl apply -f <filename>.yaml

  3. Verifique que las personalizaciones se han aplicado introduciendo:

    kubectl get configmaps --namespace=kube-system coredns-custom -o yaml

  4. Fuerce a CoreDNS a volver a cargar ConfigMap introduciendo:

    kubectl delete pod --namespace kube-system -l k8s-app=kube-dns

Configuración de ExternalDNS para utilizar Oracle Cloud Infrastructure DNS

ExternalDNS es un complemento de Kubernetes que puede crear registros de DNS para servicios en proveedores de DNS externos a Kubernetes. Define registros de DNS en un proveedor de DNS externo para que los servicios de Kubernetes se puedan detectar mediante ese proveedor de DNS, y permite controlar los registros de DNS de forma dinámica. Consulte ExternalDNS para obtener más información.

Tras desplegar ExternalDNS en un cluster, puede exponer un servicio que se ejecuta en el cluster agregando la anotación external-dns.alpha.kubernetes.io/hostname al servicio. ExternalDNS crea un registro de DNS para el servicio en el proveedor de DNS externo que ha configurado para el cluster.

ExternalDNS no es en sí mismo un servidor DNS como CoreDNS, sino una forma de configurar otros proveedores de DNS externos. Oracle Cloud Infrastructure DNS es uno de esos proveedores de DNS externos. Consulte Descripción general de DNS.

Para mayor comodidad, a continuación se incluyen instrucciones para configurar ExternalDNS en un cluster y configurarlo para que utilice Oracle Cloud Infrastructure DNS. Estas instrucciones son un resumen basado en el tutorial Setting up ExternalDNS for Oracle Cloud Infrastructure (OCI), que está disponible en GitHub.

Para configurar ExternalDNS en un cluster y configurarlo para que utilice Oracle Cloud Infrastructure DNS:

  1. Cree una nueva zona de DNS en Oracle Cloud Infrastructure DNS para contener los registros de DNS que ExternalDNS creará para el cluster. Consulte Creación de una zona.
  2. Si todavía no lo ha hecho, siga los pasos para configurar el archivo de configuración kubeconfig del cluster y (si es necesario) defina la variable de entorno KUBECONFIG para que apunte al archivo. Tenga en cuenta que debe configurar su propio archivo kubeconfig. No puede acceder a un cluster utilizando un archivo kubeconfig que haya configurado un usuario diferente. Consulte Configuración del acceso a los clusters.
  3. Cree un secreto de Kubernetes que contenga los detalles de autenticación de usuario de Oracle Cloud Infrastructure que ExternalDNS utilizará al conectarse a la API de Oracle Cloud Infrastructure para insertar y actualizar los registros de DNS en la zona de DNS que acaba de crear.
    1. En un editor de texto, cree un archivo de credenciales que contenga las credenciales de usuario de Oracle Cloud Infrastructure para acceder a la zona de DNS:
      auth:
  region: <region-identifier>
  tenancy: <tenancy-ocid>
  user: <user-ocid>
  key: |
    -----BEGIN RSA PRIVATE KEY-----
   <private-key>
    -----END RSA PRIVATE KEY-----
  fingerprint: <fingerprint>
  # Omit if there is not a password for the key
  passphrase: <passphrase>
compartment: <compartment-ocid>

      donde:

      • <region-identifer> identifica la región del usuario. Por ejemplo, us-phoenix-1
      • <tenancy-ocid> es el OCID del arrendamiento del usuario. Por ejemplo, ocid1.tenancy.oc1..aaaaaaaap...keq (abreviado para leerse mejor).
      • <user-ocid> es el OCID del usuario. Por ejemplo, ocid1.user.oc1..aaaaa...zutq (abreviado para leerse mejor).
      • <private-key> es una clave RSA, que empieza por -----BEGIN RSA PRIVATE KEY----- y termina por -----END RSA PRIVATE KEY-----
      • passphrase: <passphrase> proporciona opcionalmente la frase de contraseña para la clave, si existe.
      • <compartment-ocid> es el OCID del compartimento al que pertenece la zona de DNS.
      Por ejemplo:
      auth:
  region: us-phoenix-1
  tenancy: ocid1.tenancy.oc1..aaaaaaaap...keq
  user: ocid1.user.oc1..aaaaa...zutq
  key: |
    -----BEGIN RSA PRIVATE KEY-----
    this-is-not-a-secret_Ef8aiAk7+I0...
    -----END RSA PRIVATE KEY-----
  fingerprint: bg:92:82:9f...
  # Omit if there is not a password for the key
  passphrase: Uy2kSl...
compartment: ocid1.compartment.oc1..aaaaaaaa7______ysq
    2. Guarde el archivo de credenciales con el nombre que desee (por ejemplo, oci-creds.yaml).
    3. Cree un secreto de Kubernetes desde el archivo de credenciales que acaba de crear introduciendo:
      kubectl create secret generic <secret-name> --from-file=<credential-filename>

      Por ejemplo:

      kubectl create secret generic external-dns-config --from-file=oci-creds.yaml
  4. Despliegue ExternalDNS en el cluster.
    1. En un editor de texto, cree un archivo de configuración (por ejemplo, denominado external-dns-deployment.yaml) para crear el despliegue de ExternalDNS y especifique el nombre del secreto de Kubernetes que acaba de crear. Por ejemplo:
      apiVersion: v1
kind: ServiceAccount
metadata:
  name: external-dns
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: external-dns
rules:
- apiGroups: [""]
  resources: ["services","endpoints","pods"]
  verbs: ["get","watch","list"]
- apiGroups: ["extensions","networking.k8s.io"]
  resources: ["ingresses"]
  verbs: ["get","watch","list"]
- apiGroups: [""]
  resources: ["nodes"]
  verbs: ["list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: external-dns-viewer
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: external-dns
subjects:
- kind: ServiceAccount
  name: external-dns
  namespace: default
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: external-dns
spec:
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app: external-dns
  template:
    metadata:
      labels:
        app: external-dns
    spec:
      serviceAccountName: external-dns
      containers:
      - name: external-dns
        image: k8s.gcr.io/external-dns/external-dns:v0.7.3
        args:
        - --source=service
        - --source=ingress
        - --provider=oci
        - --policy=upsert-only # prevent ExternalDNS from deleting any records, omit to enable full synchronization
        - --txt-owner-id=my-identifier
        volumeMounts:
          - name: config
            mountPath: /etc/kubernetes/
      volumes:
      - name: config
        secret:
          secretName: external-dns-config
    2. Guarde y cierre el archivo de configuración.
    3. Aplique el archivo de configuración para desplegar ExternalDNS introduciendo:
      kubectl apply -f <filename>

      donde <filename> es el nombre del archivo creado anteriormente. Por ejemplo:

      kubectl apply -f external-dns-deployment.yaml

      La salida del comando anterior confirma el despliegue:

      serviceaccount/external-dns created
clusterrole.rbac.authorization.k8s.io/external-dns created
clusterrolebinding.rbac.authorization.k8s.io/external-dns-viewer created
deployment.apps/external-dns created
  5. Verifique que ExternalDNS se ha desplegado correctamente y que puede insertar registros en la zona de DNS creada anteriormente en Oracle Cloud Infrastructure mediante la creación de un despliegue de nginx y un servicio de nginx:
    1. En un editor de texto, cree un archivo de configuración (por ejemplo, denominado nginx-externaldns.yaml) para crear un despliegue de nginx y un servicio de nginx que incluya la anotación external-dns.alpha.kubernetes.io/hostname. Por ejemplo:
      apiVersion: v1
kind: Service
metadata:
  name: nginx
  annotations:
    external-dns.alpha.kubernetes.io/hostname: example.com
spec:
  type: LoadBalancer
  ports:
  - port: 80
    name: http
    targetPort: 80
  selector:
    app: nginx
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx
        name: nginx
        ports:
        - containerPort: 80
          name: http
    2. Aplique el archivo de configuración para crear el servicio de nginx y el despliegue introduciendo:
      kubectl apply -f <filename>

      donde <filename> es el nombre del archivo creado anteriormente. Por ejemplo:

      kubectl apply -f nginx-externaldns.yaml

      La salida del comando anterior confirma el despliegue:

      service/nginx created
deployment.apps/nginx created
    3. Espere un par de minutos y, a continuación, compruebe que se ha creado un registro de DNS para el servicio de nginx en la zona de DNS de Oracle Cloud Infrastructure (consulte Zonas).