Oracle Cloud Infrastructure - Dokumentation

DNS-Server für Kubernetes-Cluster konfigurieren

Erfahren Sie, wie Sie DNS-Server für Kubernetes-Cluster konfigurieren, die Sie mit der Kubernetes Engine (OKE) erstellt haben.

Integrierte DNS-Server (kube-dns, CoreDNS) konfigurieren

Cluster, die von der Kubernetes-Engine erstellt wurden, enthalten einen DNS-Server als integrierten Kubernetes-Service, der automatisch gestartet wird. Der kubelet-Prozess auf jedem Worker-Knoten leitet einzelne Container an den DNS-Server weiter, um DNS-Namen in IP-Adressen zu übersetzen.

Vor Kubernetes-Version 1.14 hat Kubernetes Engine Cluster mit kube-dns als DNS-Server erstellt. Kubernetes Engine erstellt jedoch ab Kubernetes-Version 1.14 Cluster mit CoreDNS als DNS-Server. CoreDNS ist ein übergeordneter autoritativer DNS-Server, der modular und integrierbar ist.

Das Standardverhalten von CoreDNS wird von einer Konfigurationsdatei gesteuert, die als Coredatei bezeichnet wird. Die Coredatei ist ein Kubernetes-ConfigMap-Objekt mit einem Coredateiabschnitt, der CoreDNS-Verhalten definiert. Sie können die Coredatei nicht direkt ändern. Falls Sie das CoreDNS-Verhalten anpassen müssen, erstellen Sie Ihr eigenes ConfigMap-Objekt, und wenden Sie es an, um Einstellungen in der Coredatei außer Kraft zu setzen (wie in diesem Thema beschrieben). Beachten Sie, dass Anpassungen des CoreDNS-Standardverhaltens bei grundlegenden Clustern regelmäßig bei internen Aktualisierungen des Clusters gelöscht werden (bei erweiterten Clustern werden Anpassungen nicht gelöscht).

Wenn Sie ein von der Kubernetes-Engine erstelltes Cluster von einer früheren Version auf Kubernetes 1.14 oder höher aktualisieren, wird der kube-dns-Server des Clusters automatisch durch den CoreDNS-Server ersetzt. Beachten Sie, dass diese Anpassungen nicht an das CoreDNS-ConfigMap-Objekt übertragen werden, wenn Sie das kube-dns-Verhalten mit dem ursprünglichen kube-dns-ConfigMap-Objekt angepasst haben. Sie müssen ein neues ConfigMap-Objekt erstellen und anwenden, das die Anpassungen enthält, um die Einstellungen in der CoreDNS-Coredatei außer Kraft zu setzen.

Weitere Informationen zu CoreDNS-Anpassung und Kubernetes finden Sie in der Kubernetes-Dokumentation und in der Dokumentation zum CoreDNS-Plug-in.

So erstellen Sie ein ConfigMap-Objekt, um die Einstellungen in der CoreDNS-Coredatei außer Kraft zu setzen:

  1. Definieren Sie ein ConfigMap-Objekt in einer YAML-Datei mit dem Format:

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

    Beispiel:

    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
    }

    Weitere Informationen zu den ConfigMap-Optionen zur Anpassung des CoreDNS-Verhaltens finden Sie in der Kubernetes-Dokumentation und in der CoreDNS-Plug-in-Dokumentation.

  2. Erstellen Sie das ConfigMap-Objekt, indem Sie Folgendes eingeben:

    kubectl apply -f <filename>.yaml

  3. Prüfen Sie, ob die Anpassungen angewendet wurden, indem Sie Folgendes eingeben:

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

  4. Erzwingen Sie, dass CoreDNS das ConfigMap-Objekt neu lädt, indem Sie Folgendes eingeben:

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

ExternalDNS für die Verwendung von Oracle Cloud Infrastructure DNS konfigurieren

ExternalDNS ist ein Add-on zu Kubernetes, das DNS-Datensätze für Services in DNS-Providern außerhalb von Kubernetes erstellen kann. Es richtet DNS-Datensätze in einem externen DNS-Provider ein, damit die Kubernetes-Services über diesen DNS-Provider gefunden werden können. Außerdem können Sie mit diesem Add-on DNS-Datensätze dynamisch kontrollieren. Weitere Informationen finden Sie unter ExternalDNS.

Nach dem Deployment von ExternalDNS in einem Cluster können Sie einen Service bereitstellen, der auf dem Cluster ausgeführt wird, indem Sie dem Service die Annotation external-dns.alpha.kubernetes.io/hostname hinzufügen. ExternalDNS erstellt einen DNS-Datensatz für den Service im externen DNS-Provider, den Sie für das Cluster konfiguriert haben.

ExternalDNS ist an sich kein DNS-Server wie CoreDNS, sondern eine Möglichkeit, andere externe DNS-Provider zu konfigurieren. Oracle Cloud Infrastructure DNS ist ein solcher externer DNS-Provider. Siehe Überblick über DNS.

Im Folgenden finden Sie Anweisungen, wie Sie ExternalDNS auf einem Cluster einrichten und für die Verwendung von Oracle Cloud Infrastructure DNS konfigurieren können. Diese Anweisungen sind eine Zusammenfassung des Tutorials zur Einrichtung von ExternalDNS für Oracle Cloud Infrastructure (OCI), das auf GitHub verfügbar ist.

So richten Sie ExternalDNS auf einem Cluster ein und konfigurieren es für die Verwendung von Oracle Cloud Infrastructure DNS:

  1. Erstellen Sie eine neue DNS-Zone in Oracle Cloud Infrastructure DNS. Diese DNS-Zone soll die DNS-Datensätze enthalten, die ExternalDNS für das Cluster erstellt. Siehe Zonen erstellen.
  2. Falls noch nicht geschehen, führen Sie die Schritte zum Einrichten der kubeconfig-Konfigurationsdatei des Clusters aus, und legen Sie (gegebenenfalls) die Umgebungsvariable KUBECONFIG so fest, dass sie auf die Datei verweist. Beachten Sie, dass Sie Ihre eigene kubeconfig-Datei einrichten müssen. Sie können nicht mit einer kubeconfig-Datei, die von einem anderen Benutzer eingerichtet wurde, auf ein Cluster zugreifen. Siehe Clusterzugriff einrichten.
  3. Erstellen Sie ein Kubernetes-Secret mit den Oracle Cloud Infrastructure-Benutzerauthentifizierungsdetails für ExternalDNS, die für die Verbindung zur Oracle Cloud Infrastructure-API verwendet werden sollen, um DNS-Datensätze in der soeben erstellten DNS-Zone einzufügen und zu aktualisieren.
    1. Erstellen Sie in einem Texteditor eine Zugangsdatendatei mit den Oracle Cloud Infrastructure-Benutzerzugangsdaten für den Zugriff auf die DNS-Zone:
      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>

      Hierbei gilt:

      • <region-identifer> gibt die Region des Benutzers an. Beispiel: us-phoenix-1.
      • <tenancy-ocid> ist die OCID des Mandanten des Benutzers. Beispiel: ocid1.tenancy.oc1..aaaaaaaap...keq (zur besseren Lesbarkeit abgekürzt).
      • <user-ocid> ist die OCID des Benutzers. Beispiel: ocid1.user.oc1..aaaaa...zutq (zur besseren Lesbarkeit abgekürzt).
      • <private-key> ist ein RSA-Schlüssel.
      • passphrase: <passphrase> gibt optional die Passphrase für den Schlüssel an, falls vorhanden.
      • <compartment-ocid> ist die OCID des Compartments, zu dem die DNS-Zone gehört.
      Beispiel:
      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. Speichern Sie die Zugangsdatendatei unter einem Namen Ihrer Wahl (Beispiel: oci-creds.yaml).
    3. Erstellen Sie ein Kubernetes-Secret aus der soeben erstellten Zugangsdatendatei, indem Sie Folgendes eingeben:
      kubectl create secret generic <secret-name> --from-file=<credential-filename>

      Beispiel:

      kubectl create secret generic external-dns-config --from-file=oci-creds.yaml
  4. Stellen Sie ExternalDNS auf dem Cluster bereit.
    1. Erstellen Sie in einem Texteditor eine Konfigurationsdatei (z.B. external-dns-deployment.yaml), um das ExternalDNS-Deployment zu erstellen, und geben Sie den Namen des soeben erstellten Kubernetes-Secrets an. Beispiel:
      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. Speichern und schließen Sie die Konfigurationsdatei.
    3. Wenden Sie die Konfigurationsdatei an, um ExternalDNS bereitzustellen, indem Sie Folgendes eingeben:
      kubectl apply -f <filename>

      Hierbei ist <filename> der Name der Datei, die Sie zuvor erstellt haben. Beispiel:

      kubectl apply -f external-dns-deployment.yaml

      In der Ausgabe des obigen Befehls wird das Deployment bestätigt:

      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. Prüfen Sie, ob ExternalDNS erfolgreich bereitgestellt wurde, und fügen Sie Datensätze in die DNS-Zone ein, die Sie zuvor in Oracle Cloud Infrastructure erstellt haben, indem Sie ein nginx-Deployment und einen nginx-Service erstellen:
    1. Erstellen Sie in einem Texteditor eine Konfigurationsdatei (z.B. nginx-externaldns.yaml), um ein nginx-Deployment und einen nginx-Service zu erstellen, der die Annotation external-dns.alpha.kubernetes.io/hostname enthält. Beispiel:
      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. Wenden Sie die Konfigurationsdatei an, um nginx-Service und -Deployment zu erstellen, indem Sie Folgendes eingeben:
      kubectl apply -f <filename>

      Hierbei ist <filename> der Name der Datei, die Sie zuvor erstellt haben. Beispiel:

      kubectl apply -f nginx-externaldns.yaml

      In der Ausgabe des obigen Befehls wird das Deployment bestätigt:

      service/nginx created
deployment.apps/nginx created
    3. Warten Sie ein paar Minuten, und prüfen Sie, ob ein DNS-Datensatz für den nginx-Service in der Oracle Cloud Infrastructure DNS-Zone erstellt wurde (siehe Zonen).