Assegure o tráfego entre pods com políticas de rede no Azure Kubernetes Service (AKS)

Você precisa da CLI do Azure versão 2.0.61 ou posterior instalada e configurada. Encontre a versão usando o az --version comando. Se precisar de instalar ou atualizar, veja Install CLI do Azure (Instalar o CLI do Azure).

Em vez de usar uma identidade atribuída pelo sistema, você também pode usar uma identidade atribuída pelo usuário. Para obter mais informações, consulte Usar identidades gerenciadas.

• Terraform instalado, versão 1.6 ou posterior.
• CLI do Azure instalada e autenticada. Encontre a versão usando o az --version comando. Se precisar de instalar ou atualizar, veja Install CLI do Azure (Instalar o CLI do Azure). Utiliza a CLI do Azure para te ligares ao cluster depois de o Terraform o criar.
• Kubectl instalado. Você pode instalá-lo localmente usando o az aks install-cli comando. Utiliza kubectl para verificar o comportamento da política de rede.

Crie um cluster AKS com Azure Network Policy Manager (Linux)

1. Defina variáveis de ambiente para o nome do grupo de recursos, nome do cluster e localização. Substitua os valores conforme necessário.

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

2. Cria o grupo de recursos usando o az group create comando.

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

3. Crie um cluster AKS usando o az aks create e especifique azure para o 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
   

   Atenção

   O Azure Network Policy Manager (NPM) para nós nodes Linux será retirado em 30 de setembro de 2028. Para novas implementações, recomendamos usar o Azure CNI Powered by Cilium com a Política de Rede Cilium. Para migrar clusters existentes, consulte Migrar de NPM para Política de Rede Cilium.

Criar um cluster AKS com a Calico

Crie um cluster AKS usando o az aks create comando. Especificar --network-plugin azure e --network-policy calico. Quando especificas --network-policy calico, ativas o Calico tanto nos pools de nós Linux como do Windows.

Se planeia adicionar conjuntos de nós do Windows ao seu cluster, inclua os parâmetros windows-admin-username e windows-admin-password que satisfaçam os requisitos de palavra-passe do Windows Server. Para criar um nome de utilizador para usar como credenciais de administrador para os seus contentores do Windows Server no seu cluster, o seguinte comando indica-lhe um nome de utilizador. Defina-o como WINDOWS_USERNAME.

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

Instale o Azure Network Policy Manager ou Calico num cluster existente

Atualize um cluster existente para instalar Azure NPM ou Calico usando o az aks update comando e especificação azure ou calico para o --network-policy parâmetro. O seguinte comando de exemplo mostra como instalar qualquer um dos NPM do Azure:

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

Atualizar um cluster existente com Azure NPM ou Calico para Cilium

Para clusters que já usam o Azure CNI, atualize o plano de dados da rede para Cilium. Os clusters Kubenet devem primeiro migrar para o Azure CNI Overlay e depois atualizar o plano de dados da rede para o Cilium como uma operação separada. Revise os pré-requisitos e siga os passos em Atualizar um cluster existente para Azure CNI Powered by Cilium.

Conectar-se ao cluster AKS

Configure kubectl para ligar ao seu cluster usando o comando az aks get-credentials. Este comando baixa credenciais e configura a CLI do Kubernetes para usá-las.

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

Verificar a configuração da política de rede

Para iniciar a verificação da diretiva de rede, crie um aplicativo de exemplo e defina regras de tráfego.

1. Crie um namespace nomeado demo para executar os pods de exemplo usando o kubectl create namespace comando.

   kubectl create namespace demo
   

2. Crie um pod nomeado server para servir na porta TCP 80 usando o 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. Cria um pod chamado client para correr Bash usando o kubectl run comando.

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

   Note

   Se quiser programar o cliente ou servidor num nó específico, adicione este bit antes do argumento --command no comando de criação do pod kubectl run: --overrides='{"spec": { "nodeSelector": {"kubernetes.io/os": "linux|windows"}}}'.

4. Numa janela separada, obtenha o endereço IP do server pod usando o kubectl get pod comando.

   kubectl get pod --output=wide -n demo
   

   Sua saída deve ser semelhante à saída de exemplo a seguir:

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

Testar a conectividade utilizando políticas de rede

1. Crie um arquivo chamado demo-policy.yaml e cole o seguinte manifesto 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 o manifesto da política de rede usando o kubectl apply comando.

   kubectl apply -f demo-policy.yaml
   

3. No shell do cliente, verifique a conectividade com o servidor usando o seguinte /agnhost comando:

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

   A conectividade com o tráfego é bloqueada porque o servidor está rotulado com app=server, mas o cliente não está rotulado. Sua saída deve ser semelhante à saída de exemplo a seguir:

   TIMEOUT
   

4. Identifique o client e verifique a conectividade com o servidor com o comando kubectl label.

   kubectl label pod client -n demo app=client
   

   Se a conexão correr bem, não terá saída.

Migrar para a Calico autogerida

O AKS só suporta Calico para políticas de rede padrão do Kubernetes e não testa outras funcionalidades. Se quiser passar para a Calico autogerida, siga as instruções da Tigera em Migrar da Calico gerida pela Azure para a Calico autogerida. A documentação da Tigera menciona que para a Calico autogerida se define --network-policy none como na secção de desinstalação.

Desinstalar o Azure Network Policy Manager ou o Calico

Remover o Azure Network Policy Manager ou o Calico de um cluster existente usando o az aks update comando e a especificação none para o --network-policy parâmetro.

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

Alterar política de rede do cluster

Os passos seguintes mostram como alterar a política de rede existente de um cluster para Calico. O procedimento exige que a política de rede seja alterada para none e depois alterada para calico.

Os comandos utilizam variáveis especificadas anteriormente neste artigo: Crie um cluster AKS com o Azure Network Policy Manager (Linux). Caso contrário, substitua $RESOURCE_GROUP e $CLUSTER_NAME pelo grupo de recursos e nome do cluster.

1. Execute o comando seguinte para mostrar a política de rede existente do cluster.

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

2. Execute o seguinte comando para definir a política de rede para none.

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

3. Execute o seguinte comando para definir a política de rede para calico.

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

Limpar recursos

Neste artigo, você criou um namespace e dois pods e aplicou uma diretiva de rede. Se já não precisares destes recursos, podes apagá-los.

Apaga os recursos usando o kubectl delete comando.

kubectl delete namespace demo

Se seguiu os passos deste artigo para criar um cluster AKS, use o az group delete comando para eliminar o grupo de recursos AKS e o seu grupo de recursos relacionados, com um nome que começa por MC_.

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

Criar um cluster AKS com política de rede Cilium usando o Terraform

Esta secção mostra como usar o Terraform para implementar um cluster AKS que utiliza Azure CNI Powered by Cilium para rede e aplicação de políticas de rede e, em seguida, usar um recurso do Kubernetes NetworkPolicy para controlar o tráfego entre pods.

Este exemplo implementa:

• Um grupo de recursos.
• Um cluster do AKS que utiliza a rede Azure CNI Overlay com o Cilium como motor de políticas de rede e plano de dados da rede.

1. Crie um diretório para testar e executar o código de exemplo do Terraform, e torne-o o diretório atual.

2. Crie um arquivo chamado main.tfe insira o seguinte 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. Inicializar o Terraform executando o terraform init comando. Este comando descarrega o fornecedor Azure necessário para gerir os recursos Azure com o Terraform.

   terraform init
   

4. Formate e valide a configuração executando os terraform fmt comandos e terraform validate .

   terraform fmt
   terraform validate
   

5. Crie um plano de execução do Terraform executando o terraform plan comando. Este comando mostra-lhe os recursos que o Terraform cria ou modifica na sua subscrição do Azure.

   terraform plan
   

6. Aplica o plano de execução do Terraform executando o terraform apply comando. Este comando cria os recursos definidos no seu main.tf ficheiro na sua subscrição do Azure.

   terraform apply
   

Liga-te ao cluster AKS usando o Terraform

1. Instale a ferramenta de linha de comandos do Kubernetes executando o az aks install-cli comando e depois verifique a instalação.

   az aks install-cli
   kubectl version --client
   

2. Configure kubectl para se ligar ao seu cluster executando o az aks get-credentials comando. Este comando baixa credenciais e configura a CLI do Kubernetes para usá-las.

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

3. Verifica se o cluster está a funcionar executando o kubectl get nodes comando.

   kubectl get nodes
   

Verificar a configuração da política de rede usando o Terraform

Para verificar a configuração da política de rede, crie uma aplicação de exemplo e defina regras de tráfego.

1. Crie um namespace nomeado demo para executar os pods de exemplo usando o kubectl create namespace comando.

   kubectl create namespace demo
   

2. Crie um pod nomeado server para servir na porta TCP 80 executando o 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. Cria um pod nomeado client para correr Bash usando o kubectl run comando.

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

4. Numa janela separada, obtenha o endereço IP do server pod usando o kubectl get pod comando.

   kubectl get pod --output=wide -n demo
   

   Use o endereço IP do pod server ao testar a conectividade a partir da shell client na secção seguinte.

Teste a conectividade com políticas de rede usando o Terraform

O exemplo inclui um manifesto do Kubernetes NetworkPolicy que permite tráfego de entrada para pods com o rótulo app=server apenas a partir de pods com o rótulo app=client, na porta 80/TCP.

1. Crie um arquivo chamado network-policy.yamle insira o seguinte 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. Aplica a política de rede usando o kubectl apply comando.

   kubectl apply -f network-policy.yaml
   

3. No client shell, teste a conectividade ao servidor usando o seguinte /agnhost comando:

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

   A conectividade está bloqueada porque o servidor está rotulado com app=server, mas o cliente não está rotulado. Sua saída deve ser semelhante à saída de exemplo a seguir:

   TIMEOUT
   

4. Rotule o client e verifique a conectividade com o servidor utilizando o comando kubectl label.

   kubectl label pod client -n demo app=client
   

5. No client shell, teste novamente a conectividade ao servidor usando o mesmo /agnhost comando:

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

   Se a conexão correr bem, não terá saída.

6. Verifica a política de rede usando os kubectl get networkpolicy comandos e kubectl describe networkpolicy .

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

   A saída mostra que os pods rotulados app=server estão selecionados, o tráfego de entrada é permitido na porta TCP 80, e apenas os pods rotulados app=client podem iniciar ligações.

Limpar recursos usando o Terraform

Nesta secção, criou um namespace, dois pods e uma política de rede. Se já não precisar destes recursos Kubernetes, elimine-os antes de remover a infraestrutura do Azure subjacente.

Use o kubectl delete comando para eliminar os recursos.

kubectl delete namespace demo

Remova os recursos do Azure usando o terraform destroy comando.

terraform destroy