Een AKS-cluster (Azure Kubernetes Services) maken en configureren voor het gebruik van virtuele knooppunten met behulp van Azure CLI

Artikel
10/24/2023

Virtuele knooppunten maken netwerkcommunicatie mogelijk tussen pods die worden uitgevoerd in ACI-clusters (Azure Container Instances) en AKS. Als u deze communicatie wilt opgeven, maakt u een subnet voor een virtueel netwerk en wijst u gedelegeerde machtigingen toe. Virtuele knooppunten werken alleen met AKS-clusters die zijn gemaakt met behulp van geavanceerde netwerken (Azure CNI). AKS-clusters worden standaard gemaakt met basisnetwerken (kubenet). In dit artikel leest u hoe u een virtueel netwerk en subnetten maakt en vervolgens een AKS-cluster implementeert dat gebruikmaakt van geavanceerde netwerken.

In dit artikel leest u hoe u de Azure CLI gebruikt voor het maken en configureren van resources voor virtuele netwerken en een AKS-cluster dat is ingeschakeld met virtuele knooppunten.

Voordat u begint

Belangrijk

Voordat u virtuele knooppunten met AKS gebruikt, bekijkt u zowel de beperkingen van virtuele AKS-knooppunten als de beperkingen voor virtuele netwerken van ACI. Deze beperkingen zijn van invloed op de locatie, netwerkconfiguratie en andere configuratiedetails van zowel uw AKS-cluster als de virtuele knooppunten.

U hebt de ACI-serviceprovider nodig die is geregistreerd bij uw abonnement. U kunt de status van de registratie van de ACI-provider controleren met behulp van de az provider list opdracht.
```
az provider list --query "[?contains(namespace,'Microsoft.ContainerInstance')]" -o table
```
De Microsoft.ContainerInstance-provider moet rapporteren als Geregistreerd, zoals wordt weergegeven in de volgende voorbeelduitvoer:
```
Namespace                    RegistrationState    RegistrationPolicy
---------------------------  -------------------  --------------------
Microsoft.ContainerInstance  Registered           RegistrationRequired
```
Als de provider wordt weergegeven als NotRegistered, registreert u de provider met behulp van de az provider registerprovider.
```
az provider register --namespace Microsoft.ContainerInstance
```
Als u Azure CLI gebruikt, is voor dit artikel Versie 2.0.49 of hoger van Azure CLI vereist. Voer az --version uit om de versie te bekijken. Als u Azure CLI 2.0 wilt installeren of upgraden, raadpleegt u Azure CLI 2.0 installeren. U kunt ook Azure Cloud Shell gebruiken.

Azure Cloud Shell starten

Azure Cloud Shell is een gratis interactieve shell die u kunt gebruiken om de stappen in dit artikel uit te voeren. Azure-hulpprogramma's zijn vooraf geïnstalleerd en geconfigureerd.

Als u Cloud Shell wilt openen, selecteert u Proberen in de rechterbovenhoek van een codeblok. U kunt Cloud Shell ook openen in een afzonderlijk browsertabblad door naar https://shell.azure.com/bash te gaan. Klik op Kopiëren om de codeblokken te kopiëren, plak deze in Cloud Shell en druk vervolgens op Enter om de code uit te voeren.

Een brongroep maken

Een Azure-resourcegroep is een logische groep waarin Azure-resources worden geïmplementeerd en beheerd.

Maak een resourcegroep met behulp van de az group create opdracht.
```
az group create --name myResourceGroup --location eastus
```

Een virtueel netwerk maken

Belangrijk

Voor een virtueel knooppunt zijn een aangepast virtueel netwerk en gekoppeld subnet vereist. Het kan niet worden gekoppeld aan hetzelfde virtuele netwerk als het AKS-cluster.

Maak een virtueel netwerk met behulp van de az network vnet create opdracht. In het volgende voorbeeld wordt een virtueel netwerk gemaakt met de naam myVnet met een adresvoorvoegsel 10.0.0.0/8 en een subnet met de naam myAKSSubnet. Het adresvoorvoegsel van dit subnet is standaard ingesteld op 10.240.0.0/16.
```
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
```
Maak een extra subnet voor de virtuele knooppunten met behulp van de az network vnet subnet create opdracht. In het volgende voorbeeld wordt een subnet met de naam myVirtualNodeSubnet gemaakt met een adresvoorvoegsel 10.241.0.0/16.
```
az network vnet subnet create \
    --resource-group myResourceGroup \
    --vnet-name myVnet \
    --name myVirtualNodeSubnet \
    --address-prefixes 10.241.0.0/16
```

Een AKS-cluster met beheerde identiteit maken

Haal de subnet-id op met behulp van de az network vnet subnet show opdracht.

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

Maak een AKS-cluster met behulp van de az aks create opdracht en vervang deze door <subnetId> de id die u in de vorige stap hebt verkregen. In het volgende voorbeeld wordt een cluster met de naam myAKSCluster gemaakt met vijf knooppunten.
```
az aks create \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --node-count 5 \
    --network-plugin azure \
    --vnet-subnet-id <subnetId>
```
Na enkele minuten is de opdracht voltooid en retourneert deze informatie over het cluster in JSON-indeling.

Zie Beheerde identiteiten gebruiken voor meer informatie over beheerde identiteiten.

De invoegtoepassing virtuele knooppunten inschakelen

Schakel virtuele knooppunten in met behulp van de az aks enable-addons opdracht. In het volgende voorbeeld wordt het subnet myVirtualNodeSubnet gebruikt dat in een vorige stap is gemaakt.
```
az aks enable-addons \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --addons virtual-node \
    --subnet-name myVirtualNodeSubnet
```

Verbinding maken met het cluster

Configureer kubectl deze om verbinding te maken met uw Kubernetes-cluster met behulp van de az aks get-credentials opdracht. In deze stap worden referenties gedownload en wordt Kubernetes CLI geconfigureerd voor het gebruik van deze referenties.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Controleer de verbinding met uw cluster met behulp van de kubectl get opdracht, die een lijst met de clusterknooppunten retourneert.
```
kubectl get nodes
```
In de volgende voorbeelduitvoer ziet u het enkele VM-knooppunt dat is gemaakt en het virtuele knooppunt voor 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
```

Een voorbeeld-app implementeren

Maak een bestand met de naam virtual-node.yaml en kopieer dit in de volgende YAML. De YAML plant de container op het knooppunt door een nodeSelector en tolerantie te definiëren.

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

Voer de toepassing uit met behulp van de kubectl apply opdracht.
```
kubectl apply -f virtual-node.yaml
```
Haal een lijst met pods en het geplande knooppunt op met behulp van de kubectl get pods opdracht met het -o wide argument.
```
kubectl get pods -o wide
```
De pod is gepland op het virtuele knooppunt virtual-node-aci-linux, zoals wordt weergegeven in de volgende voorbeelduitvoer:
```
NAME                            READY     STATUS    RESTARTS   AGE       IP           NODE
aci-helloworld-9b55975f-bnmfl   1/1       Running   0          4m        10.241.0.4   virtual-node-aci-linux
```
Aan de pod wordt een intern IP-adres toegewezen van het subnet van het virtuele Azure-netwerk dat is gedelegeerd voor gebruik met virtuele knooppunten.

Notitie

Als u installatiekopieën gebruikt die zijn opgeslagen in Azure Container Registry, configureert en gebruikt u een Kubernetes-geheim. Een huidige beperking van virtuele knooppunten is dat u geen geïntegreerde verificatie van de Microsoft Entra-service-principal kunt gebruiken. Als u geen geheim gebruikt, kunnen pods die zijn gepland op virtuele knooppunten niet worden gestart en wordt de fout HTTP response status code 400 error code "InaccessibleImage"gerapporteerd.

De pod van het virtuele knooppunt testen

Test de pod die wordt uitgevoerd op het virtuele knooppunt door naar de demotoepassing te bladeren met een webclient. Wanneer aan de pod een intern IP-adres is toegewezen, kunt u deze connectiviteit snel testen vanaf een andere pod in het AKS-cluster.
Maak een testpod en koppel er een terminalsessie aan met behulp van de volgende kubectl run -it opdracht.
```
kubectl run -it --rm testvk --image=mcr.microsoft.com/dotnet/runtime-deps:6.0
```
Installeren curl in de pod met behulp van apt-get.
```
apt-get update && apt-get install -y curl
```
Toegang tot het adres van uw pod met behulp curlvan, zoals http://10.241.0.4. Geef uw eigen interne IP-adres op dat wordt weergegeven in de vorige kubectl get pods opdracht.
```
curl -L http://10.241.0.4
```
De demotoepassing wordt weergegeven, zoals wordt weergegeven in de volgende verkorte voorbeelduitvoer:
```
<html>
<head>
  <title>Welcome to Azure Container Instances!</title>
</head>
[...]
```
Sluit de terminalsessie met uw testpod exit. Wanneer uw sessie is beëindigd, wordt de pod verwijderd.

Virtuele knooppunten verwijderen

Verwijder de aci-helloworld pod die wordt uitgevoerd op het virtuele knooppunt met behulp van de kubectl delete opdracht.
```
kubectl delete -f virtual-node.yaml
```

Schakel de virtuele knooppunten uit met behulp van de az aks disable-addons opdracht.

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

Verwijder de resources en resourcegroep van het virtuele netwerk met behulp van de volgende opdrachten.

# 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

Volgende stappen

In dit artikel hebt u een pod gepland op het virtuele knooppunt en een privé intern IP-adres toegewezen. U kunt in plaats daarvan een service-implementatie maken en verkeer naar uw pod routeren via een load balancer of ingangscontroller. Zie Een eenvoudige ingangscontroller maken in AKS voor meer informatie.

Virtuele knooppunten zijn vaak één onderdeel van een schaaloplossing in AKS. Zie de volgende artikelen voor meer informatie over het schalen van oplossingen: