Asegurar el tráfico entre pods utilizando directivas de red en Azure Kubernetes Service (AKS)

Es preciso que esté instalada y configurada la versión 2.0.61 de la CLI de Azure u otra versión posterior. Busque la versión con el comando az --version. Si necesita instalarla o actualizarla, vea Instalación de la CLI de Azure.

En lugar de usar una identidad asignada por el sistema, también puede usar una identidad asignada por el usuario. Para más información, consulte Uso de identidades administradas.

• Terraform instalado, versión 1.6 o posterior.
• La CLI de Azure instalada y autenticada. Busque la versión con el comando az --version. Si necesita instalarla o actualizarla, vea Instalación de la CLI de Azure. Use el CLI de Azure para conectarse al clúster después de que Terraform lo cree.
• kubectl instalado. Puede instalarlo localmente mediante el az aks install-cli comando . Se usa kubectl para verificar el comportamiento de la directiva de red.

Creación de un clúster de AKS con Azure Network Policy Manager (Linux)

1. Establezca variables de entorno para el nombre del grupo de recursos, el nombre del clúster y la ubicación. Reemplace los valores según sea necesario.

   export RESOURCE_GROUP=myResourceGroup
   export CLUSTER_NAME=myAKSCluster
   export LOCATION=eastus
   

2. Cree el grupo de recursos mediante el az group create comando .

   az group create --resource-group $RESOURCE_GROUP --location $LOCATION
   

3. Cree un clúster de AKS usando az aks create y especifique azure para network-plugin y network-policy.

   az aks create \
       --resource-group $RESOURCE_GROUP \
       --name $CLUSTER_NAME \
       --node-count 1 \
       --network-plugin azure \
       --network-policy azure \
       --generate-ssh-keys
   

   Precaución

   Azure Network Policy Manager (NPM) para nodos de Linux se retirará el 30 de septiembre de 2028. En el caso de las nuevas implementaciones, se recomienda usar Azure CNI Powered by Cilium con la directiva de red de Cilium. Para migrar clústeres existentes, consulte Migración de NPM a directiva de red de Cilium.

Creación de un clúster de AKS con Calico

Cree un clúster de AKS mediante el az aks create comando . Especifique --network-plugin azure y --network-policy calico. Al especificar --network-policy calico, habilitas Calico tanto en los grupos de nodos de Linux como en los de Windows.

Si tiene previsto agregar grupos de nodos de Windows al clúster, incluya los parámetros windows-admin-username y windows-admin-password que cumplan con los requisitos de contraseña de Windows Server. Para crear un nombre de usuario que se utilice como credenciales de administrador para los contenedores de Windows Server en el clúster, el siguiente comando te pedirá que introduzcas un nombre de usuario. Configúrelo como WINDOWS_USERNAME.

echo "Please enter the username to use as administrator credentials for Windows Server containers on your cluster: " && read WINDOWS_USERNAME

Instalación de Azure Network Policy Manager o Calico en un clúster existente

Actualice un clúster existente para instalar Azure NPM o Calico mediante el az aks update comando y especificando azure o calico para el --network-policy parámetro . En el siguiente comando de ejemplo se muestra cómo instalar azure NPM:

az aks update \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --network-policy azure

Actualización de un clúster existente con Azure NPM o Calico a Cilium

En el caso de los clústeres que ya usan Azure CNI, actualice el plano de datos de red a Cilium. Los clústeres de Kubenet deben migrar primero a Azure CNI Overlay y, a continuación, actualizar el plano de datos de red a Cilium en una operación independiente. Revise los requisitos previos y siga los pasos descritos en Actualización de un clúster existente para Azure CNI Powered by Cilium.

Conexión al clúster de AKS

Configure kubectl para conectarse al clúster ejecutando el comando az aks get-credentials. Con este comando se descargan las credenciales y se configura la CLI de Kubernetes para usarlas.

az aks get-credentials --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME

Comprobación de la configuración de directivas de red

Para comenzar la comprobación de la directiva de red, creará una aplicación de ejemplo y establecerá reglas de tráfico.

1. Cree un espacio de nombres denominado demo para ejecutar los pods de ejemplo usando el comando kubectl create namespace.

   kubectl create namespace demo
   

2. Cree un pod denominado server para servir en el puerto TCP 80 mediante el kubectl run comando .

   kubectl run server -n demo --image=k8s.gcr.io/e2e-test-images/agnhost:2.33 --labels="app=server" --port=80 --command -- /agnhost serve-hostname --tcp --http=false --port "80"
   

3. Cree un pod denominado client para ejecutar Bash mediante el kubectl run comando .

   kubectl run -it client -n demo --image=k8s.gcr.io/e2e-test-images/agnhost:2.33 --command -- bash
   

   Note

   Si desea programar el cliente o servidor en un nodo determinado, agregue el siguiente bit antes del --command argumento en el comando de creación kubectl run del pod: --overrides='{"spec": { "nodeSelector": {"kubernetes.io/os": "linux|windows"}}}'.

4. En una ventana independiente, obtenga la dirección IP del server pod mediante el kubectl get pod comando .

   kubectl get pod --output=wide -n demo
   

   La salida debería ser similar a la salida de ejemplo siguiente:

   NAME     READY   STATUS    RESTARTS   AGE   IP            NODE             NOMINATED NODE   READINESS GATES
   server   1/1     Running   0          30s   10.224.0.72   akswin22000001   <none>           <none>
   

Prueba de la conectividad con directivas de red

1. Cree un archivo denominado demo-policy.yaml y pegue el siguiente manifiesto de YAML:

   apiVersion: networking.k8s.io/v1
   kind: NetworkPolicy
   metadata:
     name: demo-policy
     namespace: demo
   spec:
     podSelector:
       matchLabels:
         app: server
     ingress:
     - from:
       - podSelector:
           matchLabels:
             app: client
       ports:
       - port: 80
         protocol: TCP
   

2. Aplique el manifiesto de directiva de red mediante el kubectl apply comando .

   kubectl apply -f demo-policy.yaml
   

3. En el shell de cliente, compruebe la conectividad con el servidor mediante el siguiente /agnhost comando:

   /agnhost connect <server-ip>:80 --timeout=3s --protocol=tcp
   

   La conectividad con el tráfico se bloquea porque el servidor está etiquetado con app=server, pero el cliente no está etiquetado. La salida debería ser similar a la salida de ejemplo siguiente:

   TIMEOUT
   

4. Etiqueta el client y comprueba la conectividad con el servidor con el comando kubectl label.

   kubectl label pod client -n demo app=client
   

   Si la conexión se realiza correctamente, no hay ninguna salida.

Migración a Calico autoadministrado

AKS solo admite Calico para las directivas de red estándar de Kubernetes y no prueba otras características. Si quiere pasar a Calico autoadministrado, siga las instrucciones de Tigera en Migración de Calico administrado por Azure a Calico autoadministrado. En la documentación de Tigera se indica que para Calico autoadministrado se usa --network-policy none, igual que en la sección de desinstalación.

Desinstalación de Azure Network Policy Manager o Calico

Quite Azure Network Policy Manager o Calico de un clúster existente mediante el az aks update comando y especifique none para el --network-policy parámetro .

az aks update \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --network-policy none

Cambio de la directiva de red del clúster

En los pasos siguientes se muestra cómo cambiar la directiva de red existente de un clúster a Calico. El procedimiento requiere que la directiva de red cambie a none y, a continuación, cambie a calico.

Los comandos usan variables especificadas anteriormente en este artículo Creación de un clúster de AKS con Azure Network Policy Manager (Linux). De lo contrario, reemplace $RESOURCE_GROUP y $CLUSTER_NAME por el nombre y el grupo de recursos del clúster.

1. Ejecute el siguiente comando para mostrar la directiva de red existente del clúster.

   az aks show \
     --resource-group $RESOURCE_GROUP \
     --name $CLUSTER_NAME \
     --query "networkProfile" \
     --output table
   

2. Ejecute el siguiente comando para establecer la directiva de red en none.

   az aks update --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --network-policy none
   

3. Ejecute el siguiente comando para establecer la directiva de red en calico.

   az aks update --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --network-policy calico
   

Limpieza de recursos

En este artículo, ha creado un espacio de nombres y dos pods, y ha aplicado una directiva de red. Si ya no necesita estos recursos, puede eliminarlos.

Elimine los recursos mediante el kubectl delete comando .

kubectl delete namespace demo

Si ha seguido los pasos de este artículo para crear un clúster de AKS, use el az group delete comando para eliminar el grupo de recursos de AKS y su grupo de recursos relacionado con un nombre que comience por MC_.

az group delete --resource-group $RESOURCE_GROUP --no-wait --yes

Creación de un clúster de AKS con una directiva de red de Cilium mediante Terraform

En esta sección se muestra cómo usar Terraform para implementar un clúster de AKS que usa Azure CNI Powered by Cilium para la aplicación de directivas de red y redes y, a continuación, usar un recurso de Kubernetes NetworkPolicy para controlar el tráfico de pod a pod.

En este ejemplo se implementa:

• Un grupo de recursos.
• Un clúster de AKS que usa la red superpuesta de Azure CNI con Cilium como motor de directivas de red y plano de datos de red.

1. Cree un directorio para probar y ejecutar el código de Terraform de ejemplo y convertirlo en el directorio actual.

2. Cree un archivo llamado main.tf e inserte el siguiente código:

   terraform {
     required_version = ">= 1.6.0"
     required_providers {
       azurerm = {
         source  = "hashicorp/azurerm"
         version = "~> 4.0"
       }
     }
   }
   
   provider "azurerm" {
     features {}
   }
   
   resource "azurerm_resource_group" "example" {
     name     = "rg-aks-network-policy-example"
     location = "eastus"
   }
   
   resource "azurerm_kubernetes_cluster" "example" {
     name                = "aks-network-policy-example"
     location            = azurerm_resource_group.example.location
     resource_group_name = azurerm_resource_group.example.name
     dns_prefix          = "aksnetpolicyexample"
   
     default_node_pool {
       name       = "default"
       node_count = 1
       vm_size    = "Standard_D2s_v3"
   
       upgrade_settings {
         drain_timeout_in_minutes      = 0
         max_surge                     = "10%"
         node_soak_duration_in_minutes = 0
       }
     }
   
     identity {
       type = "SystemAssigned"
     }
   
     network_profile {
       network_plugin      = "azure"
       network_plugin_mode = "overlay"
       network_policy      = "cilium"
       network_data_plane  = "cilium"
       load_balancer_sku   = "standard"
     }
   }
   

3. Para inicializar Terraform, ejecute el terraform init comando . Este comando descarga el proveedor de Azure necesario para administrar recursos de Azure con Terraform.

   terraform init
   

4. Dé formato y valide la configuración mediante la ejecución de los terraform fmt comandos y terraform validate .

   terraform fmt
   terraform validate
   

5. Cree un plan de ejecución de Terraform ejecutando el terraform plan comando . Este comando muestra los recursos que Terraform crea o modifica en la suscripción de Azure.

   terraform plan
   

6. Aplique el plan de ejecución de Terraform ejecutando el comando terraform apply. Este comando crea los recursos definidos en su archivo main.tf en su suscripción de Azure.

   terraform apply
   

Conexión al clúster de AKS mediante Terraform

1. Instale la herramienta de línea de comandos de Kubernetes ejecutando el az aks install-cli comando y, a continuación, compruebe la instalación.

   az aks install-cli
   kubectl version --client
   

2. Configure kubectl para conectarlo a su clúster ejecutando el comando az aks get-credentials. Con este comando se descargan las credenciales y se configura la CLI de Kubernetes para usarlas.

   az aks get-credentials \
       --resource-group rg-aks-network-policy-example \
       --name aks-network-policy-example
   

3. Para comprobar que el clúster se está ejecutando, ejecute el kubectl get nodes comando .

   kubectl get nodes
   

Comprobación de la configuración de directivas de red mediante Terraform

Para comprobar la configuración de la directiva de red, cree una aplicación de ejemplo y establezca reglas de tráfico.

1. Cree un espacio de nombres denominado demo para ejecutar los pods de ejemplo usando el comando kubectl create namespace.

   kubectl create namespace demo
   

2. Cree un pod denominado server para servir en el puerto TCP 80 mediante la ejecución del kubectl run comando .

   kubectl run server \
     -n demo \
     --image=k8s.gcr.io/e2e-test-images/agnhost:2.33 \
     --labels="app=server" \
     --port=80 \
     --command -- /agnhost serve-hostname --tcp --http=false --port "80"
   

3. Cree un pod denominado client para ejecutar Bash mediante el kubectl run comando .

   kubectl run -it client \
     -n demo \
     --image=k8s.gcr.io/e2e-test-images/agnhost:2.33 \
     --command -- bash
   

4. En una ventana independiente, obtenga la dirección IP del server pod mediante el kubectl get pod comando .

   kubectl get pod --output=wide -n demo
   

   Utilice la dirección IP del pod server cuando pruebe la conectividad desde la shell client en la siguiente sección.

Prueba de la conectividad con directivas de red mediante Terraform

El ejemplo incluye un manifiesto de Kubernetes NetworkPolicy que permite tráfico entrante hacia pods con la etiqueta app=server únicamente desde pods con la etiqueta app=client a través del puerto TCP 80.

1. Cree un archivo llamado network-policy.yaml e inserte el siguiente código:

   apiVersion: networking.k8s.io/v1
   kind: NetworkPolicy
   metadata:
     name: demo-policy
     namespace: demo
   spec:
     podSelector:
       matchLabels:
         app: server
     policyTypes:
       - Ingress
     ingress:
       - from:
           - podSelector:
               matchLabels:
                 app: client
         ports:
           - protocol: TCP
             port: 80
   

2. Aplique la directiva de red mediante el kubectl apply comando .

   kubectl apply -f network-policy.yaml
   

3. En el client intérprete de comandos, compruebe la conectividad con el servidor mediante el siguiente /agnhost comando:

   /agnhost connect <server-ip>:80 --timeout=3s --protocol=tcp
   

   La conectividad se bloquea porque el servidor está etiquetado con app=server, pero el cliente no está etiquetado. La salida debería ser similar a la salida de ejemplo siguiente:

   TIMEOUT
   

4. Etiquete client y compruebe la conectividad con el servidor mediante el comando kubectl label.

   kubectl label pod client -n demo app=client
   

5. En el client shell, vuelva a probar la conectividad con el servidor mediante el mismo /agnhost comando:

   /agnhost connect <server-ip>:80 --timeout=3s --protocol=tcp
   

   Si la conexión se realiza correctamente, no hay ninguna salida.

6. Compruebe la directiva de red mediante los kubectl get networkpolicy comandos y kubectl describe networkpolicy .

   kubectl get networkpolicy -n demo
   kubectl describe networkpolicy demo-policy -n demo
   

   La salida muestra que los pods etiquetados app=server están seleccionados, se permite el tráfico de entrada en el puerto TCP 80 y solo los pods etiquetados app=client pueden iniciar conexiones.

Limpieza de recursos mediante Terraform

En esta sección, ha creado un espacio de nombres, dos pods y una directiva de red. Si ya no necesita estos recursos de Kubernetes, elimínelos antes de quitar la infraestructura de Azure subyacente.

Use el kubectl delete comando para eliminar los recursos.

kubectl delete namespace demo

Quite los recursos de Azure mediante el terraform destroy comando .

terraform destroy