Erstellen und Konfigurieren eines AKS-Clusters zur Verwendung von virtuellen Knoten mithilfe der Azure-Befehlszeilenschnittstelle

Artikel
08/28/2023

Die virtuellen Knoten ermöglichen die Netzwerkkommunikation zwischen Pods, die in Azure Container Instances (ACI) und AKS-Clustern ausgeführt werden. Um diese Kommunikation zu ermöglichen, erstellen Sie ein Subnetz des virtuellen Netzwerks und weisen delegierte Berechtigungen zu. Virtuelle Knoten funktionieren nur in AKS-Clustern, die mit erweiterten Netzwerkfunktionen (Azure CNI) erstellt wurden. Standardmäßig werden AKS-Cluster mit grundlegenden Netzwerkfunktionen (kubenet) erstellt. Dieser Artikel zeigt, wie Sie ein virtuelles Netzwerk und virtuelle Subnetze erstellen und dann einen AKS-Cluster bereitstellen, der erweiterte Netzwerkfunktionen verwendet.

Dieser Artikel zeigt, wie Sie die Azure CLI verwenden, um virtuelle Netzwerkressourcen und einen AKS-Cluster mit virtuellen Knoten zu erstellen und zu konfigurieren.

Voraussetzungen

Wichtig

Bevor Sie virtuelle Knoten bei AKS verwenden, überprüfen Sie sowohl die Einschränkungen von virtuellen AKS-Knoten als auch die Einschränkungen des virtuellen Netzwerks von ACI. Diese Einschränkungen wirken sich auf den Speicherort, die Netzwerkkonfiguration und andere Konfigurationsdetails Ihres AKS-Clusters und der virtuellen Knoten aus.

Sie benötigen den ACI-Dienstanbieter, der für Ihr Abonnement registriert ist. Sie können den Status der ACI-Anbieterregistrierung mithilfe des Befehls az provider list überprüfen.
```
az provider list --query "[?contains(namespace,'Microsoft.ContainerInstance')]" -o table
```
Der Anbieter Microsoft.ContainerInstance sollte als Registriert gemeldet werden, wie in der folgenden Beispielausgabe gezeigt:
```
Namespace                    RegistrationState    RegistrationPolicy
---------------------------  -------------------  --------------------
Microsoft.ContainerInstance  Registered           RegistrationRequired
```
Wenn der Anbieter als Nicht registriert angezeigt wird, registrieren Sie den Anbieter mit az provider register.
```
az provider register --namespace Microsoft.ContainerInstance
```
Bei Verwendung der Azure CLI ist für diesen Artikel Azure CLI-Version 2.0.49 oder höher erforderlich. Führen Sie az --version aus, um die Version zu ermitteln. Informationen zum Durchführen einer Installation oder eines Upgrades finden Sie bei Bedarf unter Installieren der Azure CLI. Sie können auch Azure Cloud Shell verwenden.

Starten von Azure Cloud Shell

Die Azure Cloud Shell ist eine kostenlose interaktive Shell, mit der Sie die Schritte in diesem Artikel durchführen können. Dieser Dienst verfügt über allgemeine vorinstallierte Tools und ist für die Verwendung mit Ihrem Konto konfiguriert.

Wählen Sie zum Öffnen von Cloud Shell oben rechts in einem Codeblock die Option Ausprobieren aus. Sie können Cloud Shell auch auf einem separaten Browsertab starten, indem Sie zu https://shell.azure.com/bash navigieren. Wählen Sie Kopieren, um die Blöcke mit dem Code zu kopieren. Fügen Sie ihn anschließend in Cloud Shell ein, und drücken Sie die EINGABETASTE, um ihn auszuführen.

Erstellen einer Ressourcengruppe

Eine Azure-Ressourcengruppe ist eine logische Gruppe, in der Azure-Ressourcen bereitgestellt und verwaltet werden.

Erstellen Sie mit dem Befehl az group create eine Ressourcengruppe.
```
az group create --name myResourceGroup --location eastus
```

Erstellen eines virtuellen Netzwerks

Wichtig

Der virtuelle Knoten erfordert ein benutzerdefiniertes virtuelles Netzwerk und ein zugeordnetes Subnetz. Eine Zuordnung zum selben virtuellen Netzwerk wie der AKS-Cluster nicht möglich.

Erstellen Sie ein virtuelles Netzwerk mit dem Befehl az network vnet create. Im folgenden Beispiel wird ein virtuelles Netzwerk namens myVnet mit dem Adresspräfix 10.0.0.0/8 und einem Subnetz namens myAKSSubnet erstellt. Das Adresspräfix dieses Subnetzes wird standardmäßig auf 10.240.0.0/16 festgelegt.
```
az network vnet create \
    --resource-group myResourceGroup \
    --name myVnet \
    --address-prefixes 10.0.0.0/8 \
    --subnet-name myAKSSubnet \
    --subnet-prefix 10.240.0.0/16
```
Erstellen Sie mit dem Befehl az network vnet subnet create ein zusätzliches Subnetz für die virtuellen Knoten. Im folgenden Beispiel wird ein Subnetz namens myVirtualNodeSubnet mit dem Adresspräfix 10.241.0.0/16 erstellt.
```
az network vnet subnet create \
    --resource-group myResourceGroup \
    --vnet-name myVnet \
    --name myVirtualNodeSubnet \
    --address-prefixes 10.241.0.0/16
```

Erstellen eines AKS-Clusters mit verwalteter Identität

Rufen Sie die Subnetz-ID mit dem az network vnet subnet show-Befehl ab.

az network vnet subnet show --resource-group myResourceGroup --vnet-name myVnet --name myAKSSubnet --query id -o tsv

Erstellen Sie mit dem Befehl az aks create ein AKS-Cluster, und ersetzen Sie <subnetId> durch die im vorigen Schritt erhaltene ID. Im folgenden Beispiel wird ein Cluster mit dem Namen myAKSCluster mit fünf Knoten erstellt.
```
az aks create \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --node-count 5 \
    --network-plugin azure \
    --vnet-subnet-id <subnetId>
```
Nach einigen Minuten wird der Befehl abgeschlossen und gibt Informationen über den Cluster im JSON-Format zurück.

Weitere Informationen zu verwalteten Identitäten finden Sie unter Verwenden verwalteter Identitäten.

Aktivieren des Add-Ons für virtuelle Knoten

Aktivieren Sie virtuelle Knoten mithilfe des Befehls az aks enable-addons. Im folgenden Beispiel wird das Subnetz myVirtualNodeSubnet, das in einem vorherigen Schritt erstellt wurde, verwendet.
```
az aks enable-addons \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --addons virtual-node \
    --subnet-name myVirtualNodeSubnet
```

Herstellen einer Verbindung mit dem Cluster

Mit dem Befehl az aks get-credentials können Sie kubectl für die Verbindungsherstellung mit Ihrem Kubernetes-Cluster konfigurieren. Dieser Schritt dient dazu, Anmeldeinformationen herunterzuladen und die Kubernetes-Befehlszeilenschnittstelle für ihre Verwendung zu konfigurieren.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Überprüfen Sie die Verbindung zu Ihrem Cluster mit dem Befehl kubectl get, der eine Liste der Clusterknoten zurückgibt.
```
kubectl get nodes
```
Die folgende Beispielausgabe enthält den erstellten einzelnen VM-Knoten und den virtuellen Knoten für Linux, virtual-node-aci-linux:
```
NAME                          STATUS    ROLES     AGE       VERSION
virtual-node-aci-linux        Ready     agent     28m       v1.11.2
aks-agentpool-14693408-0      Ready     agent     32m       v1.11.2
```

Bereitstellen einer Beispiel-App

Erstellen Sie eine Datei namens „virtual-node.yaml“, und fügen Sie den folgenden YAML-Code ein. YAML plant den Container auf dem Knoten durch die Definition vonnodeSelector und toleration.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: aci-helloworld
spec:
  replicas: 1
  selector:
    matchLabels:
      app: aci-helloworld
  template:
    metadata:
      labels:
        app: aci-helloworld
    spec:
      containers:
      - name: aci-helloworld
        image: mcr.microsoft.com/azuredocs/aci-helloworld
        ports:
        - containerPort: 80
      nodeSelector:
        kubernetes.io/role: agent
        beta.kubernetes.io/os: linux
        type: virtual-kubelet
      tolerations:
      - key: virtual-kubelet.io/provider
        operator: Exists
      - key: azure.com/aci
        effect: NoSchedule

Führen Sie die Anwendung mit dem Befehl kubectl apply aus.
```
kubectl apply -f virtual-node.yaml
```
Rufen Sie mithilfe des Befehls kubectl get pods mit dem Argument -o wide eine Liste der Pods und den geplanten Knoten ab.
```
kubectl get pods -o wide
```
Der Pod wird auf dem virtuellen Knoten virtual-node-aci-linux geplant, wie in der folgenden Beispielausgabe gezeigt:
```
NAME                            READY     STATUS    RESTARTS   AGE       IP           NODE
aci-helloworld-9b55975f-bnmfl   1/1       Running   0          4m        10.241.0.4   virtual-node-aci-linux
```
Dem Pod wird von dem Subnetz des virtuellen Azure-Netzwerks, das für die Verwendung mit virtuellen Knoten delegiert wurde, eine interne IP-Adresse zugewiesen.

Hinweis

Wenn Sie Images verwenden, die in der Azure Container Registry gespeichert sind, konfigurieren und verwenden Sie ein Kubernetes-Geheimnis. Derzeit besteht eine Einschränkung virtueller Knoten darin, dass Sie die integrierte Microsoft Entra-Authentifizierung mit einem Dienstprinzipal nicht verwenden können. Wenn Sie kein Geheimnis verwenden, können auf virtuellen Knoten geplante Pods nicht starten und melden den Fehler HTTP response status code 400 error code "InaccessibleImage".

Testen des Pods des virtuellen Knotens

Testen Sie den Pod, der auf dem virtuellen Knoten ausgeführt wird, indem Sie in einem Webclient zur Demoanwendung wechseln. Da dem Pod eine interne IP-Adresse zugewiesen wurde, können Sie diese Konnektivität schnell von einem anderen Pod im AKS-Cluster aus testen.
Erstellen Sie einen Testpod, und fügen Sie mithilfe des folgenden kubectl run -it-Befehls eine Terminalsitzung an ihn an:
```
kubectl run -it --rm testvk --image=mcr.microsoft.com/dotnet/runtime-deps:6.0
```

Installieren Sie curl mittels apt-get im Pod.

apt-get update && apt-get install -y curl

Greifen Sie mithilfe von curl auf die Adresse Ihres Pods zu, z. B. http://10.241.0.4. Geben Sie Ihre eigene interne IP-Adresse an, die im vorherigen kubectl get pods-Befehl gezeigt wurde.
```
curl -L http://10.241.0.4
```
Die Demoanwendung wird angezeigt, wie in der folgenden verkürzten Beispielausgabe veranschaulicht:
```
<html>
<head>
  <title>Welcome to Azure Container Instances!</title>
</head>
[...]
```
Schließen Sie die Terminalsitzung mit Ihrem Testpod mit exit. Bei Beendigung der Sitzung wird der Pod gelöscht.

Entfernen von virtuellen Knoten

Löschen Sie den aci-helloworld-Pod, der auf dem virtuellen Knoten ausgeführt wird, mit dem Befehl kubectl delete.
```
kubectl delete -f virtual-node.yaml
```

Deaktivieren Sie die virtuellen Knoten mithilfe des Befehls az aks disable-addons.

az aks disable-addons --resource-group myResourceGroup --name myAKSCluster --addons virtual-node

Entfernen Sie die Ressourcen des virtuellen Netzwerks und die Ressourcengruppe mit den folgenden Befehlen.

# Change the name of your resource group, cluster and network resources as needed
RES_GROUP=myResourceGroup
AKS_CLUSTER=myAKScluster
AKS_VNET=myVnet
AKS_SUBNET=myVirtualNodeSubnet

# Get AKS node resource group
NODE_RES_GROUP=$(az aks show --resource-group $RES_GROUP --name $AKS_CLUSTER --query nodeResourceGroup --output tsv)

# Get network profile ID
NETWORK_PROFILE_ID=$(az network profile list --resource-group $NODE_RES_GROUP --query "[0].id" --output tsv)

# Delete the network profile
az network profile delete --id $NETWORK_PROFILE_ID -y

# Grab the service association link ID
SAL_ID=$(az network vnet subnet show --resource-group $RES_GROUP --vnet-name $AKS_VNET --name $AKS_SUBNET --query id --output tsv)/providers/Microsoft.ContainerInstance/serviceAssociationLinks/default

# Delete the service association link for the subnet
az resource delete --ids $SAL_ID --api-version 2021-10-01

# Delete the subnet delegation to Azure Container Instances
az network vnet subnet update --resource-group $RES_GROUP --vnet-name $AKS_VNET --name $AKS_SUBNET --remove delegations

Nächste Schritte

In diesem Artikel haben Sie einen Pod im virtuellen Knoten geplant und dem Pod eine private interne IP-Adresse zugewiesen. Sie können stattdessen auch eine Dienstbereitstellung erstellen und den Datenverkehr über ein Lastenausgleichsmodul oder einen Eingangscontroller an Ihren Pod weiterleiten. Weitere Informationen finden Sie unter Erstellen eines einfachen Eingangscontrollers in AKS.

Virtuelle Knoten sind oft eine Komponente einer Skalierungslösung in AKS. Weitere Informationen zu Skalierungslösungen finden Sie in den folgenden Artikeln: