Skapa och konfigurera ett AKS-kluster (Azure Kubernetes Services) för att använda virtuella noder i Azure Portal

Artikel
11/22/2024

Virtuella noder möjliggör nätverkskommunikation mellan poddar som körs i Azure Container Instances-kluster (ACI) och Aks-kluster (Azure Kubernetes Service). För att tillhandahålla den här kommunikationen skapas ett undernät för virtuellt nätverk och delegerade behörigheter tilldelas. Virtuella noder fungerar bara med AKS-kluster som skapats med hjälp av avancerade nätverk (Azure CNI). AKS-kluster skapas som standard med grundläggande nätverk (kubenet).

Den här artikeln visar hur du skapar ett virtuellt nätverk och undernät och sedan distribuerar ett AKS-kluster som använder avancerade nätverk med hjälp av Azure Portal.

Kommentar

En översikt över tillgänglighet och begränsningar för virtuella noder finns i Använda virtuella noder i AKS.

Innan du börjar

Du behöver ACI-tjänstleverantören registrerad i din prenumeration.

Kontrollera statusen för ACI-providerregistreringen az provider list med hjälp av kommandot .

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

Följande exempelutdata visar att Microsoft.ContainerInstance-providern är registrerad:

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

Om providern är NotRegistered registrerar du den med kommandot az provider register .
```
az provider register --namespace Microsoft.ContainerInstance
```

Skapa ett AKS-kluster

Gå till startsidan för Azure Portal.
Välj Skapa en resurscontainer>.
I Resursen Azure Kubernetes Service (AKS) väljer du Skapa.
På sidan Grundläggande konfigurerar du följande alternativ:
- Projektinformation: Välj en Azure-prenumeration och välj eller skapa sedan en Azure-resursgrupp, till exempel myResourceGroup.
- Klusterinformation: Ange ett Kubernetes-klusternamn, till exempel myAKSCluster. Välj en region och Kubernetes-version för AKS-klustret.
Välj Nästa: Nodpooler och kontrollera *Aktivera virtuella noder.
Välj Granska + skapa.
När verifieringen är klar väljer du Skapa.

Som standard skapar den här processen en hanterad klusteridentitet som används för klusterkommunikation och integrering med andra Azure-tjänster. Mer information finns i Använda hanterade identiteter. Du kan också använda tjänstens huvudnamn som klusteridentitet.

Den här processen konfigurerar klustret för avancerade nätverk och de virtuella noderna så att de använder sitt eget undernät för virtuella Azure-nätverk. Undernätet har delegerade behörigheter för att ansluta Azure-resurser mellan AKS-klustret. Om du inte redan har ett delegerat undernät skapar och konfigurerar Azure Portal ett virtuellt Azure-nätverk och undernät med de virtuella noderna.

Anslut till klustret

Azure Cloud Shell är ett kostnadsfritt interaktivt gränssnitt som du kan använda för att köra stegen i den här artikeln. Den har vanliga Azure-verktyg förinstallerat och har konfigurerats för användning med ditt konto. Hantera Kubernetes-kluster med kubectl, Kubernetes kommandoradsklient. kubectl-klienten är förinstallerad i Azure Cloud Shell.

Konfigurera kubectl för att ansluta till kubernetes-klustret med hjälp av az aks get-credentials kommandot . I följande exempel hämtas autentiseringsuppgifterna för klusternamnet myAKSCluster i den resursgrupp som heter myResourceGroup:
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```

Verifiera anslutningen till klustret med hjälp av kubectl get nodes.

kubectl get nodes

Följande exempelutdata visar den enskilda VM-noden som skapats och den virtuella Linux-noden med namnet 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

Distribuera en exempelapp

I Azure Cloud Shell skapar du en fil med namnet virtual-node.yaml och kopierar i följande 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

YAML definierar en nodeSelector och tolerans, vilket gör att podden kan schemaläggas på den virtuella noden. Podden tilldelas en intern IP-adress från det virtuella Azure-nätverksundernätet som delegerats för användning med virtuella noder.

Kör programmet med kommandot kubectl apply .
```
kubectl apply -f virtual-node.yaml
```

Visa poddarna som schemalagts på noden med kommandot kubectl get pods med -o wide argumentet .

kubectl get pods -o wide

Följande exempelutdata visar podden som virtual-node-helloworld schemalagts virtual-node-linux på noden.

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

Kommentar

Om du använder avbildningar som lagras i Azure Container Registry konfigurerar och använder du en Kubernetes-hemlighet. En begränsning för virtuella noder är att du inte kan använda integrerad Microsoft Entra-tjänstens huvudnamnsautentisering. Om du inte använder en hemlighet startar inte poddar som schemalagts på virtuella noder och rapporterar felet HTTP response status code 400 error code "InaccessibleImage".

Testa podden för den virtuella noden

Om du vill testa podden som körs på den virtuella noden bläddrar du till demoprogrammet med en webbklient. Podden tilldelas en intern IP-adress så att du enkelt kan testa anslutningen från en annan podd i AKS-klustret.

Skapa en testpodd och koppla en terminalsession till den med hjälp av följande kubectl run kommando.
```
kubectl run -it --rm virtual-node-test --image=mcr.microsoft.com/dotnet/runtime-deps:6.0
```
Installera curl i podden med hjälp av följande apt-get kommando.
```
apt-get update && apt-get install -y curl
```
Få åtkomst till poddens adress med hjälp av följande curl kommando och ange din interna IP-adress.
```
curl -L http://10.241.0.4
```
Följande komprimerade exempelutdata visar demoprogrammet.
```
<html>
<head>
  <title>Welcome to Azure Container Instances!</title>
</head>
[...]
```
Stäng terminalsessionen till testpodden med exit, som även tar bort podden.
```
exit
```

Nästa steg

I den här artikeln har du schemalagt en podd på den virtuella noden och tilldelat en privat, intern IP-adress. Om du vill kan du i stället skapa en tjänstdistribution och dirigera trafik till din podd via en lastbalanserare eller ingresskontrollant. Mer information finns i Skapa en grundläggande ingresskontrollant i AKS.

Virtuella noder är en komponent i en skalningslösning i AKS. Mer information om skalningslösningar finns i följande artiklar:

Dela via