Een AKS-cluster (Azure Kubernetes Services) maken en configureren voor het gebruik van virtuele knooppunten in Azure Portal

Artikel
11/22/2024

Virtuele knooppunten maken netwerkcommunicatie mogelijk tussen pods die worden uitgevoerd in ACI-clusters (Azure Container Instances) en Azure Kubernetes Service (AKS). Om deze communicatie te bieden, wordt er een subnet voor een virtueel netwerk gemaakt en worden gedelegeerde machtigingen toegewezen. 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 met behulp van Azure Portal.

Notitie

Zie Virtuele knooppunten gebruiken in AKS voor een overzicht van de beschikbaarheid en beperkingen van virtuele knooppunten.

Voordat u begint

U hebt de ACI-serviceprovider nodig die is geregistreerd bij uw abonnement.

Controleer de status van de registratie van de ACI-provider met behulp van de az provider list opdracht.

az provider list --query "[?contains(namespace,'Microsoft.ContainerInstance')]" -o table

In de volgende voorbeelduitvoer ziet u dat de Provider Microsoft.ContainerInstance is geregistreerd:

Namespace                    RegistrationState    RegistrationPolicy
---------------------------  -------------------  --------------------
Microsoft.ContainerInstance  Registered           RegistrationRequired

Als de provider NotRegistered is, registreert u deze met behulp van de az provider register opdracht.
```
az provider register --namespace Microsoft.ContainerInstance
```

Een AKS-cluster maken

Navigeer naar de startpagina van Azure Portal.
Selecteer Een resourcecontainer> maken.
Selecteer Maken in de AKS-resource (Azure Kubernetes Service).
Configureer op de pagina Basisbeginselen de volgende opties:
- Projectdetails: Selecteer een Azure-abonnement en selecteer of maak vervolgens een Azure-resourcegroep, zoals myResourceGroup.
- Clusterdetails: voer een Kubernetes-clusternaam in, zoals myAKSCluster. Selecteer een regio en Kubernetes-versie voor het AKS-cluster.
Selecteer Volgende: Knooppuntgroepen en schakel *Virtuele knooppunten inschakelen in.
Selecteer Controleren + maken.
Nadat de validatie is voltooid, selecteert u Maken.

Dit proces maakt standaard een beheerde clusteridentiteit, die wordt gebruikt voor clustercommunicatie en -integratie met andere Azure-services. Zie Beheerde identiteiten gebruiken voor meer informatie. U kunt ook een service-principal gebruiken als uw clusteridentiteit.

Met dit proces configureert u het cluster voor geavanceerde netwerken en de virtuele knooppunten om hun eigen subnet van het virtuele Azure-netwerk te gebruiken. Het subnet heeft gedelegeerde machtigingen om Azure-resources te verbinden tussen het AKS-cluster. Als u nog geen gedelegeerd subnet hebt, maakt en configureert Azure Portal een virtueel Azure-netwerk en subnet met de virtuele knooppunten.

Verbinding maken met het cluster

Azure Cloud Shell is een gratis interactieve shell die u kunt gebruiken om de stappen in dit artikel uit te voeren. In deze shell zijn algemene Azure-hulpprogramma's vooraf geïnstalleerd en geconfigureerd voor gebruik met uw account. Als u een Kubernetes-cluster wilt beheren, gebruikt u kubectl, de Kubernetes-opdrachtregelclient. De client kubectl is vooraf geïnstalleerd in Azure Cloud Shell.

Configureer kubectl deze om verbinding te maken met uw Kubernetes-cluster met behulp van de az aks get-credentials opdracht. In het volgende voorbeeld worden de referenties opgehaald voor de clusternaam myAKSCluster in de resourcegroep met de naam myResourceGroup:
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```

Controleer de verbinding met uw cluster met behulp van de kubectl get nodes.

kubectl get nodes

In de volgende voorbeelduitvoer ziet u het enkele VM-knooppunt dat is gemaakt en het virtuele Linux-knooppunt met de naam 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 in Azure Cloud Shell een bestand met de naam virtual-node.yaml en kopieer dit in de volgende YAML:

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

De YAML definieert een nodeSelector en tolerantie, waarmee de pod kan worden gepland op het virtuele knooppunt. 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.

Voer de toepassing uit met behulp van de kubectl apply opdracht.
```
kubectl apply -f virtual-node.yaml
```

Bekijk de pods die zijn gepland op het knooppunt met behulp van de kubectl get pods opdracht met het -o wide argument.

kubectl get pods -o wide

In de volgende voorbeelduitvoer ziet u de virtual-node-helloworld pod die op het virtual-node-linux knooppunt is gepland.

NAME                                     READY     STATUS    RESTARTS   AGE       IP           NODE
virtual-node-helloworld-9b55975f-bnmfl   1/1       Running   0          4m        10.241.0.4   virtual-node-aci-linux

Notitie

Als u installatiekopieën gebruikt die zijn opgeslagen in Azure Container Registry, configureert en gebruikt u een Kubernetes-geheim. Een 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

Als u de pod wilt testen die wordt uitgevoerd op het virtuele knooppunt, bladert u naar de demotoepassing met een webclient. Aan de pod wordt een intern IP-adres toegewezen, zodat u de connectiviteit eenvoudig kunt 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 opdracht.
```
kubectl run -it --rm virtual-node-test --image=mcr.microsoft.com/dotnet/runtime-deps:6.0
```
Installeer curl in de pod met behulp van de volgende apt-get opdracht.
```
apt-get update && apt-get install -y curl
```
Open het adres van uw pod met behulp van de volgende curl opdracht en geef uw interne IP-adres op.
```
curl -L http://10.241.0.4
```
In de volgende verkorte voorbeelduitvoer ziet u de demotoepassing.
```
<html>
<head>
  <title>Welcome to Azure Container Instances!</title>
</head>
[...]
```
Sluit de terminalsessie met uw testpod, exitwaarmee ook de pod wordt verwijderd.
```
exit
```

Volgende stappen

In dit artikel hebt u een pod gepland op het virtuele knooppunt en een privé, intern IP-adres toegewezen. Als u wilt, kunt u 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 één onderdeel van een schaaloplossing in AKS. Zie de volgende artikelen voor meer informatie over het schalen van oplossingen:

Delen via