Documentazione di Oracle Cloud Infrastructure

Configurazione dei server DNS per i cluster Kubernetes

Scopri come configurare i server DNS per i cluster Kubernetes creati utilizzando Kubernetes Engine (OKE).

Configurazione dei server DNS integrati (kube-dns, CoreDNS)

I cluster creati da Kubernetes Engine includono un server DNS come servizio Kubernetes integrato che viene avviato automaticamente. Il processo kubelet su ogni nodo di lavoro indirizza i singoli container al server DNS per tradurre i nomi DNS in indirizzi IP.

Prima di Kubernetes versione 1.14, Kubernetes Engine creava cluster con kube-dns come server DNS. Tuttavia, da Kubernetes versione 1.14 in poi, Kubernetes Engine crea cluster con CoreDNS come server DNS. CoreDNS è un server DNS affidabile e di uso generale, modulare e integrabile.

Il comportamento predefinito di CoreDNS è controllato da un file di configurazione denominato Corefile. Corefile è un file ConfigMap Kubernetes con una sezione Corefile che definisce il comportamento CoreDNS. Non è possibile modificare direttamente il file core. Se è necessario personalizzare il comportamento di CoreDNS, creare e applicare il proprio ConfigMap per sostituire le impostazioni nel file core (come descritto in questo argomento). Tenere presente che con i cluster di base, se si personalizza il comportamento predefinito CoreDNS, le personalizzazioni vengono eliminate periodicamente durante gli aggiornamenti interni al cluster (con cluster avanzati, le personalizzazioni non vengono eliminate).

Quando si aggiorna un cluster creato da Kubernetes Engine da una versione precedente a Kubernetes 1.14 o versione successiva, il server kube-dns del cluster viene sostituito automaticamente con il server CoreDNS. Tenere presente che se si è personalizzato il comportamento di kube-dns utilizzando l'originale kube-dns ConfigMap, tali personalizzazioni non vengono riportate all'indirizzo CoreDNS ConfigMap. Sarà necessario creare e applicare un nuovo file ConfigMap contenente le personalizzazioni per eseguire l'override delle impostazioni nel file core CoreDNS.

Per ulteriori informazioni sulla personalizzazione CoreDNS e su Kubernetes, consulta la documentazione di Kubernetes e la documentazione del plugin CoreDNS.

Per creare un file ConfigMap per eseguire l'override delle impostazioni nel file core CoreDNS:

  1. Definire un file ConfigMap in un file yaml nel formato:

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

    Ad esempio:

    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
    }

    Per ulteriori informazioni sulle opzioni ConfigMap da utilizzare per personalizzare il comportamento CoreDNS, consultare la documentazione di Kubernetes e la documentazione del plugin CoreDNS.

  2. Creare il file ConfigMap immettendo:

    kubectl apply -f <filename>.yaml

  3. Verificare che le personalizzazioni siano state applicate immettendo:

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

  4. Forzare CoreDNS a ricaricare il file ConfigMap immettendo:

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

Configurazione di ExternalDNS per utilizzare Oracle Cloud Infrastructure DNS

ExternalDNS è un componente aggiuntivo di Kubernetes in grado di creare record DNS per i servizi nei provider DNS esterni a Kubernetes. Imposta i record DNS in un provider DNS esterno per rendere i servizi Kubernetes rilevabili tramite tale provider DNS e ti consente di controllare i record DNS in modo dinamico. Vedere ExternalDNS.

Dopo aver distribuito ExternalDNS su un cluster, è possibile esporre un servizio in esecuzione sul cluster aggiungendo l'annotazione external-dns.alpha.kubernetes.io/hostname al servizio. ExternalDNS crea un record DNS per il servizio nel provider DNS esterno configurato per il cluster.

ExternalDNS non è di per sé un server DNS come CoreDNS, ma un modo per configurare altri provider DNS esterni. Oracle Cloud Infrastructure DNS è uno di questi provider DNS esterni. Vedere Panoramica del DNS.

Per comodità, sono incluse le istruzioni riportate di seguito per impostare ExternalDNS su un cluster e configurarlo in modo che utilizzi Oracle Cloud Infrastructure DNS. Queste istruzioni sono un riepilogo basato sull'esercitazione sull'impostazione di ExternalDNS per Oracle Cloud Infrastructure (OCI), disponibile sul sito GitHub.

Per impostare ExternalDNS su un cluster e configurarlo in modo che utilizzi Oracle Cloud Infrastructure DNS:

  1. Creare una nuova zona DNS in Oracle Cloud Infrastructure DNS per contenere i record DNS che ExternalDNS creerà per il cluster. Vedere Creazione di una zona.
  2. Se non è già stato fatto, attenersi alla procedura per impostare il file di configurazione kubeconfig del cluster e (se necessario) impostare la variabile di ambiente KUBECONFIG in modo che punti al file. Si noti che è necessario impostare il proprio file kubeconfig. Non è possibile accedere a un cluster utilizzando un file kubeconfig impostato da un altro utente. Vedere Impostazione dell'accesso al cluster.
  3. Crea un segreto Kubernetes contenente i dettagli di autenticazione utente di Oracle Cloud Infrastructure da utilizzare per ExternalDNS durante la connessione all'API di Oracle Cloud Infrastructure per inserire e aggiornare i record DNS nella zona DNS appena creata.
    1. In un editor di testo, creare un file di credenziali contenente le credenziali utente di Oracle Cloud Infrastructure da utilizzare per accedere alla zona 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>

      Dove:

      • <region-identifer> identifica l'area dell'utente. Ad esempio, us-phoenix-1
      • <tenancy-ocid> è l'OCID della tenancy dell'utente. Ad esempio, ocid1.tenancy.oc1..aaaaaaaap...keq (abbreviato per leggibilità).
      • <user-ocid> è l'OCID dell'utente. Ad esempio, ocid1.user.oc1..aaaaa...zutq (abbreviato per leggibilità).
      • <private-key> è una chiave RSA.
      • passphrase: <passphrase> fornisce facoltativamente la passphrase per la chiave, se presente
      • <compartment-ocid> è l'OCID del compartimento a cui appartiene la zona DNS
      Ad esempio:
      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. Salvare il file delle credenziali con il nome desiderato (ad esempio, oci-creds.yaml).
    3. Creare un segreto Kubernetes dal file delle credenziali appena creato immettendo:
      kubectl create secret generic <secret-name> --from-file=<credential-filename>

      Ad esempio:

      kubectl create secret generic external-dns-config --from-file=oci-creds.yaml
  4. Distribuire ExternalDNS sul cluster.
    1. In un editor di testo, creare un file di configurazione (ad esempio, denominato external-dns-deployment.yaml) per creare la distribuzione ExternalDNS e specificare il nome del segreto Kubernetes appena creato. Ad esempio:
      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. Salvare e chiudere il file di configurazione.
    3. Applicare il file di configurazione per distribuire ExternalDNS immettendo:
      kubectl apply -f <filename>

      dove <filename> è il nome del file creato in precedenza. Ad esempio:

      kubectl apply -f external-dns-deployment.yaml

      L'output del comando precedente conferma la distribuzione:

      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. Verificare che la distribuzione di ExternalDNS sia riuscita e che sia possibile inserire record nella zona DNS creata in precedenza in Oracle Cloud Infrastructure creando una distribuzione nginx e un servizio nginx.
    1. In un editor di testo, creare un file di configurazione (ad esempio, nginx-externaldns.yaml) per creare una distribuzione nginx e un servizio nginx che includa l'annotazione external-dns.alpha.kubernetes.io/hostname. Ad esempio:
      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. Applicare il file di configurazione per creare il servizio e la distribuzione nginx immettendo:
      kubectl apply -f <filename>

      dove <filename> è il nome del file creato in precedenza. Ad esempio:

      kubectl apply -f nginx-externaldns.yaml

      L'output del comando precedente conferma la distribuzione:

      service/nginx created
deployment.apps/nginx created
    3. Attendere alcuni minuti, quindi verificare che sia stato creato un record DNS per il servizio nginx nella zona Oracle Cloud Infrastructure DNS (vedere Zone).