Documentation Oracle Cloud Infrastructure

Configuration des serveurs DNS pour les clusters Kubernetes

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

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

Les clusters créés par le moteur Kubernetes incluent un serveur DNS en tant que service Kubernetes intégré lancé automatiquement. Le processus kubelet sur chaque noeud de processus actif dirige les différents conteneurs vers le serveur DNS en vue de la conversion des noms DNS en adresses IP.

Avant Kubernetes version 1.14, Kubernetes Engine créait des clusters avec kube-dns en tant que serveur DNS. Depuis la version 1.14 de Kubernetes toutefois, Kubernetes Engine crée des clusters avec CoreDNS en tant que serveur DNS. CoreDNS est un serveur DNS autorisé à usage général. Il est modulaire et pluggable.

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

Lorsque vous mettez à niveau un cluster créé par Kubernetes Engine à partir d'une version antérieure à Kubernetes 1.14, le serveur kube-dns du cluster est automatiquement remplacé par le serveur CoreDNS. Si vous avez personnalisé le comportement de kube-dns à l'aide de l'objet ConfigMap kube-dns d'origine, les personnalisations ne sont pas transférées vers l'objet ConfigMap CoreDNS. Vous devrez créer et appliquer un objet ConfigMap contenant les personnalisations pour remplacer les paramètres du fichier Corefile CoreDNS.

Pour plus d'informations sur la personnalisation CoreDNS et sur Kubernetes, reportez-vous à la Documentation Kubernetes et à la Documentation du module d'extension CoreDNS.

Pour créer un objet ConfigMap afin de remplacer les paramètres du fichier Corefile CoreDNS, procédez comme suit :

  1. Définissez un objet ConfigMap dans un fichier YAML, au 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 afin de personnaliser le comportement de CoreDNS, reportez-vous à la documentation Kubernetes et à la documentation du module d'extension CoreDNS.

  2. Créez l'objet ConfigMap en saisissant ce qui suit :

    kubectl apply -f <filename>.yaml

  3. Vérifiez que les personnalisations ont été appliquées en saisissant ce qui suit :

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

  4. Forcez CoreDNS à recharger l'objet ConfigMap en saisissant ce qui suit :

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

Configuration d'ExternalDNS pour utiliser Oracle Cloud Infrastructure DNS

ExternalDNS est une extension de Kubernetes qui peut créer des enregistrements DNS pour des services dans des fournisseurs DNS externes à Kubernetes. Elle configure des enregistrements DNS dans un fournisseur DNS externe pour rendre les services Kubernetes repérables via ce fournisseur DNS et vous permet de contrôler les enregistrements DNS de manière dynamique. Pour plus d'informations, reportez-vous à ExternalDNS.

Une fois ExternalDNS déployé sur un cluster, vous pouvez exposer un service exécuté sur le cluster 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 le cluster.

ExternalDNS n'est pas un serveur DNS en soi comme CoreDNS, mais un moyen de configurer d'autres fournisseurs DNS externes. Oracle Cloud Infrastructure DNS est l'un de ces fournisseurs DNS externes. Reportez-vous à Présentation de DNS.

Pour plus de commodité, des instructions sont fournies ci-dessous afin de configurer ExternalDNS sur un cluster et de le configurer pour utiliser Oracle Cloud Infrastructure DNS. Ces instructions récapitulent le tutoriel relatif à la configuration d'ExternalDNS pour Oracle Cloud Infrastructure (OCI) disponible sur GitHub.

Pour configurer ExternalDNS sur un cluster et le configurer de sorte à utiliser Oracle Cloud Infrastructure DNS, procédez comme suit :

  1. Créez une zone DNS dans Oracle Cloud Infrastructure DNS pour contenir les enregistrements DNS créés par ExternalDNS pour le cluster. Reportez-vous à Création d'une zone.
  2. Si vous ne l'avez pas encore fait, suivez les étapes permettant de configurer le fichier de configuration Kubeconfig du cluster et (si nécessaire) de définir la variable d'environnement KUBECONFIG de sorte qu'elle pointe vers le fichier. Vous devez configurer votre propre fichier Kubeconfig. Vous ne pouvez pas accéder à un cluster à l'aide d'un fichier Kubeconfig configuré par un autre utilisateur. Reportez-vous à Configuration de l'accès à un cluster.
  3. Créez une clé secrète Kubernetes contenant les détails d'authentification utilisateur Oracle Cloud Infrastructure pour ExternalDNS à utiliser lors de la connexion à l'API Oracle Cloud Infrastructure afin d'insérer et de mettre à jour les enregistrements DNS dans la zone DNS que vous venez de créer.
    1. Dans un éditeur de texte, créez un fichier d'informations d'identification contenant les informations d'identification 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 plus de 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> fournit éventuellement la phrase de passe de la clé, le cas échéant.
      • <compartment-ocid> est l'OCID du compartiment auquel appartient la zone DNS.
      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 d'informations d'identification sous le nom de votre choix (par exemple, oci-creds.yaml).
    3. Créez une clé secrète Kubernetes à partir du fichier d'informations d'identification que vous venez de créer, en saisissant ce qui suit :
      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 sur le cluster.
    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 indiquez 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 saisissant ce qui suit :
      kubectl apply -f <filename>

      où <filename> est le nom du fichier 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é et qu'il 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 nginx et un service nginx :
    1. Dans un éditeur de texte, créez un fichier de configuration (par exemple, nginx-externaldns.yaml) pour créer un déploiement nginx et un service nginx comprenant 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 déploiement et le service nginx en saisissant ce qui suit :
      kubectl apply -f <filename>

      où <filename> est le nom du fichier 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 (reportez-vous à Zones).