Konfigurieren des NGINX-Eingangsdatencontrollers zur Unterstützung der privaten Azure-DNS-Zone mit Anwendungsrouting-Add-On

Artikel
08/02/2024

In diesem Artikel wird veranschaulicht, wie Sie einen NGINX-Eingangsdatencontroller für die Arbeit mit dem internen Azure-Lastenausgleich konfigurieren und eine private Azure DNS-Zone konfigurieren, um die DNS-Auflösung für die privaten Endpunkte zum Auflösen bestimmter Domänen zu aktivieren.

Voraussetzungen

Ein AKS-Cluster mit dem Anwendungsrouting-Add-On
Um eine private Azure-DNS-Zone anzuhängen, benötigen Sie die Rolle Besitzer, Azure-Kontoadministrator oder Azure-Co-Administrator in Ihrem Azure-Abonnement.

Herstellen einer Verbindung mit dem AKS-Cluster

Zum Herstellen der Verbindung mit dem Kubernetes-Cluster von Ihrem lokalen Computer aus verwenden Sie den Kubernetes-Befehlszeilenclient kubectl. Mit dem Befehl az aks install-cli können Sie ihn lokal installieren. Wenn Sie Azure Cloud Shell verwenden, ist kubectl bereits installiert.

Im folgenden Beispiel wird die Verbindung mit Ihrem Cluster mit dem Namen myAKSCluster in der myResourceGroup mithilfe des az aks get-credentials-Befehls konfiguriert.

az aks get-credentials --resource-group myResourceGroup --name myAKSCluster

Erstellen eines virtuellen Netzwerks

Um eine private DNS-Zone in Ihrem virtuellen Netzwerk zu veröffentlichen, müssen Sie eine Liste der virtuellen Netzwerke angeben, die Datensätze innerhalb der Zone auflösen dürfen. Diese werden als virtuelle Netzwerkverbindungen bezeichnet.

Im folgenden Beispiel wird ein virtuelles Netzwerk namens myAzureVNet in der Ressourcengruppe myResourceGroup und ein Subnetz mit dem Namen mySubnet erstellt, um innerhalb des VNet mit einem bestimmten Adresspräfix zu erstellen.

az network vnet create \
  --name myAzureVNet \
  --resource-group myResourceGroup \
  --location eastus \
  --address-prefix 10.2.0.0/16 \
  --subnet-name mysubnet \
  --subnet-prefixes 10.2.0.0/24

Erstellen Sie eine private Azure DNS-Zone

Hinweis

Sie können das Application Routing Add-on so konfigurieren, dass es automatisch Einträge in einer oder mehreren globalen und privaten Azure-DNS-Zonen für Hosts erstellt, die auf Eingangsressourcen definiert sind. Alle globalen Azure DNS-Zonen und alle privaten Azure DNS-Zonen müssen sich in derselben Ressourcengruppe befinden.

Sie erstellen eine DNS-Zone mit dem Befehl az network private-dns zone create und geben den Namen der Zone und die Ressourcengruppe an, in der sie erstellt werden soll. Im folgenden Beispiel wird eine DNS-Zone namens private.contoso.com in der Ressourcengruppe myResourceGroup erstellt.

az network private-dns zone create --resource-group myResourceGroup --name private.contoso.com

Sie erstellen eine virtuelle Netzwerkverbindung zu der zuvor erstellten DNS-Zone mit dem Befehl az network private-dns link vnet create. Im folgenden Beispiel wird ein Link namens myDNSLink zu der Zone private.contoso.com für das virtuelle Netzwerk myAzureVNet erstellt. Schließen Sie den --registration-enabled-Parameter ein, um anzugeben, dass der Link nicht registriert ist.

az network private-dns link vnet create --resource-group myResourceGroup \
  --name myDNSLink \
  --zone-name private.contoso.com \
  --virtual-network myAzureVNet \
  --registration-enabled false

Die Funktion zur automatischen Registrierung privater Azure DNS-Zonen verwaltet DNS-Einträge für virtuelle Computer, die in einem virtuellen Netzwerk bereitgestellt werden. Wenn Sie ein virtuelles Netzwerk mit einer privaten DNS-Zone verknüpfen und diese Einstellung aktiviert ist, wird für jeden virtuellen Azure-Computer ein DNS-Eintrag für Ihren AKS-Knoten erstellt, der in dem virtuellen Netzwerk eingesetzt wird.

Anfügen einer privaten Azure-DNS-Zone an das Anwendungsrouting-Add-On

Hinweis

Der Befehl az aks approuting zone add verwendet die Berechtigungen des Benutzers, der den Befehl zum Erstellen der Azure DNS-Zonen-Rollenzuweisung ausführt. Die Rolle Mitwirkender privater DNS-Zone ist eine integrierte Rolle zum Verwalten privater DNS-Ressourcen und wird der verwalteten Identität des Add-Ons zugewiesen. Weitere Informationen zu verwalteten AKS-Identitäten finden Sie unter Zusammenfassung der verwalteten Identitäten.

Rufen Sie die Ressourcen-ID für die DNS-Zone mit dem az network dns zone show-Befehl ab und legen Sie die Ausgabe auf eine Variable namens ZONEID fest. Im folgenden Beispiel wird die Zone private.contoso.com in der Ressourcengruppe myResourceGroup abgefragt.
```
ZONEID=$(az network private-dns zone show --resource-group myResourceGroup --name private.contoso.com --query "id" --output tsv)
```
Aktualisieren Sie das Add-On, um die Integration mit Azure DNS zu aktivieren, indem Sie den az aks approuting zone-Befehl verwenden. Sie können eine Komma-separierte Liste Ressourcen-IDs für DNS-Zonen übergeben. Im folgenden Beispiel wird der AKS-Cluster myAKSCluster in der Ressourcengruppe myResourceGroup aktualisiert.
```
az aks approuting zone add --resource-group myResourceGroup --name myAKSCluster --ids=${ZONEID} --attach-zones
```

Erstellen eines NGINX-Eingangsdatencontrollers mit einer privaten IP-Adresse und einem internen Lastenausgleich

Das Anwendungsrouting-Add-On verwendet eine benutzerdefinierte Ressourcendefinition (CRD) namens NginxIngressController von Kubernetes, um NGINX-Eingangsdatencontroller zu konfigurieren. Sie können weitere Eingangsdatencontroller erstellen oder eine vorhandene Konfiguration ändern.

NginxIngressController CRD verfügt über ein loadBalancerAnnotations-Feld, um das Verhalten des NGINX-Eingangsdatencontrollerdiensts zu steuern, indem Lastenausgleichsanmerkungen festgelegt werden.

Führen Sie die folgenden Schritte aus, um einen NGINX-Eingangsdatencontroller mit einem nach innen gerichteten Azure Load Balancer mit einer privaten IP-Adresse zu erstellen.

Kopieren Sie das folgende YAML-Manifest in eine neue Datei namens nginx-internal-controller.yaml, und speichern Sie die Datei auf Ihrem lokalen Computer.

apiVersion: approuting.kubernetes.azure.com/v1alpha1
kind: NginxIngressController
metadata:
  name: nginx-internal
spec:
  ingressClassName: nginx-internal
  controllerNamePrefix: nginx-internal
  loadBalancerAnnotations: 
    service.beta.kubernetes.io/azure-load-balancer-internal: "true"

Erstellen Sie die Ressourcen des NGINX-Eingangsdatencontrollers mithilfe des Befehls kubectl apply.
```
kubectl apply -f nginx-internal-controller.yaml
```
In der folgenden Beispielausgabe sehen Sie die erstellten Ressourcen:
```
nginxingresscontroller.approuting.kubernetes.azure.com/nginx-internal created
```
Überprüfen, ob der Eingangsdatencontroller erstellt wurde

Sie können den Status der NGINX-Eingangsdatencontroller mit dem Befehl kubectl get nginxingresscontroller überprüfen.
```
kubectl get nginxingresscontroller
```
In der folgenden Beispielausgabe sehen Sie die erstellte Ressource. Es kann einige Minuten dauern, bis der Controller verfügbar ist.
```
NAME             INGRESSCLASS                         CONTROLLERNAMEPREFIX   AVAILABLE
default          webapprouting.kubernetes.azure.com   nginx                  True
nginx-internal   nginx-internal                       nginx-internal         True
```

Bereitstellen von Anwendungen

Das Anwendungsrouting-Add-On verwendet Anmerkungen für Kubernetes-Eingangsobjekte, um die zugehörigen Ressourcen zu erstellen.

Erstellen Sie den Anwendungsnamespace namens hello-web-app-routing, um die Beispielpods mit dem kubectl create namespace-Befehl auszuführen.
```
kubectl create namespace hello-web-app-routing
```

Erstellen Sie die Bereitstellung, indem Sie das folgende YAML-Manifest in eine neue Datei namens deployment.yaml kopieren und die Datei auf Ihrem lokalen Computer speichern.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: aks-helloworld  
  namespace: hello-web-app-routing
spec:
  replicas: 1
  selector:
    matchLabels:
      app: aks-helloworld
  template:
    metadata:
      labels:
        app: aks-helloworld
    spec:
      containers:
      - name: aks-helloworld
        image: mcr.microsoft.com/azuredocs/aks-helloworld:v1
        ports:
        - containerPort: 80
        env:
        - name: TITLE
          value: "Welcome to Azure Kubernetes Service (AKS)"

Erstellen Sie den Dienst, indem Sie das folgende YAML-Manifest in eine neue Datei namens service.yaml kopieren und die Datei auf Ihrem lokalen Computer speichern.

apiVersion: v1
kind: Service
metadata:
  name: aks-helloworld
  namespace: hello-web-app-routing
spec:
  type: ClusterIP
  ports:
  - port: 80
  selector:
    app: aks-helloworld

Erstellen Sie die Clusterressourcen mithilfe des Befehls kubectl apply.
```
kubectl apply -f deployment.yaml -n hello-web-app-routing
```
In der folgenden Beispielausgabe sehen Sie die erstellten Ressourcen:
```
deployment.apps/aks-helloworld created created
```
```
kubectl apply -f service.yaml -n hello-web-app-routing
```
In der folgenden Beispielausgabe sehen Sie die erstellten Ressourcen:
```
service/aks-helloworld created created
```

Erstellen der Eingangsressource, die einen Hostnamen in der privaten Azure-DNS-Zone und eine private IP-Adresse verwendet

Kopieren Sie das folgende YAML-Manifest in eine neue Datei namens ingress.yaml, und speichern Sie die Datei auf Ihrem lokalen Computer.

Aktualisieren Sie <Hostname> mit dem Namen Ihres DNS-Hosts, z. B. helloworld.private.contoso.com. Vergewissern Sie sich, dass Sie die Angabe nginx-internal für ingressClassName machen.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: aks-helloworld
  namespace: hello-web-app-routing
spec:
  ingressClassName: nginx-internal
  rules:
  - host: <Hostname>
    http:
      paths:
      - backend:
          service:
            name: aks-helloworld
            port:
              number: 80
        path: /
        pathType: Prefix

Erstellen Sie die Clusterressourcen mithilfe des Befehls kubectl apply.
```
kubectl apply -f ingress.yaml -n hello-web-app-routing
```
In der folgenden Beispielausgabe sehen Sie die erstellten Ressourcen:
```
ingress.networking.k8s.io/aks-helloworld created
```

Überprüfen, ob der verwaltete Eingang erstellt wurde

Überprüfen Sie mithilfe des Befehls kubectl get ingress, ob der verwaltete Eingang erstellt wurde.

kubectl get ingress -n hello-web-app-routing

Die folgende Beispielausgabe zeigt den erstellten verwalteten Eingang:

NAME             CLASS            HOSTS                            ADDRESS      PORTS   AGE
aks-helloworld   nginx-internal   helloworld.private.contoso.com   10.224.0.7   80      98s

Überprüfen, ob die private Azure-DNS-Zone aktualisiert wurde

Führen Sie in ein paar Minuten den Befehl az network private-dns record-set a list aus, um die A-Einträge für Ihre private Azure-DNS-Zone anzuzeigen. Geben Sie den Namen der Ressourcengruppe und den Namen der DNS-Zone an. In diesem Beispiel ist die Ressourcengruppe myResourceGroup und die DNS-Zone private.contoso.com.

az network private-dns record-set a list --resource-group myResourceGroup --zone-name private.contoso.com

Die folgende Beispielausgabe zeigt den erstellten Datensatz:

[
  {
    "aRecords": [
      {
        "ipv4Address": "10.224.0.7"
      }
    ],
    "etag": "188f0ce5-90e3-49e6-a479-9e4053f21965",
    "fqdn": "helloworld.private.contoso.com.",
    "id": "/subscriptions/xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx/resourceGroups/foo/providers/Microsoft.Network/privateDnsZones/private.contoso.com/A/helloworld",
    "isAutoRegistered": false,
    "name": "helloworld",
    "resourceGroup": "foo",
    "ttl": 300,
    "type": "Microsoft.Network/privateDnsZones/A"
  }
]

Nächste Schritte

Weitere Konfigurationsinformationen im Zusammenhang mit der SSL-Verschlüsselung anderer erweiterter NGINX-Eingangscontroller und -Eingangsressourcenkonfiguration finden Sie unter DNS- und SSL-Konfiguration und Anwendungsrouting-Add-On-Konfiguration.

Freigeben über