Creare e configurare un cluster del servizio Azure Kubernetes per l'uso di nodi virtuali tramite l'interfaccia della riga di comando di Azure

Articolo
03/28/2024

I nodi virtuali consentono la comunicazione di rete tra i pod eseguiti in Istanze di Azure Container e nei cluster del servizio Azure Kubernetes. Per fornire questa comunicazione, creare una subnet di rete virtuale e assegnare autorizzazioni delegate. I nodi virtuali funzionano solo con i cluster del servizio Azure Kubernetes creati usando una rete avanzata (Azure CNI). Per impostazione predefinita, i cluster del servizio Azure Kubernetes vengono creati con una rete di base (kubenet). Questo articolo illustra come creare una rete virtuale e le subnet e quindi distribuire un cluster del servizio Azure Kubernetes che usa reti avanzate.

Questo articolo mostra come usare l'interfaccia della riga di comando di Azure per creare e configurare risorse di rete virtuale e un cluster del servizio Azure Kubernetes abilitato con nodi virtuali.

Operazioni preliminari

Importante

Prima di usare i nodi virtuali con il servizio Azure Kubernetes, esaminare le limitazioni dei nodi virtuali del servizio Azure Kubernetes e le limitazioni di rete virtuale di ACI. Queste limitazioni influiscono sul percorso, la configurazione di rete e altri dettagli di configurazione del cluster del servizio Azure Kubernetes e dei nodi virtuali.

È necessario che il provider di servizi ACI sia registrato con l’abbonamento. È possibile controllare lo stato della registrazione del provider ACI usando il comando az provider list.
```
az provider list --query "[?contains(namespace,'Microsoft.ContainerInstance')]" -o table
```
Il provider Microsoft.ContainerInstance deve essere contrassegnato come Registrato, come spiegato nell'output di esempio seguente:
```
Namespace                    RegistrationState    RegistrationPolicy
---------------------------  -------------------  --------------------
Microsoft.ContainerInstance  Registered           RegistrationRequired
```
Se il provider viene visualizzato come NotRegistered, registrare il provider usando il az provider register.
```
az provider register --namespace Microsoft.ContainerInstance
```
Se si usa l'interfaccia della riga di comando di Azure, questo articolo richiede l'interfaccia della riga di comando di Azure versione 2.0.49 o successiva. Eseguire az --version per trovare la versione. Se è necessario eseguire l'installazione o l'aggiornamento, vedere Installare l'interfaccia della riga di comando di Azure. È anche possibile usare Azure Cloud Shell.

Avviare Azure Cloud Shell

Azure Cloud Shell è una shell interattiva gratuita che è possibile usare per eseguire i passaggi descritti in questo articolo. Include strumenti di Azure comuni preinstallati e configurati.

Per aprire Cloud Shell, selezionare Prova nell'angolo superiore destro di un blocco di codice. È anche possibile avviare Cloud Shell in una scheda separata del browser visitando https://shell.azure.com/bash. Selezionare Copia per copiare i blocchi di codice, incollarli in Cloud Shell e premere INVIO per eseguirli.

Creare un gruppo di risorse

Un gruppo di risorse di Azure è un gruppo logico in cui le risorse di Azure vengono distribuite e gestite.

Creare un gruppo di risorse usando il comando az group create.
```
az group create --name myResourceGroup --location eastus
```

Creare una rete virtuale

Importante

Il nodo virtuale richiede una rete virtuale personalizzata e una subnet associata. Non può essere associato alla stessa rete virtuale del cluster del servizio Azure Kubernetes.

Creare una rete virtuale usando il comando az network vnet create. L'esempio seguente crea una rete virtuale chiamata myVnet con un prefisso di indirizzo 10.0.0.0/8 e una subnet chiamata myAKSSubnet. Per impostazione predefinita, il prefisso dell'indirizzo di questa subnet è 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
```
Creare una subnet aggiuntiva per i nodi virtuali usando il comando az network vnet subnet create . Nell'esempio seguente viene creata una subnet chiamata myVirtualNodeSubnet con un prefisso di indirizzo 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
```

Creare un cluster del servizio Azure Kubernetes con identità gestita

Ottenere l'ID subnet usando il comando az network vnet subnet show .

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

Creare un cluster del servizio Azure Kubernetes usando il comando az aks create e sostituire <subnetId> con l'ID ottenuto nel passaggio precedente. L'esempio seguente crea un cluster chiamato myAKSCluster con cinque nodi.
```
az aks create \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --node-count 5 \
    --network-plugin azure \
    --vnet-subnet-id <subnetId>
```
Dopo alcuni minuti, il comando viene completato e restituisce le informazioni in formato JSON sul cluster.

Per altre informazioni sulle identità gestite, vedere Usare identità gestite.

Abilitare il componente aggiuntivo dei nodi virtuali

Abilitare i nodi virtuali usando il comando az aks enable-addons. L'esempio seguente usa la subnet chiamata myVirtualNodeSubnet creata nel passaggio precedente:
```
az aks enable-addons \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --addons virtual-node \
    --subnet-name myVirtualNodeSubnet
```

Stabilire la connessione al cluster

Configurare kubectl per connettersi al cluster Kubernetes usando il comando az aks get-credentials. Con questo passaggio si scaricano le credenziali e si configura l'interfaccia della riga di comando di Kubernetes per il loro uso.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Verificare la connessione al cluster usando il comando kubectl get, da cui si ottiene un elenco dei nodi del cluster.
```
kubectl get nodes
```
L'output di esempio seguente mostra il singolo nodo VM creato e il nodo virtuale per 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
```

Distribuire un'app di esempio

Creare un file denominato virtual-node.yaml e copiarlo nel codice YAML seguente. YAML pianifica il contenitore sul nodo definendo un nodeSelector e una tolleranza.

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

Eseguire l'applicazione usando il comando kubectl apply .
```
kubectl apply -f virtual-node.yaml
```
Ottenere un elenco di pod e il nodo pianificato usando il comando kubectl get pods con l'argomento -o wide.
```
kubectl get pods -o wide
```
Il pod è pianificato sul nodo virtuale virtual-node-aci-linux, come illustrato nell'output di esempio seguente:
```
NAME                            READY     STATUS    RESTARTS   AGE       IP           NODE
aci-helloworld-9b55975f-bnmfl   1/1       Running   0          4m        10.241.0.4   virtual-node-aci-linux
```
Al pod viene assegnato un indirizzo IP interno della subnet di rete virtuale di Azure delegata per l'uso con nodi virtuali.

Nota

Se si usano immagini archiviate nel Registro Azure Container, configurare e usare un segreto Kubernetes. Con una limitazione corrente dei nodi virtuali non è possibile usare l'autenticazione integrata dell'entità servizio Microsoft Entra. Se non si usa un segreto, i pod pianificati nei nodi virtuali non si avviano e segnalano l'errore HTTP response status code 400 error code "InaccessibleImage".

Testare il pod del nodo virtuale

Testare il pod in esecuzione nel nodo virtuale passando all'applicazione demo con un client Web. Poiché al pod è assegnato un indirizzo IP interno, è possibile eseguire rapidamente il test di questa connettività da un altro pod nel cluster del servizio Azure Kubernetes.
Creare un pod di prova e collegare ad esso una sessione del terminale usando il comando seguente kubectl run -it.
```
kubectl run -it --rm testvk --image=mcr.microsoft.com/dotnet/runtime-deps:6.0
```

Installare curl nel pod usando apt-get.

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

Accedere all'indirizzo del pod usando curl, ad esempio http://10.241.0.4. Specificare il proprio indirizzo IP interno mostrato nel comando kubectl get pods precedente.
```
curl -L http://10.241.0.4
```
Viene visualizzata l'applicazione demo, come illustrato nell'output di esempio condensato seguente:
```
<html>
<head>
  <title>Welcome to Azure Container Instances!</title>
</head>
[...]
```
Chiudere la sessione del terminale nel pod del test con exit. Al termine della sessione, il pod viene eliminato.

Rimuovere i nodi virtuali

Eliminare il pod aci-helloworld in esecuzione sul nodo virtuale usando il comando kubectl delete.
```
kubectl delete -f virtual-node.yaml
```

Disabilitare i nodi virtuali usando il comando az aks disable-addons.

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

Rimuovere le risorse di rete virtuale e il gruppo di risorse usando i comandi seguenti.

# 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

Passaggi successivi

In questo articolo è stato pianificato un pod sul nodo virtuale ed è stato assegnato un indirizzo IP interno privato. In alternativa, è possibile creare una distribuzione di servizio e instradare il traffico al pod attraverso un bilanciamento del carico o un controller in ingresso. Per altre informazioni, vedereCreare un controller di ingresso di base nel servizio Azure Kubernetes.

I nodi virtuali sono spesso un componente di una soluzione di scalabilità nel servizio Azure Kubernetes. Per altre informazioni sulle soluzioni di scalabilità, vedere gli articoli seguenti: