

 **Ajudar a melhorar esta página** 

Para contribuir com este guia de usuário, escolha o link **Editar esta página no GitHub**, disponível no painel direito de cada página.

# Restringir o tráfego de rede de pods com políticas de rede do Kubernetes
<a name="cni-network-policy-configure"></a>

Você pode usar uma política de rede do Kubernetes para restringir o tráfego de rede que entra e sai dos pods. Para obter mais informações, consulte [Políticas de rede](https://kubernetes.io/docs/concepts/services-networking/network-policies/) na documentação do Kubernetes.

É necessário fazer as seguintes configurações para usar esse atributo:

1. Configure aplicação de políticas na inicialização do pod. Você faz isso no contêiner `aws-node` do `DaemonSet` CNI da VPC.

1. Habilitar o parâmetro da política de redes para o complemento.

1. Configurar o cluster para usar as políticas de rede do Kubernetes

Antes de começar, reveja as considerações. Para obter mais informações, consulte [Considerações](cni-network-policy.md#cni-network-policy-considerations).

## Pré-requisitos
<a name="cni-network-policy-prereqs"></a>

A seguir estão os pré-requisitos do recurso:

### Versão mínima do cluster
<a name="cni-network-policy-minimum"></a>

Um cluster existente do Amazon EKS. Para implantar, consulte [Começar a usar o Amazon EKS](getting-started.md). O cluster dove estar executando uma das versões do Kubernetes e versões da plataforma listadas na tabela a seguir. Observe que qualquer versão da plataforma e do Kubernetes posterior às versões listadas também é compatível. Para verificar a versão atual do Kubernetes, substitua *my-cluster* no comando a seguir pelo nome do seu cluster e execute o comando modificado:

```
aws eks describe-cluster --name my-cluster --query cluster.version --output text
```


| Versão do Kubernetes | Versão da plataforma | 
| --- | --- | 
|   `1.27.4`   |   `eks.5`   | 
|   `1.26.7`   |   `eks.6`   | 

### Versão mínima do VPC CNI
<a name="cni-network-policy-minimum-vpc"></a>

Para criar tanto políticas de rede padrão do Kubernetes quanto políticas de rede de administrador, é necessário executar a versão `1.21` do plug-in CNI da VPC. É possível verificar qual é a sua versão atual com o comando a seguir.

```
kubectl describe daemonset aws-node --namespace kube-system | grep amazon-k8s-cni: | cut -d : -f 3
```

Se a versão for anterior à `1.21`, consulte [Atualização do plug-in da CNI da Amazon VPC (complemento do Amazon EKS)](vpc-add-on-update.md) para atualizar para a versão `1.21` ou superior.

### Versão mínima do kernel do Linux
<a name="cni-network-policy-minimum-linux"></a>

Os nós devem ter a versão `5.10` ou superior do kernel do Linux. Você pode verificar qual é a sua versão atual com `uname -r`. Se você usa as versões mais recentes do Amazon Linux otimizado para Amazon EKS, das AMIs do Amazon Linux otimizadas para Amazon EKS e as AMIs do Bottlerocket, elas já têm a versão do kernel exigida.

A AMI do Amazon Linux acelerada otimizada para Amazon EKS versão `v20231116` ou superior possui o kernel versão `5.10`.

## Etapa 1: configurar a aplicação de políticas na inicialização dos pods
<a name="cni-network-policy-configure-policy"></a>

O plug-in CNI da Amazon VPC para Kubernetes configura as políticas de rede para os pods em paralelo ao provisionamento de pods. Até que todas as políticas estejam configuradas para o novo pod, os contêineres no novo pod serão iniciados com uma *política de permissão padrão*. Isso é denominado *modo padrão*. Uma política de permissão padrão significa que todo o tráfego de entrada e de saída é permitido de e para os novos pods. Por exemplo, os pods não terão nenhuma regra de firewall aplicada (todo o tráfego é permitido) até que o novo pod seja atualizado com as políticas ativas.

Com a variável `NETWORK_POLICY_ENFORCING_MODE` definida como `strict`, os pods que usam o plug-in CNI da VPC são iniciados com uma *política de negação padrão* e, em seguida, as políticas são configuradas. Isso é denominado *modo estrito*. No modo estrito, você deve ter uma política de rede para cada endpoint que os pods precisam acessar no cluster. Observe que esse requisito se aplica aos pods do CoreDNS. A política de negação padrão não está configurada para pods com sistemas de redes de host.

É possível alterar a política de rede padrão ao definir a variável de ambiente `NETWORK_POLICY_ENFORCING_MODE` como `strict` no contêiner `aws-node` do `DaemonSet` do plug-in CNI da VPC.

```
env:
  - name: NETWORK_POLICY_ENFORCING_MODE
    value: "strict"
```

## Etapa 2: habilitar o parâmetro da política de redes do complemento
<a name="enable-network-policy-parameter"></a>

O recurso de política de rede usa a porta `8162` no nó para métricas por padrão. Além disso, o recurso usa a porta `8163` para a realização de sondagens de integridade. Se você executar outro aplicativo nos nós ou dentro dos pods que precisa usar essas portas, o aplicativo não será executado. Na versão `v1.14.1` ou em versões posteriores da CNI da VPC, é possível alterar essas portas.

Use o procedimento a seguir para habilitar o parâmetro da política de redes do complemento.

### Console de gerenciamento da AWS
<a name="cni-network-policy-console"></a>

1. Abra o [console do Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters).

1. No painel de navegação à esquerda, selecione **Clusters** e o nome do cluster para o qual você deseja configurar o complemento Amazon VPC CNI.

1. Escolha a guia **Add-ons** (Complementos).

1. Selecione a caixa no canto superior direito da caixa do complemento e depois escolha **Edit** (Editar).

1. Na página **Configurar `Amazon VPC CNI`**:

   1. Selecione a versão `v1.14.0-eksbuild.3` ou superior na lista **Versão**.

   1. Expanda **Definições de configuração opcionais**.

   1. Insira a chave JSON `"enableNetworkPolicy":` e o valor `"true"` em **Valores da configuração**. O texto resultante deve ser um objeto JSON válido. Se esse par de chave e valor for o único dado na caixa de texto, coloque-o entre colchetes `{ }`.

      O seguinte exemplo tem a funcionalidade de política de rede ativada e as métricas e investigações de integridade estão configuradas com os números de porta padrão:

      ```
      {
          "enableNetworkPolicy": "true",
          "nodeAgent": {
              "healthProbeBindAddr": "8163",
              "metricsBindAddr": "8162"
          }
      }
      ```

### Helm
<a name="cni-network-helm"></a>

Se você instalou o plug-in CNI da Amazon VPC para Kubernetes por meio do `helm`, você pode atualizar a configuração para alterar as portas.

1. Execute o seguinte comando para alterar as portas. Defina o número da porta no valor da chave `nodeAgent.metricsBindAddr` ou da chave `nodeAgent.healthProbeBindAddr`, respectivamente.

   ```
   helm upgrade --set nodeAgent.metricsBindAddr=8162 --set nodeAgent.healthProbeBindAddr=8163 aws-vpc-cni --namespace kube-system eks/aws-vpc-cni
   ```

### kubectl
<a name="cni-network-policy-kubectl"></a>

1. Abra o `aws-node` `DaemonSet` no editor.

   ```
   kubectl edit daemonset -n kube-system aws-node
   ```

1. Substitua os números da porta nos argumentos do comando a seguir no contêiner `args:` no manifesto do daemonset `aws-network-policy-agent` do CNI do `aws-node` VPC.

   ```
       - args:
               - --metrics-bind-addr=:8162
               - --health-probe-bind-addr=:8163
   ```

## Etapa 3: configurar o cluster para usar as políticas de rede do Kubernetes
<a name="cni-network-policy-setup"></a>

É possível configurar isso para um complemento do Amazon EKS ou autogerenciado.

### Complemento do Amazon EKS
<a name="cni-network-policy-setup-procedure-add-on"></a>

Usando a AWS CLI, você pode configurar o cluster para usar as políticas de rede do Kubernetes ao executar o comando a seguir. Substitua `my-cluster` pelo nome do cluster e o ARN do perfil do IAM pelo perfil que você está usando.

```
aws eks update-addon --cluster-name my-cluster --addon-name vpc-cni --addon-version v1.14.0-eksbuild.3 \
    --service-account-role-arn arn:aws:iam::123456789012:role/AmazonEKSVPCCNIRole \
    --resolve-conflicts PRESERVE --configuration-values '{"enableNetworkPolicy": "true"}'
```

Para definir essa configuração usando o Console de Gerenciamento da AWS, siga as etapas abaixo:

1. Abra o [console do Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters).

1. No painel de navegação à esquerda, selecione **Clusters** e o nome do cluster para o qual você deseja configurar o complemento Amazon VPC CNI.

1. Escolha a guia **Add-ons** (Complementos).

1. Selecione a caixa no canto superior direito da caixa do complemento e depois escolha **Edit** (Editar).

1. Na página **Configurar `Amazon VPC CNI`**:

   1. Selecione a versão `v1.14.0-eksbuild.3` ou superior na lista **Versão**.

   1. Expanda **Definições de configuração opcionais**.

   1. Insira a chave JSON `"enableNetworkPolicy":` e o valor `"true"` em **Valores da configuração**. O texto resultante deve ser um objeto JSON válido. Se esse par de chave e valor for o único dado na caixa de texto, coloque-o entre colchetes `{ }`. O exemplo apresentado a seguir mostra que a política de rede está habilitada:

      ```
      { "enableNetworkPolicy": "true" }
      ```

      A captura de tela a seguir mostra um exemplo desse cenário.  
![\[<shared id="consolelong"/> mostrando o complemento VPC CNI com política de rede na configuração opcional.\]](http://docs.aws.amazon.com/pt_br/eks/latest/userguide/images/console-cni-config-network-policy.png)

### Complemento autogerenciado
<a name="cni-network-policy-setup-procedure-self-managed-add-on"></a>

Se você instalou o plug-in CNI da Amazon VPC para Kubernetes por meio do `helm`, você pode atualizar a configuração para habilitar a política de rede.

1. Execute o comando a seguir para habilitar a política de rede.

   ```
   helm upgrade --set enableNetworkPolicy=true aws-vpc-cni --namespace kube-system eks/aws-vpc-cni
   ```

1. Abra o `amazon-vpc-cni` `ConfigMap` no editor.

   ```
   kubectl edit configmap -n kube-system amazon-vpc-cni -o yaml
   ```

1. Adicione a linha a seguir aos `data` no `ConfigMap`.

   ```
   enable-network-policy-controller: "true"
   ```

   Depois de adicionar a linha, o `ConfigMap` deverá ser semelhante ao exemplo a seguir.

   ```
   apiVersion: v1
    kind: ConfigMap
    metadata:
     name: amazon-vpc-cni
     namespace: kube-system
    data:
     enable-network-policy-controller: "true"
   ```

1. Abra o `aws-node` `DaemonSet` no editor.

   ```
   kubectl edit daemonset -n kube-system aws-node
   ```

   1. Substitua `false` por `true` no argumento do comando `--enable-network-policy=false` em `args:` no contêiner do `aws-network-policy-agent` no manifesto do daemonset do `aws-node` do VPC CNI.

      ```
           - args:
              - --enable-network-policy=true
      ```

## Etapa 4: Próximas etapas
<a name="cni-network-policy-setup-procedure-confirm"></a>

Depois de concluir a configuração, confirme se os pods `aws-node` estão sendo executados no cluster.

```
kubectl get pods -n kube-system | grep 'aws-node\|amazon'
```

Veja abaixo um exemplo de saída.

```
aws-node-gmqp7                                          2/2     Running   1 (24h ago)   24h
aws-node-prnsh                                          2/2     Running   1 (24h ago)   24h
```

Existem dois contêineres nos pods `aws-node` na versão `1.14` e posteriores. Nas versões anteriores e quando a política de rede está desabilitada, há apenas um único contêiner nos pods do `aws-node`.

Agora você pode implantar políticas de rede do Kubernetes no cluster.

Para implementar políticas de rede do Kubernetes, você pode criar objetos `NetworkPolicy` ou `ClusterNetworkPolicy` e implantá-los em seu cluster. Os objetos `NetworkPolicy` são restritos a um namespace, enquanto objetos `ClusterNetworkPolicy` podem abranger todo o cluster ou diversos namespaces. Você implementa políticas para permitir ou negar tráfego entre os pods com base em seletores de rótulos, namespaces e intervalos de endereços IP. Para obter mais informações sobre a criação de objetos de `NetworkPolicy`, consulte [Políticas de rede](https://kubernetes.io/docs/concepts/services-networking/network-policies/#networkpolicy-resource) na documentação do Kubernetes.

A aplicação dos objetos de `NetworkPolicy` do Kubernetes é implementada usando o Extended Berkeley Packet Filter (eBPF). Em relação a implementações baseadas em `iptables`, ele oferece menor latência e características de performance, incluindo menor utilização da CPU e prevenção de consultas sequenciais. Além disso, as sondas do eBPF fornecem acesso a dados contextuais ricos que ajudam a depurar problemas complexos no nível do kernel e a melhorar a observabilidade. O Amazon EKS é compatível com um exportador baseado no eBPF que aproveita as sondas para registrar em log os resultados da política em cada nó e exportar os dados para coletores de logs externos para auxiliar na depuração. Para obter mais informações, consulte a [documentação do eBPF](https://ebpf.io/what-is-ebpf/#what-is-ebpf).