Creación y configuración de un clúster de Azure Kubernetes Service (AKS) para usar nodos virtuales mediante la CLI de Azure

Artículo
08/02/2024

Los nodos virtuales permiten la comunicación de red entre los pods que se ejecutan en Azure Container Instances (ACI) y los clústeres de AKS. Para proporcionar esta comunicación, cree una subred de red virtual y asigne permisos delegados. Los nodos virtuales solo funcionan con clústeres de AKS creados mediante redes avanzadas (Azure CNI). De forma predeterminada, los clústeres de AKS se crean con redes básicas (kubenet). En este artículo se explica cómo crear una red virtual y subredes y, después, cómo implementar un clúster de AKS que usa redes avanzadas.

En este artículo se muestra cómo usar la CLI de Azure para crear y configurar los recursos de red virtual y un clúster de AKS con nodos virtuales habilitados.

Antes de empezar

Importante

Antes de usar nodos virtuales con AKS, revise las limitaciones de los nodos virtuales de AKS y las limitaciones de redes virtuales de ACI. Estas limitaciones afectan a la ubicación, la configuración de redes y otros detalles de configuración del clúster de AKS y los nodos virtuales.

Necesita el proveedor de servicios de ACI registrado con su suscripción. Puede comprobar el estado del registro del proveedor de ACI mediante el comando az provider list.
```
az provider list --query "[?contains(namespace,'Microsoft.ContainerInstance')]" -o table
```
El proveedor Microsoft.ContainerInstance debería notificar como Registrado, tal como se muestra en el siguiente ejemplo de salida:
```
Namespace                    RegistrationState    RegistrationPolicy
---------------------------  -------------------  --------------------
Microsoft.ContainerInstance  Registered           RegistrationRequired
```
Si el proveedor se muestra como NotRegistered, registre el proveedor con el comando az provider register.
```
az provider register --namespace Microsoft.ContainerInstance
```
Si se usa la CLI de Azure, este artículo requiere la versión 2.0.49 o posterior. Ejecute az --version para encontrar la versión. Si necesita instalarla o actualizarla, vea Instalación de la CLI de Azure. También puede usar Azure Cloud Shell.

Inicio de Azure Cloud Shell

Azure Cloud Shell es un shell interactivo gratuito que puede usar para ejecutar los pasos de este artículo. Tiene las herramientas comunes de Azure preinstaladas y configuradas.

Para abrir Cloud Shell, seleccione Pruébelo en la esquina superior derecha de un bloque de código. También puede ir a https://shell.azure.com/bash para iniciar Cloud Shell en una pestaña independiente del explorador. Seleccione Copiar para copiar los bloques de código, péguelos en Cloud Shell y, luego, presione Entrar para ejecutarlos.

Crear un grupo de recursos

Un grupo de recursos de Azure es un grupo lógico en el que se implementan y administran recursos de Azure.

Cree un grupo de recursos con el comando az group create.

az group create --name myResourceGroup --location eastus

Creación de una red virtual

Importante

El nodo virtual requiere una red virtual personalizada y una subred asociada. No se puede asociar a la misma red virtual que el clúster de AKS.

Cree una red virtual mediante el comando az network vnet create. En el ejemplo siguiente se crea una red virtual denominada myVnet con un prefijo de dirección de 10.0.0.0/8 y una subred llamada myAKSSubnet. El valor predeterminado del prefijo de la dirección de esta subred es 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
```
Cree una subred adicional para los nodos virtuales mediante el comando az network vnet subnet create. En el ejemplo siguiente se crea una subred llamada myVirtualNodeSubnet con un prefijo de dirección de 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
```

Creación de un clúster de AKS con una identidad administrada

Obtenga el identificador de subred mediante el comando az network vnet subnet show.

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

Cree un clúster de AKS mediante el comando az aks create y reemplace <subnetId> por el identificador obtenido en el paso anterior. En el siguiente ejemplo se crea un clúster denominado myAKSCluster con cinco nodos.
```
az aks create \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --node-count 5 \
    --network-plugin azure \
    --vnet-subnet-id <subnetId> \
    --generate-ssh-keys
```
En unos minutos, terminará de ejecutarse el comando, que devuelve información con formato JSON sobre el clúster.

Para más información sobre las identidades administradas, consulte Usar identidades administradas.

Habilitar el complemento de nodos virtuales

Habilite los nodos virtuales mediante el comando az aks enable-addons. En el ejemplo siguiente se usa la subred denominada myVirtualNodeSubnet creada en un paso anterior.
```
az aks enable-addons \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --addons virtual-node \
    --subnet-name myVirtualNodeSubnet
```

Conectarse al clúster

Para configurar kubectl para conectarse a su clúster de Kubernetes, use el comando az aks get-credentials. Con este paso se descargan las credenciales y se configura la CLI de Kubernetes para usarlas.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Compruebe la conexión al clúster usando el comando kubectl get, que devuelve una lista de los nodos del clúster.
```
kubectl get nodes
```
La salida de ejemplo siguiente muestra el nodo de máquina virtual único creado y el nodo virtual para 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
```

Implementación de una aplicación de ejemplo

Cree un archivo denominado virtual-node.yaml y cópielo en el siguiente código YAML. YAML programa el contenedor en el nodo definiendo un nodeSelector y toleration.

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

Ejecute la aplicación con el comando kubectl apply.
```
kubectl apply -f virtual-node.yaml
```
Obtenga una lista de pods y el nodo programado mediante el comando kubectl get pods con el argumento -o wide.
```
kubectl get pods -o wide
```
El pod está programado en el nodo virtual virtual-node-aci-linux, como se muestra en la salida de ejemplo siguiente:
```
NAME                            READY     STATUS    RESTARTS   AGE       IP           NODE
aci-helloworld-9b55975f-bnmfl   1/1       Running   0          4m        10.241.0.4   virtual-node-aci-linux
```
Se asigna una dirección IP interna al pod de la subred de red virtual de Azure delegada para su uso con los nodos virtuales.

Nota

Si usa imágenes almacenadas en Azure Container Registry, configure y use un secreto de Kubernetes. Una limitación actual de los nodos virtuales es que no se puede usar la autenticación de entidad de servicio de Microsoft Entra integrada. Si no usa un secreto, los pods programados en los nodos virtuales no se pueden iniciar y se notifica el error HTTP response status code 400 error code "InaccessibleImage".

Prueba del pod del nodo virtual

Para probar el pod que se ejecuta en el nodo virtual, vaya a la aplicación de demostración con un cliente web. Como se asigna una dirección IP interna al pod, puede probar rápidamente esta conectividad desde otro pod en el clúster de AKS.
Cree un pod de prueba y adjunte una sesión de terminal con el comando kubectl run -it siguiente.
```
kubectl run -it --rm testvk --image=mcr.microsoft.com/dotnet/runtime-deps:6.0
```

Instale curl en el pod mediante apt-get.

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

Acceda a la dirección de su pod mediante curl, como http://10.241.0.4. Proporcione su propia dirección IP interna mostrada en el comando kubectl get pods anterior.
```
curl -L http://10.241.0.4
```
Se muestra la aplicación de demostración, tal como se muestra en la siguiente salida de ejemplo reducida:
```
<html>
<head>
  <title>Welcome to Azure Container Instances!</title>
</head>
[...]
```
Cierre la sesión de terminal en su pod de prueba con exit. Cuando la sesión finaliza, el pod se elimina.

Quitar nodos virtuales

Elimine el pod aci-helloworld que se ejecuta en el nodo virtual mediante el comando kubectl delete.
```
kubectl delete -f virtual-node.yaml
```

Deshabilite los nodos virtuales mediante el comando az aks disable-addons.

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

Quite los recursos de red virtual y el grupo de recursos mediante los siguientes comandos.

# 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

Pasos siguientes

En este artículo, programó un pod en el nodo virtual y se le asignó una dirección IP privada interna. En su lugar, podría crear una implementación de servicio y enrutar el tráfico a su pod a través de un equilibrador de carga o controlador de entrada. Para más información, consulte Creación de un controlador de entrada en Azure Kubernetes Service (AKS).

Los nodos virtuales suelen ser un componente de una solución de escalado en AKS. Para más información sobre soluciones de escalado, consulte los siguientes artículos:

Compartir a través de