Proteggere il traffico tra pod con criteri di rete nel servizio Azure Kubernetes

È necessario che sia installata e configurata l'interfaccia della riga di comando di Azure 2.0.61 o versioni successive. Trovare la versione usando il az --version comando . Se è necessario eseguire l'installazione o l'aggiornamento, vedere Installare l'interfaccia della riga di comando di Azure.

Invece di utilizzare un'identità assegnata dal sistema, è possibile utilizzare un'identità assegnata dall'utente. Per altre informazioni, vedere Usare le identità gestite.

• Terraform installato, versione 1.6 o successiva.
• CLI di Azure installata e autenticata. Trovare la versione usando il az --version comando . Se è necessario eseguire l'installazione o l'aggiornamento, vedere Installare l'interfaccia della riga di comando di Azure. Si usa l'interfaccia della riga di comando di Azure (interfaccia della riga di comando di Azure) per connettersi al cluster dopo che Terraform lo ha creato.
• kubectl installato. È possibile installarlo in locale usando il az aks install-cli comando . Si usa kubectl per verificare il comportamento dei criteri di rete.

Creare un cluster AKS (Azure Kubernetes Service) con Azure Network Policy Manager (Linux)

1. Impostare le variabili di ambiente per il nome del gruppo di risorse, il nome del cluster e la posizione. Sostituire i valori in base alle esigenze.

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

2. Creare il gruppo di risorse usando il az group create comando .

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

3. Creare un cluster AKS usando az aks create e specificare azure per network-plugin e network-policy.

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

   Attenzione

   Azure Network Policy Manager (NPM) per i nodi Linux verrà ritirato il 30 settembre 2028. Per le nuove distribuzioni, è consigliabile usare Azure CNI con tecnologia Cilium con criteri di rete Cilium. Per eseguire la migrazione dei cluster esistenti, vedere Eseguire la migrazione da NPM a Criteri di rete Cilium.

Creare un cluster AKS con Calico

Creare un cluster AKS usando il comando az aks create. Specificare --network-plugin azure e --network-policy calico. Quando si specifica --network-policy calico, si abilita Calico sia in Linux che in Windows pool di nodi.

Se si intende aggiungere pool di nodi Windows al cluster, includere i parametri windows-admin-password e windows-admin-username che soddisfano i requisiti delle password di Windows Server. Per creare un nome utente da usare come credenziali di amministratore per i contenitori Windows Server nel cluster, il comando seguente richiede un nome utente. Impostarlo su WINDOWS_USERNAME.

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

Installare Azure Network Policy Manager o Calico in un cluster esistente

Aggiornare un cluster esistente per installare NPM di Azure o Calico usando il az aks update comando e specificando azure o calico per il --network-policy parametro . Il comando di esempio seguente illustra come installare Azure NPM:

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

Aggiornare un cluster esistente con NPM di Azure o Calico a Cilium

Per i cluster che usano già Azure CNI, aggiornare il piano dati di rete in Cilium. I cluster Kubenet devono prima eseguire la migrazione a Azure overlay CNI e quindi aggiornare il piano dati di rete a Cilium come operazione separata. Esaminare i prerequisiti e seguire i passaggi descritti in Aggiornare un cluster esistente a Azure CNI basato su Cilium.

Connettersi al cluster AKS

Configurare kubectl per connettersi al cluster usando il comando az aks get-credentials. Questo comando scarica le credenziali e configura l'interfaccia della riga di comando di Kubernetes per usarle.

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

Verificare la configurazione dei criteri di rete

Per iniziare la verifica dei criteri di rete, si crea un'applicazione di esempio e si impostano le regole di traffico.

1. Creare un namespace denominato demo per eseguire i pod di esempio usando il comando kubectl create namespace.

   kubectl create namespace demo
   

2. Creare un pod denominato server da servire sulla porta TCP 80 usando il 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. Creare un pod denominato client per eseguire Bash usando il kubectl run comando .

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

   Note

   Se si vuole pianificare il client o il server in un nodo specifico, aggiungere il bit seguente prima dell'argomento --command nel comando di creazione kubectl run del pod: --overrides='{"spec": { "nodeSelector": {"kubernetes.io/os": "linux|windows"}}}'.

4. In una finestra separata ottenere l'indirizzo IP del server pod usando il kubectl get pod comando .

   kubectl get pod --output=wide -n demo
   

   L'output dovrebbe essere simile all'output di esempio seguente:

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

Testare la connettività con le politiche di rete

1. Creare un file denominato demo-policy.yaml e incollare il manifesto YAML seguente:

   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. Applicare il manifesto dei criteri di rete usando il kubectl apply comando .

   kubectl apply -f demo-policy.yaml
   

3. Nella shell client verificare la connettività con il server usando il comando seguente /agnhost :

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

   La connettività con il traffico viene bloccata perché il server è etichettato con app=server, ma il client non è etichettato. L'output dovrebbe essere simile all'output di esempio seguente:

   TIMEOUT
   

4. Etichettare il client e verificare la connettività con il server usando il comando kubectl label.

   kubectl label pod client -n demo app=client
   

   Se la connessione ha esito positivo, non è presente alcun output.

Migrare a Calico gestito autonomamente

AKS supporta solo Calico per i criteri di rete standard di Kubernetes e non testa altre funzionalità. Se si vuole passare a Calico autogestito, seguire le istruzioni di Tigera su Eseguire la migrazione da Calico gestito da Azure a Calico autogestito. La documentazione di Tigera indica che per Calico autogestito imposti --network-policy none come nella sezione di disinstallazione.

Disinstallare Azure Network Policy Manager o Calico

Rimuovere Azure Network Policy Manager o Calico da un cluster esistente usando il az aks update comando e specificando none per il --network-policy parametro .

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

Modificare i criteri di rete del cluster

I passaggi seguenti illustrano come modificare i criteri di rete esistenti di un cluster in Calico. La procedura richiede che i criteri di rete vengano modificati in none e successivamente in calico.

I comandi usano le variabili specificate in precedenza in questo articolo creare un cluster AKS di Azure con Azure Network Policy Manager (Linux). In caso contrario, sostituire $RESOURCE_GROUP e $CLUSTER_NAME con il gruppo di risorse e il nome del cluster.

1. Eseguire il comando seguente per visualizzare i criteri di rete esistenti del cluster.

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

2. Eseguire il comando seguente per impostare i criteri di rete su none.

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

3. Eseguire il comando seguente per impostare i criteri di rete su calico.

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

Pulire le risorse

In questo articolo sono stati creati uno spazio dei nomi e due pod, inoltre sono stati applicati criteri di rete. Se queste risorse non sono più necessarie, è possibile eliminarle.

Eliminare le risorse usando il kubectl delete comando .

kubectl delete namespace demo

Se sono stati seguiti i passaggi di questo articolo per creare un cluster del servizio Azure Kubernetes, usare il az group delete comando per eliminare il gruppo di risorse del servizio Azure Kubernetes e il relativo gruppo di risorse correlato con un nome che inizia con MC_.

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

Creare un cluster AKS con il criterio di rete Cilium con Terraform

Questa sezione illustra come usare Terraform per distribuire un cluster AKS che usa Azure CNI Powered by Cilium per la rete e l'applicazione dei criteri di rete, e quindi utilizzare una risorsa Kubernetes NetworkPolicy per controllare il traffico tra i pod.

Questo esempio distribuisce:

• Un gruppo di risorse.
• Un cluster AKS che utilizza la rete overlay di Azure CNI con Cilium come motore dei criteri di rete e piano dati della rete.

1. Creare una directory per testare ed eseguire il codice Terraform di esempio e impostarlo come directory corrente.

2. Creare un file denominato main.tfe inserire il codice seguente:

   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. Inizializzare Terraform eseguendo il terraform init comando . Questo comando scarica il provider di Azure necessario per gestire le risorse Azure con Terraform.

   terraform init
   

4. Formattare e convalidare la configurazione eseguendo i terraform fmt comandi e terraform validate .

   terraform fmt
   terraform validate
   

5. Crea un piano di esecuzione di Terraform eseguendo il comando terraform plan. Questo comando mostra le risorse create o modificate da Terraform nella sottoscrizione Azure.

   terraform plan
   

6. Applica il piano di esecuzione di Terraform eseguendo il comando terraform apply. Questo comando crea le risorse definite nel main.tf file nella sottoscrizione Azure.

   terraform apply
   

Connettersi al cluster AKS usando Terraform

1. Installare lo strumento da riga di comando kubernetes eseguendo il az aks install-cli comando e quindi verificare l'installazione.

   az aks install-cli
   kubectl version --client
   

2. Configurare kubectl per connettersi al cluster eseguendo il az aks get-credentials comando . Questo comando scarica le credenziali e configura l'interfaccia della riga di comando di Kubernetes per usarle.

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

3. Verificare che il cluster sia in esecuzione eseguendo il kubectl get nodes comando .

   kubectl get nodes
   

Verificare la configurazione dei criteri di rete con Terraform

Per verificare la configurazione dei criteri di rete, creare un'applicazione di esempio e impostare le regole di traffico.

1. Crea un namespace denominato demo per eseguire i pod di esempio usando il comando kubectl create namespace.

   kubectl create namespace demo
   

2. Creare un pod denominato server da servire sulla porta TCP 80 eseguendo il 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. Creare un pod denominato client per eseguire Bash usando il kubectl run comando .

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

4. In una finestra separata ottenere l'indirizzo IP del server pod usando il kubectl get pod comando .

   kubectl get pod --output=wide -n demo
   

   Usare l'indirizzo IP del pod server quando si testa la connettività dalla shell client nella sezione successiva.

Testare la connettività con i criteri di rete usando Terraform

L'esempio include un manifest Kubernetes NetworkPolicy che consente il traffico in ingresso verso i pod etichettati app=server solo dai pod etichettati app=client sulla porta TCP 80.

1. Creare un file denominato network-policy.yamle inserire il codice seguente:

   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. Applicare i criteri di rete usando il kubectl apply comando .

   kubectl apply -f network-policy.yaml
   

3. Nella shell client, verificare la connettività al server usando il seguente /agnhost comando:

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

   La connettività è bloccata perché il server è etichettato con app=server, ma il client non è etichettato. L'output dovrebbe essere simile all'output di esempio seguente:

   TIMEOUT
   

4. Etichettare client e verificare la connettività con il server utilizzando il comando kubectl label.

   kubectl label pod client -n demo app=client
   

5. Nella shell testare di nuovo la client connettività al server usando lo stesso /agnhost comando:

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

   Se la connessione ha esito positivo, non è presente alcun output.

6. Verificare i criteri di rete usando i kubectl get networkpolicy comandi e kubectl describe networkpolicy .

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

   L'output mostra che i pod etichettati app=server sono selezionati, il traffico in ingresso è consentito sulla porta TCP 80 e solo i pod etichettati app=client possono avviare le connessioni.

Pulire le risorse usando Terraform

In questa sezione, hai creato un namespace, due pod e una network policy. Se queste risorse Kubernetes non sono più necessarie, eliminarle prima di rimuovere l'infrastruttura di Azure sottostante.

Usare il kubectl delete comando per eliminare le risorse.

kubectl delete namespace demo

Rimuovere le risorse Azure usando il terraform destroy comando .

terraform destroy