Documentation sur Oracle Cloud Infrastructure

Configuration des serveurs DNS pour les grappes Kubernetes

Découvrez comment configurer des serveurs DNS pour les grappes Kubernetes que vous avez créées à l'aide de Kubernetes Engine (OKE).

Configuration des serveurs DNS intégrés (kube-dns, CoreDNS)

Les grappes créées par Kubernetes Engine comprennent un serveur DNS en tant que service Kubernetes intégré lancé automatiquement. Le processus kubelet de chaque noeud de travail dirige les conteneurs individuels vers le serveur DNS pour convertir les noms DNS en adresses IP.

Avant la version Kubernetes 1.14, Kubernetes Engine créait des grappes avec kube-dns comme serveur DNS. Cependant, à partir de la version 1.14 de Kubernetes, Kubernetes Engine crée des grappes avec CoreDNS comme serveur DNS. CoreDNS est un serveur DNS faisant autorité, polyvalent, modulaire et enfichable.

Le comportement par défaut de CoreDNS est contrôlé par un fichier de configuration appelé Corefile. Le Corefile est un ConfigMap Kubernetes comportant une section Corefile qui définit le comportement de CoreDNS. Vous ne pouvez pas modifier directement le Corefile. Si vous devez personnaliser le comportement de CoreDNS, créez et appliquez votre propre ConfigMap pour remplacer les paramètres du Corefile (comme décrit dans cette rubrique). Notez qu'avec les grappes de base, si vous personnalisez le comportement par défaut de CoreDNS, les personnalisations sont supprimées régulièrement lors des mises à jour internes de la grappe (avec des grappes améliorées, les personnalisations ne sont pas supprimées).

Lorsque vous mettez à niveau une grappe créée par Kubernetes Engine d'une version antérieure vers Kubernetes version 1.14 ou ultérieure, le serveur kube-dns de la grappe est automatiquement remplacé par le serveur CoreDNS. Notez que si vous avez personnalisé le comportement de kube-dns à l'aide du ConfigMap kube-dns initial, ces personnalisations ne sont pas reportées dans le ConfigMap CoreDNS. Vous devez créer et appliquer un nouveau ConfigMap contenant les personnalisations pour remplacer les paramètres du fichier Corefile CoreDNS.

Pour plus d'informations sur la personnalisation CoreDNS et Kubernetes, consultez la Kubernetes et la CoreDNS documentation sur le plugiciel.

Pour créer un ConfigMap pour remplacer les paramètres du Corefile CoreDNS :

  1. Définissez un ConfigMap dans un fichier yaml, avec le format suivant :

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

    Par exemple :

    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
    }

    Pour plus d'informations sur les options ConfigMap à utiliser pour personnaliser le comportement de CoreDNS, consultez la documentation sur Kubernetes et la documentation sur le plugiciel CoreDNS.

  2. Créez le ConfigMap en entrant :

    kubectl apply -f <filename>.yaml

  3. Vérifiez que les personnalisations ont été appliquées en entrant :

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

  4. Forcez CoreDNS à recharger le ConfigMap en entrant :

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

Configuration d'ExternalDNS pour l'utilisation du service DNS pour Oracle Cloud Infrastructure

ExternalDNS est un module complémentaire de Kubernetes qui peut créer des enregistrements DNS pour les services des fournisseurs DNS externes à Kubernetes. Il configure des enregistrements DNS dans un fournisseur DNS externe pour que les services Kubernetes puissent être détectés par l'intermédiaire de ce fournisseur DNS, et vous permet de contrôler dynamiquement les enregistrements DNS. Pour plus d'informations, voir ExternalDNS.

Après avoir déployé ExternalDNS dans une grappe, vous pouvez exposer un service exécuté dans la grappe en ajoutant l'annotation external-dns.alpha.kubernetes.io/hostname au service. ExternalDNS crée un enregistrement DNS pour le service dans le fournisseur DNS externe que vous avez configuré pour la grappe.

ExternalDNS n'est pas en soi un serveur DNS comme CoreDNS, mais un moyen de configurer d'autres fournisseurs DNS externes. Le service DNS pour Oracle Cloud Infrastructure est l'un de ces fournisseurs DNS externes. Voir Aperçu du service DNS.

Pour plus de commodité, des instructions sont incluses ci-dessous pour configurer ExternalDNS sur une grappe et la configurer pour utiliser Oracle Cloud Infrastructure DNS. Ces instructions sont un résumé basé sur le tutoriel Configuration d'ExternalDNS pour Oracle Cloud Infrastructure (OCI), disponible sur la page GitHub.

Pour configurer ExternalDNS dans une grappe et le configurer pour l'utilisation du service DNS pour Oracle Cloud Infrastructure :

  1. Créez une nouvelle zone DNS dans le service DNS pour Oracle Cloud Infrastructure pour accueillir les enregistrements DNS créés par ExternalDNS pour la grappe. Voir Création d'une zone.
  2. Si vous ne l'avez pas encore fait, suivez les étapes pour configurer le fichier de configuration kubeconfig de la grappe et (s'il y a lieu) définissez la variable d'environnement KUBECONFIG pour qu'elle pointe vers le fichier. Notez que vous devez configurer votre propre fichier kubeconfig. Vous ne pouvez pas accéder à une grappe à l'aide d'un fichier kubeconfig configuré par un autre utilisateur. Voir Configuration de l'accès aux grappes.
  3. Créez une clé secrète Kubernetes contenant les informations d'authentification d'utilisateur Oracle Cloud Infrastructure pour ExternalDNS à utiliser lors de la connexion à l'API Oracle Cloud Infrastructure pour insérer et mettre à jour des enregistrements DNS dans la zone DNS que vous venez de créer.
    1. Dans un éditeur de texte, créez un fichier de données d'identification contenant les données d'identification d'utilisateur Oracle Cloud Infrastructure à utiliser pour accéder à la zone 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>

      où :

      • <region-identifer> identifie la région de l'utilisateur. Par exemple, us-phoenix-1
      • <tenancy-ocid> est l'OCID de la location de l'utilisateur. Par exemple, ocid1.tenancy.oc1..aaaaaaaap...keq (abrégé pour une meilleure lisibilité).
      • <user-ocid> est l'OCID de l'utilisateur. Par exemple, ocid1.user.oc1..aaaaa...zutq (abrégé pour plus de lisibilité).
      • <private-key> est une clé RSA.
      • passphrase: <passphrase> indique la phrase secrète de la clé, si elle existe
      • <compartment-ocid> est l'OCID du compartiment auquel la zone DNS appartient
      Par exemple :
      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. Enregistrez le fichier de données d'identification sous le nom de votre choix (par exemple oci-creds.yaml).
    3. Créez une clé secrète Kubernetes à partir du fichier de données d'identification que vous venez de créer, en entrant :
      kubectl create secret generic <secret-name> --from-file=<credential-filename>

      Par exemple :

      kubectl create secret generic external-dns-config --from-file=oci-creds.yaml
  4. Déployez ExternalDNS dans la grappe.
    1. Dans un éditeur de texte, créez un fichier de configuration (par exemple external-dns-deployment.yaml) pour créer le déploiement ExternalDNS et spécifiez le nom de la clé secrète Kubernetes que vous venez de créer. Par exemple :
      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. Enregistrez et fermez le fichier de configuration.
    3. Appliquez le fichier de configuration pour déployer ExternalDNS en entrant :
      kubectl apply -f <filename>

      où <filename> est le nom du fichier que vous avez créé précédemment. Par exemple :

      kubectl apply -f external-dns-deployment.yaml

      La sortie de la commande ci-dessus confirme le déploiement :

      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. Vérifiez qu'ExternalDNS a été déployé avec succès et peut insérer des enregistrements dans la zone DNS que vous avez créée précédemment dans Oracle Cloud Infrastructure en créant un déploiement et un service nginx :
    1. Dans un éditeur de texte, créez un fichier de configuration (nommé nginx-externaldns.yaml, par exemple) pour créer un déploiement et un service nginx comportant l'annotation external-dns.alpha.kubernetes.io/hostname. Par exemple :
      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. Appliquez le fichier de configuration pour créer le service et le déploiement nginx en entrant :
      kubectl apply -f <filename>

      où <filename> est le nom du fichier que vous avez créé précédemment. Par exemple :

      kubectl apply -f nginx-externaldns.yaml

      La sortie de la commande ci-dessus confirme le déploiement :

      service/nginx created
deployment.apps/nginx created
    3. Patientez quelques minutes, puis vérifiez qu'un enregistrement DNS a été créé pour le service nginx dans la zone Oracle Cloud Infrastructure DNS (voir Zones).