**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.

# Controlar o tráfego de rede de um nó gerenciado usando kubectl e S3
<a name="auto-get-tcpdump"></a>

Saiba como controlar o tráfego de rede de um nó gerenciado do Amazon EKS que tem o agente de monitoramento de nós. O agente executa o tcpdump no nó, compacta os arquivos de captura e os carrega no seu bucket do S3.

## Pré-requisitos
<a name="_prerequisites"></a>

Certifique-se de ter o seguinte:
+ Um cluster existente do Amazon EKS Auto Mode com o agente de monitoramento de nós. Para obter mais informações, consulte [Detectar problemas de integridade dos nós e habilitar o reparo automático dos nós](node-health.md).
+ A ferramenta de linha de comandos da `kubectl` instalada e configurada para se comunicar com o cluster.
+ A AWS CLI instalada e conectada com permissões suficientes para criar buckets e objetos do S3.
+ Uma versão recente do Python 3 instalada
+ O AWS SDK para Python 3, Boto 3, instalado.
+ A biblioteca PyYAML instalada (`pip install pyyaml`).

## Etapa 1: criar um bucket de destino do S3 (opcional)
<a name="_step_1_create_s3_bucket_destination_optional"></a>

Caso ainda não tenha um bucket do S3 para controlar arquivos, crie um. Substitua {{bucket-name}} e {{region}} pelos seus valores.

```
aws s3api create-bucket --bucket {{<bucket-name>}} \
    --region {{<region>}} \
    --create-bucket-configuration LocationConstraint={{<region>}}
```

**nota**  
O parâmetro `--create-bucket-configuration` é obrigatório para todas as regiões, exceto `us-east-1`.

## Etapa 2: iniciar a captura de pacotes
<a name="_step_2_start_packet_capture"></a>

Use o script `start-capture.py` do [repositório do agente de monitoramento de nós](https://github.com/aws/eks-node-monitoring-agent) (`tools/start-capture.py`) para gerar credenciais S3 pré-assinadas, criar o recurso `NodeDiagnostic` e aplicá-lo ao seu cluster.

1. Identifique o nó do qual deseja coletar o tráfego.

   ```
   kubectl get nodes
   ```

1. Salve o script [start-capture.py](https://github.com/aws/eks-node-monitoring-agent/blob/main/tools/start-capture.py) do repositório do agente de monitoramento de nós em sua máquina local e execute-o. Substitua {{<bucket-name>}} e {{<node-name>}} por seus valores.

   ```
   python3 start-capture.py --bucket {{<bucket-name>}} --node {{<node-name>}}
   ```

   Opções comuns:

   ```
   # Capture for 5 minutes on eth0 with a filter
   python3 start-capture.py --bucket {{<bucket-name>}} --node {{<node-name>}} \
       --duration 5m --interface eth0 --filter "tcp port 443"
   
   # Preview the YAML without applying
   python3 start-capture.py --bucket {{<bucket-name>}} --node {{<node-name>}} --dry-run
   ```

   O script requer Python 3 com `boto3` e `pyyaml` instalados e `kubectl` configurado para seu cluster.

   O script gera um recurso `NodeDiagnostic` como o seguinte. Este exemplo é fornecido para referência; observe que os campos `upload` exigem credenciais S3 POST pré-assinadas que são geradas programaticamente pelo script.

   ```
   apiVersion: eks.amazonaws.com/v1alpha1
   kind: NodeDiagnostic
   metadata:
     name: {{<node-name>}}                    # Required: node instance ID
   spec:
     packetCapture:
       duration: "30s"                       # Required: capture duration (max 1h)
       # interface: "eth0"                   # Optional: default is primary ENI. Use "any" for all interfaces
       # filter: "tcp port 443"             # Optional: tcpdump filter expression
       # chunkSizeMB: 10                    # Optional: file rotation size in MB (1-100, default: 10)
       upload:                               # Required: pre-signed S3 POST credentials
         url: "https://{{<bucket>}}.s3.amazonaws.com/"
         fields:
           key: "captures/{{<node-name>}}/${filename}"
           # ... other pre-signed POST fields (generated by the script)
   ```

## Etapa 3: monitorar o andamento da captura
<a name="_step_3_monitor_capture_progress"></a>

Verifique o status da captura.

```
kubectl describe nodediagnostic {{<node-name>}}
```

O status mostrará:
+  `Running` enquanto a captura estiver em andamento.
+  `Completed` com o motivo `Success` quando a captura terminar e todos os arquivos forem carregados.
+  `Completed` com o motivo `Failure` se a captura encontrou erros.

Para ver o status completo, incluindo `captureID` (usado para identificação do caminho do S3):

```
kubectl get nodediagnostic {{<node-name>}} -o jsonpath='{.status.captureStatuses}'
```

## Etapa 4: faça download dos arquivos de captura do S3
<a name="_step_4_download_capture_files_from_s3"></a>

Quando o status exibir `Success`, faça download dos arquivos de captura do S3.

```
aws s3 cp s3://{{<bucket-name>}}/captures/ ./captures/ --recursive
```

Os arquivos estão no formato pcap compactado com gzip. Descompacte e analise com tcpdump ou Wireshark:

```
gunzip captures/*.gz
tcpdump -r captures/capture.pcap0000 -n
```

## Etapa 5: limpar
<a name="_step_5_clean_up"></a>

 Os recursos `NodeDiagnostic` não são excluídos automaticamente. Limpe depois de obter seus arquivos de captura. A exclusão do recurso enquanto uma captura está sendo executada a interromperá imediatamente.

```
kubectl delete nodediagnostic {{<node-name>}}
```

## Opções de configuração e comportamento
<a name="_configuration_options_and_behavior"></a>

Para obter a referência completa das especificações `packetCapture`, as opções de configuração e os detalhes do comportamento, consulte a [documentação de captura de pacotes](https://github.com/aws/eks-node-monitoring-agent/blob/main/docs/packet-capture.adoc) no repositório do atendente de monitoramento de nós.