Tworzenie i konfigurowanie klastra usługi Azure Kubernetes Services (AKS) do używania węzłów wirtualnych przy użyciu interfejsu wiersza polecenia platformy Azure

Artykuł
08/28/2023

Węzły wirtualne umożliwiają komunikację sieciową między zasobnikami uruchomionymi w klastrach Azure Container Instances (ACI) i AKS. Aby zapewnić tę komunikację, należy utworzyć podsieć sieci wirtualnej i przypisać delegowane uprawnienia. Węzły wirtualne działają tylko z klastrami usługi AKS utworzonymi przy użyciu zaawansowanych sieci (Azure CNI). Domyślnie klastry usługi AKS są tworzone przy użyciu podstawowej sieci (kubenet). W tym artykule przedstawiono sposób tworzenia sieci wirtualnej i podsieci, a następnie wdrażania klastra usługi AKS korzystającego z zaawansowanych sieci.

W tym artykule pokazano, jak za pomocą interfejsu wiersza polecenia platformy Azure tworzyć i konfigurować zasoby sieci wirtualnej oraz klaster usługi AKS z włączonymi węzłami wirtualnymi.

Zanim rozpoczniesz

Ważne

Przed użyciem węzłów wirtualnych z usługą AKS zapoznaj się zarówno z ograniczeniami węzłów wirtualnych usługi AKS , jak i ograniczeniami sieci wirtualnej usługi ACI. Te ograniczenia wpływają na lokalizację, konfigurację sieci i inne szczegóły konfiguracji zarówno klastra usługi AKS, jak i węzłów wirtualnych.

Potrzebujesz dostawcy usługi ACI zarejestrowanego w ramach subskrypcji. Stan rejestracji dostawcy usługi ACI można sprawdzić przy użyciu az provider list polecenia .
```
az provider list --query "[?contains(namespace,'Microsoft.ContainerInstance')]" -o table
```
Dostawca Microsoft.ContainerInstance powinien zgłosić wartość Zarejestrowano, jak pokazano w poniższych przykładowych danych wyjściowych:
```
Namespace                    RegistrationState    RegistrationPolicy
---------------------------  -------------------  --------------------
Microsoft.ContainerInstance  Registered           RegistrationRequired
```
Jeśli dostawca jest wyświetlany jako NotRegistered, zarejestruj dostawcę przy użyciu polecenia az provider register.
```
az provider register --namespace Microsoft.ContainerInstance
```
W przypadku korzystania z interfejsu wiersza polecenia platformy Azure ten artykuł wymaga interfejsu wiersza polecenia platformy Azure w wersji 2.0.49 lub nowszej. Uruchom polecenie az --version, aby dowiedzieć się, jaka wersja jest używana. Jeśli konieczna będzie instalacja lub uaktualnienie, zobacz Instalowanie interfejsu wiersza polecenia platformy Azure. Możesz również użyć usługi Azure Cloud Shell.

Uruchamianie usługi Azure Cloud Shell

Usługa Azure Cloud Shell to bezpłatna interaktywna powłoka, której można użyć do uruchomienia kroków opisanych w tym artykule. Ma ona typowe narzędzia platformy Azure wstępnie zainstalowane i skonfigurowane.

Aby otworzyć Cloud Shell, wybierz pozycję Wypróbuj w prawym górnym rogu bloku kodu. Możesz również uruchomić usługę Cloud Shell w oddzielnej karcie przeglądarki, przechodząc do strony https://shell.azure.com/bash. Wybierz przycisk Kopiuj, aby skopiować bloki kodu, wklej je do usługi Cloud Shell, a następnie naciśnij klawisz Enter, aby je uruchomić.

Tworzenie grupy zasobów

Grupa zasobów platformy Azure to logiczna grupa przeznaczona do wdrażania zasobów platformy Azure i zarządzania nimi.

Utwórz grupę zasobów przy użyciu az group create polecenia .
```
az group create --name myResourceGroup --location eastus
```

Tworzenie sieci wirtualnej

Ważne

Węzeł wirtualny wymaga niestandardowej sieci wirtualnej i skojarzonej podsieci. Nie można go skojarzyć z tą samą siecią wirtualną co klaster usługi AKS.

Utwórz sieć wirtualną przy użyciu az network vnet create polecenia . Poniższy przykład tworzy sieć wirtualną o nazwie myVnet z prefiksem adresu 10.0.0.0/8 i podsiecią o nazwie myAKSSubnet. Prefiks adresu tej podsieci domyślnie to 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
```
Utwórz dodatkową podsieć dla węzłów wirtualnych za pomocą az network vnet subnet create polecenia . Poniższy przykład tworzy podsieć o nazwie myVirtualNodeSubnet z prefiksem adresu 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
```

Tworzenie klastra usługi AKS z tożsamością zarządzaną

Pobierz identyfikator podsieci przy użyciu az network vnet subnet show polecenia .

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

Utwórz klaster usługi AKS przy użyciu az aks create polecenia i zastąp <subnetId> ciąg identyfikatorem uzyskanym w poprzednim kroku. Poniższy przykład tworzy klaster o nazwie myAKSCluster z pięcioma węzłami.
```
az aks create \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --node-count 5 \
    --network-plugin azure \
    --vnet-subnet-id <subnetId>
```
Po kilku minutach polecenie zostanie zakończone i zwróci informacje o klastrze sformatowanym przy użyciu formatu JSON.

Aby uzyskać więcej informacji na temat tożsamości zarządzanych, zobacz Używanie tożsamości zarządzanych.

Włączanie dodatku węzłów wirtualnych

Włącz węzły wirtualne przy użyciu az aks enable-addons polecenia . W poniższym przykładzie użyto podsieci o nazwie myVirtualNodeSubnet utworzonej w poprzednim kroku.
```
az aks enable-addons \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --addons virtual-node \
    --subnet-name myVirtualNodeSubnet
```

Łączenie z klastrem

Skonfiguruj kubectl , aby nawiązać połączenie z klastrem az aks get-credentials Kubernetes przy użyciu polecenia . Ten krok umożliwia pobranie poświadczeń i skonfigurowanie interfejsu wiersza polecenia Kubernetes do ich użycia.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Sprawdź połączenie z klastrem przy użyciu kubectl get polecenia , które zwraca listę węzłów klastra.
```
kubectl get nodes
```
W poniższych przykładowych danych wyjściowych przedstawiono utworzony pojedynczy węzeł maszyny wirtualnej i węzeł wirtualny dla systemu 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
```

Wdrażanie przykładowej aplikacji

Utwórz plik o nazwie virtual-node.yaml i skopiuj go w następującym języku YAML. Kod YAML planuje kontener w węźle, definiując węzełSelector i tolerancję.

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

Uruchom aplikację przy użyciu kubectl apply polecenia .
```
kubectl apply -f virtual-node.yaml
```
Pobierz listę zasobników i zaplanowanego węzła przy użyciu kubectl get pods polecenia z argumentem -o wide .
```
kubectl get pods -o wide
```
Zasobnik jest zaplanowany na wirtualnym węźle wirtualnym virtual-node-aci-linux, jak pokazano w poniższych przykładowych danych wyjściowych:
```
NAME                            READY     STATUS    RESTARTS   AGE       IP           NODE
aci-helloworld-9b55975f-bnmfl   1/1       Running   0          4m        10.241.0.4   virtual-node-aci-linux
```
Zasobnik jest przypisany do wewnętrznego adresu IP z podsieci sieci wirtualnej platformy Azure delegowanej do użycia z węzłami wirtualnymi.

Uwaga

Jeśli używasz obrazów przechowywanych w Azure Container Registry, skonfiguruj i użyj wpisu tajnego platformy Kubernetes. Bieżące ograniczenie węzłów wirtualnych polega na tym, że nie można używać zintegrowanego uwierzytelniania jednostki usługi Azure AD. Jeśli nie używasz wpisu tajnego, zasobniki zaplanowane na węzłach wirtualnych nie mogą uruchomić i zgłosić błąd HTTP response status code 400 error code "InaccessibleImage".

Testowanie zasobnika węzła wirtualnego

Przetestuj zasobnik uruchomiony w węźle wirtualnym, przechodząc do aplikacji demonstracyjnej przy użyciu klienta internetowego. Gdy zasobnik jest przypisany do wewnętrznego adresu IP, można szybko przetestować tę łączność z innego zasobnika w klastrze usługi AKS.
Utwórz zasobnik testowy i dołącz do niego sesję terminalu przy użyciu następującego kubectl run -it polecenia.
```
kubectl run -it --rm testvk --image=mcr.microsoft.com/dotnet/runtime-deps:6.0
```
Zainstaluj curl w zasobniku przy użyciu polecenia apt-get.
```
apt-get update && apt-get install -y curl
```
Uzyskaj dostęp do adresu zasobnika przy użyciu elementu curl, takiego jak http://10.241.0.4. Podaj własny wewnętrzny adres IP pokazany w poprzednim kubectl get pods poleceniu.
```
curl -L http://10.241.0.4
```
Zostanie wyświetlona aplikacja demonstracyjna, jak pokazano w następujących skróconych przykładowych danych wyjściowych:
```
<html>
<head>
  <title>Welcome to Azure Container Instances!</title>
</head>
[...]
```
Zamknij sesję terminalu do zasobnika testowego za pomocą polecenia exit. Po zakończeniu sesji zasobnik zostanie usunięty.

Usuwanie węzłów wirtualnych

aci-helloworld Usuń zasobnik uruchomiony w węźle wirtualnym przy użyciu kubectl delete polecenia .
```
kubectl delete -f virtual-node.yaml
```

Wyłącz węzły wirtualne przy użyciu az aks disable-addons polecenia .

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

Usuń zasoby sieci wirtualnej i grupę zasobów przy użyciu następujących poleceń.

# 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

Następne kroki

W tym artykule zaplanowano zasobnik w węźle wirtualnym i przypisano prywatny wewnętrzny adres IP. Zamiast tego można utworzyć wdrożenie usługi i kierować ruch do zasobnika za pomocą modułu równoważenia obciążenia lub kontrolera ruchu przychodzącego. Aby uzyskać więcej informacji, zobacz Tworzenie podstawowego kontrolera ruchu przychodzącego w usłudze AKS.

Węzły wirtualne są często jednym składnikiem rozwiązania do skalowania w usłudze AKS. Aby uzyskać więcej informacji na temat skalowania rozwiązań, zobacz następujące artykuły: