# Como registrar tráfego IP em log com logs de fluxo da VPC
O VPC Flow Logs é um recurso que possibilita que você capture informações sobre o tráfego de IP para e proveniente de interfaces de rede da VPC. Os dados do log de fluxo podem ser publicados nos seguintes locais: Amazon CloudWatch Logs, Amazon S3 ou Amazon Data Firehose. O caminho de entrega configurado e as permissões que permitem que os logs de tráfego de rede sejam enviados para um destino como o CloudWatch Logs ou o S3 são chamados de *assinaturas*. Depois de criar um log de fluxo, você poderá recuperar e visualizar os registros do log de fluxo no grupo de logs, no bucket ou no fluxo de entrega configurado.
Os logs de fluxo podem ajudar em diversas tarefas, como:
+ Diagnosticar regras de grupo de segurança excessivamente restritivas
+ Monitorar o tráfego que chega à sua instância
+ Determinar a direção de entrada e saída do tráfego das interfaces de rede
Os dados do log de fluxo são coletados fora do caminho do tráfego de rede e, portanto, não afetam o throughput nem a latência da rede. É possível criar ou excluir logs de fluxo sem qualquer risco de impacto na performance da rede.
**nota**
Esta seção trata apenas dos logs de fluxo para VPCs. Para obter informações sobre os logs de fluxo para gateways de trânsito lançados na versão 6, consulte [Logging network traffic using Transit Gateway Flow Logs](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-flow-logs.html) no *Guia do usuário do Amazon VPC Transit Gateways*.
**Topics**
+ [Noções básicas de logs de fluxo](flow-logs-basics.md)
+ [Registros de log de fluxo](flow-log-records.md)
+ [Exemplos de registro de log de fluxo](flow-logs-records-examples.md)
+ [Limitações do log de fluxo](flow-logs-limitations.md)
+ [Preços](#flow-logs-pricing)
+ [Trabalhar com logs de fluxo](working-with-flow-logs.md)
+ [Publicar logs de fluxo no CloudWatch Logs](flow-logs-cwl.md)
+ [Publicar logs de fluxo no Amazon S3](flow-logs-s3.md)
+ [Publicar logs de fluxo no Amazon Data Firehose](flow-logs-firehose.md)
+ [Consultar logs de fluxo usando o Amazon Athena](flow-logs-athena.md)
+ [Solucionar problemas do VPC Flow Logs](flow-logs-troubleshooting.md)
# Noções básicas de logs de fluxo
É possível criar um log de fluxo para VPC, sub-rede ou interface de rede. Se você criar um log de fluxo para uma sub-rede ou VPC, toda interface de rede na sub-rede ou VPC será monitorada.
Os dados de log de fluxo para uma interface de rede monitorada são registrados como *registros de log de fluxo*, que são eventos de log que consistem em campos que descrevem o fluxo de tráfego. Para obter mais informações, consulte [Registros de log de fluxo](flow-log-records.md).
Para criar um log de fluxo, especifique:
+ O recurso para o qual criar o log de fluxo
+ O tipo de tráfego a ser capturado (tráfego aceito, tráfego rejeitado ou todo o tráfego)
+ Os destinos em que você quer publicar os dados de log de fluxo
No exemplo a seguir, crie um log de fluxo que capture o tráfego aceito para a interface de rede de uma das instâncias do EC2 em uma sub-rede privada e publica os registros de log de fluxo em um bucket do Amazon S3.
![\[Logs de fluxo de uma instância\]](http://docs.aws.amazon.com/pt_br/vpc/latest/userguide/images/flow-logs-diagram-s3.png)
No seguinte exemplo, um log de fluxo captura todo o tráfego para a sub-rede e publica os registros do log de fluxo no Amazon CloudWatch Logs. O log de fluxo captura o tráfego para todas as interfaces de rede na sub-rede.
![\[Logs de fluxo para uma sub-rede\]](http://docs.aws.amazon.com/pt_br/vpc/latest/userguide/images/flow-logs-diagram-cw.png)
Depois que você criar um log de fluxo, pode demorar alguns minutos para começar a coletar e publicar dados nos destinos selecionados. Os logs de fluxo não capturam streams de logs em tempo real para suas interfaces de rede. Para obter mais informações, consulte [2. Criar um log de fluxo](working-with-flow-logs.md#create-flow-log).
Se você iniciar uma instância na sua sub-rede depois de criar um log de fluxo para a sua sub-rede ou VPC, criaremos um fluxo de logs (para o CloudWatch Logs) ou objeto de arquivo de log (para o Amazon S3) para a nova interface de rede assim que houver tráfego de rede para a interface de rede.
Você pode criar logs de fluxo para interfaces de rede que são criadas por outros serviços da AWS, como:
+ Elastic Load Balancing
+ Amazon RDS
+ Amazon ElastiCache
+ Amazon Redshift
+ Amazon WorkSpaces
+ Gateways NAT
+ Gateways de trânsito
Independentemente do tipo de interface de rede, é necessário usar o console ou a API do Amazon EC2 para criar um log de fluxo para uma interface de rede.
É possível aplicar tags aos logs de fluxo. Cada tag consiste de uma chave e um valor opcional, que podem ser definidos. As tags podem ajudar você a organizar seus logs de fluxo. Por exemplo, por finalidade ou proprietário.
Caso não precise mais de um log de fluxo, é possível excluí-lo. A exclusão de um log de fluxo desabilita o serviço de log de fluxo para o recurso, de modo que novos registros de log de fluxo não são criados nem publicados. A exclusão de um log de fluxo não exclui qualquer dado existente do log de fluxo. Depois de excluir um log de fluxo, você pode excluir os dados do log de fluxo diretamente do destino quando terminar de usá-lo. Para obter mais informações, consulte [4. Excluir um log de fluxo](working-with-flow-logs.md#delete-flow-log).
# Registros de log de fluxo
Um registro de log de fluxo representa um fluxo de rede na VPC. Por padrão, cada registro captura um fluxo de tráfego de protocolo de Internet (IP) da rede (caracterizado por 5 tuplas em uma base de interface de rede) que ocorre dentro de um *intervalo de agregação*, também referido como uma *janela de captura*.
Cada registro é uma string com campos separados por espaços. Um registro inclui valores para os diferentes componentes do fluxo IP como, por exemplo, a origem, o destino e o protocolo.
Ao criar um log de fluxo, é possível usar o formato padrão do registro de log de fluxo ou especificar um formato personalizado.
**Topics**
+ [Intervalo de agregação](#flow-logs-aggregration-interval)
+ [Formato padrão](#flow-logs-default)
+ [Formato personalizado](#flow-logs-custom)
+ [Campos disponíveis](#flow-logs-fields)
## Intervalo de agregação
O intervalo de agregação é o período durante o qual um fluxo específico é capturado e agregado em um registro de log de fluxo. Por padrão, o intervalo de agregação máximo é de dez minutos. Ao criar um log de fluxo, você pode especificar um intervalo de agregação máximo de 1 minuto, opcionalmente. Os logs de fluxo com um intervalo de agregação máximo de 1 minuto geram um volume mais alto de registros de log de fluxo que os logs de fluxo com um intervalo de agregação máximo de 10 minutos.
Quando uma interface de rede é anexada a uma [instância baseada em Nitro](https://docs.aws.amazon.com/ec2/latest/instancetypes/ec2-nitro-instances.html), o intervalo de agregação é sempre 1 minuto ou menos, independentemente do intervalo de agregação máximo especificado.
Depois que os dados forem capturados em um intervalo de agregação, será necessário tempo adicional para processar e publicar os dados no CloudWatch Logs e no Amazon S3. O serviço de log de fluxo geralmente fornece logs para o CloudWatch Logs em cerca de 5 minutos e para o Amazon S3 em cerca de 10 minutos. No entanto, a entrega de logs baseia-se no melhor esforço, e seus registros podem ser atrasados além do tempo de entrega típico.
## Formato padrão
Com o formato padrão, os registros de log de fluxo incluem os campos da versão 2, na ordem mostrada na tabela de [campos disponíveis](#flow-logs-fields). Não é possível personalizar ou alterar o formato padrão. Para capturar campos adicionais disponíveis ou um subconjunto de campos diferente, especifique um formato personalizado em vez disso.
## Formato personalizado
Com um formato personalizado, você especifica quais campos estão incluídos nos registros de log de fluxo e em qual ordem. Isso permite que você crie logs de fluxo específicos para suas necessidades e omita campos que não são relevantes. Usar um formato personalizado pode diminuir a necessidade de processos separados para extrair informações específicas dos logs de fluxo publicados. É possível especificar qualquer quantidade de campos disponíveis do log de fluxo, mas deve-se especificar pelo menos um.
## Campos disponíveis
A tabela a seguir descreve todos os campos disponíveis para um registro de log de fluxo. A coluna **Versão** indica a versão do VPC Flow Logs na qual o campo foi introduzido. O formato padrão inclui todos os campos da versão 2, na mesma ordem em que aparecem na tabela.
Ao publicar dados de log de fluxo no Amazon S3, o tipo de dados para os campos dependerá do formato do log de fluxo. Se o formato estiver como texto sem formatação, todos os campos serão do tipo STRING. Se o formato for Parquet, consulte a tabela para os tipos de dados de campo.
Se um campo não for aplicável ou não puder ser computado para um registro específico, o registro exibirá o símbolo '-' para essa entrada. Os campos de metadados que não vêm diretamente do cabeçalho do pacote são aproximações e seus valores podem estar ausentes ou imprecisos.
| Campo | Descrição | Versão |
| --- | --- | --- |
| version | A versão dos logs de fluxo da VPC. Se você usar o formato padrão, a versão será 2. Se você usar um formato personalizado, a versão será a versão mais alta entre os campos especificados. Por exemplo, se você especificar apenas os campos da versão 2, a versão será 2. Se você especificar uma mistura de campos das versões 2, 3 e 4, a versão será 4. **Tipo de dados em Parquet:** INT\$132 | 2 |
| account-id | O ID da conta da AWS do proprietário da interface de rede de origem para a qual o tráfego é registrado. Se a interface de rede for criada por um serviço da AWS, por exemplo, ao criar um endpoint da VPC ou Network Load Balancer, o registro poderá exibir unknown para esse campo. **Tipo de dados em Parquet:** STRING | 2 |
| interface-id | O ID da interface de rede para a qual o tráfego é registrado. Retorna um símbolo “-” para fluxos associados a um gateway NAT regional. **Tipo de dados em Parquet:** STRING | 2 |
| srcaddr | No caso do tráfego de entrada, este é o endereço IP da origem do tráfego. No caso do tráfego de saída, este é o endereço IPv4 privado ou o endereço IPv6 da interface de rede que envia o tráfego. Para tráfego de saída do gateway NAT regional, é o mesmo endereço IP de origem em nível de pacote que em pkt-srcaddr. Consulte também pkt-srcaddr. **Tipo de dados em Parquet:** STRING | 2 |
| dstaddr | O endereço de destino do tráfego de saída ou o endereço IPv4 ou IPv6 da interface de rede do tráfego de entrada na interface de rede. O endereço IPv4 da interface de rede sempre é o respectivo endereço IPv4 privado. Para tráfego de entrada para o gateway NAT regional, é o mesmo endereço IP de destino em nível de pacote que em pkt-dstaddr. Consulte também pkt-dstaddr. **Tipo de dados em Parquet:** STRING | 2 |
| srcport | A porta de origem do tráfego. **Tipo de dados em Parquet:** INT\$132 | 2 |
| dstport | A porta de destino do tráfego. **Tipo de dados em Parquet:** INT\$132 | 2 |
| protocol | O número do protocolo IANA do tráfego. Para obter mais informações, consulte [Números de Protocolo da Internet Designados](http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml). **Tipo de dados em Parquet:** INT\$132 | 2 |
| packets | O número de pacotes transferidos durante o fluxo. **Tipo de dados em Parquet:** INT\$164 | 2 |
| bytes | O número de bytes transferidos durante o fluxo. **Tipo de dados em Parquet:** INT\$164 | 2 |
| start | O tempo, em segundos Unix, quando o primeiro pacote de fluxo foi recebido no intervalo de agregação. Isso pode ocorrer até 60 segundos após o pacote ter sido transmitido ou recebido na interface de rede **Tipo de dados em Parquet:** INT\$164 | 2 |
| end | O tempo, em segundos Unix, quando o último pacote de fluxo foi recebido dentro do intervalo de agregação. Isso pode ocorrer até 60 segundos após o pacote ter sido transmitido ou recebido na interface de rede **Tipo de dados em Parquet:** INT\$164 | 2 |
| action | A ação associada ao tráfego: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/vpc/latest/userguide/flow-log-records.html) **Tipo de dados em Parquet:** STRING | 2 |
| log-status | O status de registro do log de fluxo: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/vpc/latest/userguide/flow-log-records.html) **Tipo de dados em Parquet:** STRING | 2 |
| vpc-id | O ID da VPC que contém a interface de rede para a qual o tráfego é registrado. **Tipo de dados em Parquet:** STRING | 3 |
| subnet-id | O ID da sub-rede que contém a interface de rede para a qual o tráfego é registrado. Retorna um símbolo “-” para fluxos associados ao gateway NAT regional. **Tipo de dados em Parquet:** STRING | 3 |
| instance-id | O ID da instância associada à interface de rede para a qual o tráfego é registrado, caso a instância seja de sua propriedade. Retorna um símbolo “-” para uma [interface de rede gerenciada pelo solicitante](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/requester-managed-eni.html); por exemplo, a interface de rede de um gateway NAT. **Tipo de dados em Parquet:** STRING | 3 |
| tcp-flags | O valor da máscara de bits para os seguintes sinalizadores TCP:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/vpc/latest/userguide/flow-log-records.html)Se nenhum sinalizador compatível for registrado, o valor do sinalizador TCP será 0. Por exemplo, no caso de sinalizadores como ACK ou PSH, que não são suportados pelo registro de tcp-flags, o resultado para registros de tráfego contendo esses sinalizadores não suportados será 0 para tcp-flags. Entretanto, se um sinalizador não suportado estiver acompanhado por um sinalizador suportado, o valor do sinalizador suportado será informado. Por exemplo, se o ACK fizer parte do SYN-ACK, o relatório indicará o valor 18. Se houver um registro como SYN\$1ECE, onde SYN é um sinalizador suportado e ECE não é, o valor do sinalizador TCP será 2. O valor “-” será atribuído para casos nos quais a combinação de sinalizadores seja inválida e não seja possível calcular o valor. Se nenhum sinalizador for enviado, o valor do sinalizador TCP será 0.Os sinalizadores TCP podem ser processados com o operador OR durante o intervalo de agregação. Para conexões curtas, os sinalizadores podem ser definidos na mesma linha no registro de log de fluxo, por exemplo, 19 para SYN-ACK e FIN, e 3 para SYN e FIN. Para ver um exemplo, consulte [Sequência de sinalizadores TCP](flow-logs-records-examples.md#flow-log-example-tcp-flag).Para obter informações gerais sobre sinalizadores TCP (por exemplo, o significado de sinalizadores FIN, SYN e ACK), consulte [Estrutura de segmentos TCP](https://en.wikipedia.org/wiki/Transmission_Control_Protocol#TCP_segment_structure), na Wikipédia.**Tipo de dados em Parquet:** INT\$132 | 3 |
| type | O tipo de tráfego. Os valores possíveis são: IPv4 \$1 IPv6 \$1 EFA. Para obter mais informações, consulte [ Elastic Fabric Adapter](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html). **Tipo de dados em Parquet:** STRING | 3 |
| pkt-srcaddr | O endereço IP de origem (original) no nível do pacote do tráfego. Use esse campo com o campo srcaddr para diferenciar o endereço IP de uma camada intermediária pela qual o tráfego flui e o endereço IP de origem original do tráfego. Por exemplo, quando o tráfego flui por [uma interface de rede para um gateway NAT](flow-logs-records-examples.md#flow-log-example-nat) ou quando o endereço IP de um pod no Amazon EKS é diferente do endereço IP da interface de rede do nó da instância em que o dispositivo está em execução (para comunicação dentro de uma VPC). **Tipo de dados em Parquet:** STRING | 3 |
| pkt-dstaddr | O endereço IP de destino (original) no nível do pacote do tráfego. Use esse campo com o campo dstaddr para diferenciar o endereço IP de uma camada intermediária pela qual o tráfego flui e o endereço IP de destino final do tráfego. Por exemplo, quando o tráfego flui por [uma interface de rede para um gateway NAT](flow-logs-records-examples.md#flow-log-example-nat) ou quando o endereço IP de um pod no Amazon EKS é diferente do endereço IP da interface de rede do nó da instância em que o dispositivo está em execução (para comunicação dentro de uma VPC). **Tipo de dados em Parquet:** STRING | 3 |
| region | A região que contém a interface de rede para a qual o tráfego é registrado. **Tipo de dados em Parquet:** STRING | 4 |
| az-id | O ID da zona de disponibilidade que contém a interface de rede para a qual o tráfego é registrado. Se o tráfego for de uma sublocalização, o registro exibirá um símbolo '-' para este campo. **Tipo de dados em Parquet:** STRING | 4 |
| sublocation-type | O tipo de sublocalização que é retornado no campo sublocation-id. Os valores possíveis são: [wavelength](https://aws.amazon.com/wavelength/) \$1 [outpost](https://docs.aws.amazon.com/outposts/latest/userguide/) \$1 [localzone](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#concepts-local-zones) . Se o tráfego não for de uma sublocalização, o registro exibirá um símbolo '-' para este campo. **Tipo de dados em Parquet:** STRING | 4 |
| sublocation-id | O ID da sublocalização que contém a interface de rede para a qual o tráfego é registrado. Se o tráfego não for de uma sublocalização, o registro exibirá um símbolo '-' para este campo. **Tipo de dados em Parquet:** STRING | 4 |
| pkt-src-aws-service | O nome do subconjunto de [intervalos de endereços IP](aws-ip-ranges.md) para o campo pkt-srcaddr, se o endereço IP de origem for para um serviço da AWS. Se o endereço IP de origem pertencer a um [intervalo sobreposto](aws-ip-syntax.md#aws-ip-range-overlaps), pkt-src-aws-service mostrará somente um dos códigos de serviço da AWS. Os valores possíveis são: `AMAZON` \$1 `AMAZON_APPFLOW` \$1 `AMAZON_CONNECT` \$1 `API_GATEWAY` \$1 `AURORA_DSQL` \$1 `CHIME_MEETINGS` \$1 `CHIME_VOICECONNECTOR` \$1 `CLOUD9` \$1 `CLOUDFRONT` \$1 `CLOUDFRONT_ORIGIN_FACING` \$1 `CODEBUILD` \$1 `DYNAMODB` \$1 `EBS` \$1 `EC2` \$1 `EC2_INSTANCE_CONNECT` \$1 `GLOBALACCELERATOR` \$1 `IVS_LOW_LATENCY` \$1 `IVS_REALTIME` \$1 `KINESIS_VIDEO_STREAMS` \$1 `MEDIA_PACKAGE_V2` \$1 `ROUTE53` \$1 `ROUTE53_HEALTHCHECKS` \$1 `ROUTE53_HEALTHCHECKS_PUBLISHING` \$1 `ROUTE53_RESOLVER` \$1 `S3` \$1 `WORKSPACES_GATEWAYS`. **Tipo de dados em Parquet:** STRING | 5 |
| pkt-dst-aws-service | O nome do subconjunto de intervalos de endereços IP para o campo pkt-dstaddr, se o endereço IP de destino for para um serviço da AWS. Para uma lista de valores possíveis, consulte o campo pkt-src-aws-service. **Tipo de dados em Parquet:** STRING | 5 |
| flow-direction | O sentido do fluxo em relação à interface onde o tráfego é capturado. Os valores possíveis são: ingress \$1 egress. **Tipo de dados em Parquet:** STRING | 5 |
| traffic-path | O trajeto que o tráfego de saída leva ao destino. Para determinar se o tráfego é de saída, verifique o campo flow-direction. Os valores possíveis são conforme o seguintes. Se nenhum dos valores se aplicar, o campo será definido como -. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/vpc/latest/userguide/flow-log-records.html) **Tipo de dados em Parquet:** INT\$132 | 5 |
| ecs-cluster-arn | Nome do recurso da AWS (ARN) do cluster do ECS se o tráfego for proveniente de uma tarefa do ECS em execução. Para incluir esse campo na sua assinatura, você vai precisar de permissão para chamar ecs:ListClusters.Tipo de dados em Parquet: STRING | 7 |
| ecs-cluster-name | Nome do cluster do ECS se o tráfego for proveniente de uma tarefa do ECS em execução. Para incluir esse campo na sua assinatura, você vai precisar de permissão para chamar ecs:ListClusters.Tipo de dados em Parquet: STRING | 7 |
| ecs-container-instance-arn | ARN da instância de contêiner do ECS se o tráfego for proveniente de uma tarefa do ECS em execução em uma instância do EC2. Se o provedor de capacidade for AWS Fargate, esse campo será “-”. Para incluir esse campo na sua assinatura, você vai precisar de permissão para chamar ecs:ListClusters e ecs:ListContainerInstances. Tipo de dados em Parquet: STRING | 7 |
| ecs-container-instance-id | ID da instância de contêiner do ECS se o tráfego for proveniente de uma tarefa do ECS em execução em uma instância do EC2. Se o provedor de capacidade for AWS Fargate, esse campo será “-”. Para incluir esse campo na sua assinatura, você vai precisar de permissão para chamar ecs:ListClusters e ecs:ListContainerInstances. Tipo de dados em Parquet: STRING | 7 |
| ecs-container-id | ID de runtime do Docker do contêiner se o tráfego for de uma tarefa do ECS em execução. Se houver um ou mais contêineres na tarefa do ECS, esse será o ID de runtime do Docker do primeiro contêiner. Para incluir esse campo na sua assinatura, você vai precisar de permissão para chamar ecs:ListClusters. Tipo de dados em Parquet: STRING | 7 |
| ecs-second-container-id | ID de runtime do Docker do contêiner se o tráfego for de uma tarefa do ECS em execução. Se houver mais de um contêiner na tarefa do ECS, esse será o ID de runtime do Docker do segundo contêiner. Para incluir esse campo na sua assinatura, você vai precisar de permissão para chamar ecs:ListClusters. Tipo de dados em Parquet: STRING | 7 |
| ecs-service-name | Nome do serviço do ECS se o tráfego for proveniente de uma tarefa do ECS em execução e a tarefa do ECS for iniciada por um serviço do ECS. Se a tarefa do ECS não for iniciada por um serviço do ECS, esse campo será “-”. Para incluir esse campo na sua assinatura, você vai precisar de permissão para chamar ecs:ListClusters e ecs:ListServices. Tipo de dados em Parquet: STRING | 7 |
| ecs-task-definition-arn | O ARN da definição da tarefa do ECS se o tráfego for proveniente de uma tarefa do ECS em execução. Para incluir esse campo na sua assinatura, você vai precisar de permissão para chamar ecs:ListClusters e ecs:ListTaskDefinitions. Tipo de dados em Parquet: STRING | 7 |
| ecs-task-arn | O ARN da tarefa do ECS se o tráfego for proveniente de uma tarefa do ECS em execução. Para incluir esse campo na sua assinatura, você vai precisar de permissão para chamar ecs:ListClusters e ecs:ListTasks. Tipo de dados em Parquet: STRING | 7 |
| ecs-task-id | O ID da tarefa do ECS se o tráfego for proveniente de uma tarefa do ECS em execução. Para incluir esse campo na sua assinatura, você vai precisar de permissão para chamar ecs:ListClusters e ecs:ListTasks. Tipo de dados em Parquet: STRING | 7 |
| rejeit-reason | Motivo da rejeição do tráfego. Valores possíveis: BPA, EC. Retorna um '-' para qualquer outro motivo de rejeição. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/vpc/latest/userguide/flow-log-records.html) **Tipo de dados em Parquet:** STRING | 8 |
| resource-id | O ID do gateway NAT regional que contém a interface de rede para a qual o tráfego é registrado. Retorna um símbolo “-” para fluxos de tráfego não associados a um gateway NAT regional. Para mais informações sobre gateways NAT regionais, consulte [Gateways NAT regionais para expansão multi-AZ automática](nat-gateways-regional.md). **Tipo de dados em Parquet:** STRING | 9 |
| encryption-status | O status da criptografia do fluxo. Para obter mais informações sobre os controles de criptografia da VPC, consulte [Aplicar a criptografia de VPC em trânsito](vpc-encryption-controls.md). Os valores possíveis são: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/vpc/latest/userguide/flow-log-records.html) O valor será “-” se os controles de criptografia da VPC não estiverem habilitados ou se o FlowLog não conseguir obter o status. \$1 Para endpoints de interface e gateway, a AWS não examina os dados do pacote para determinar o status da criptografia; em vez disso, confiamos na porta usada para assumir o status da criptografia. \$1\$1 Para endpoints especificados, gerenciados pela AWS, a AWS determina o status da criptografia com base no requisito de TLS na configuração do serviço. **Tipo de dados em Parquet:** INT\$132 | 10 |
# Exemplos de registro de log de fluxo
Os exemplos a seguir mostram registros de log de fluxo que capturam fluxos de tráfego específicos.
Para obter informações sobre o formato de registro de log de fluxo, consulte [Registros de log de fluxo](flow-log-records.md). Para obter informações sobre como criar logs de fluxo, consulte [Trabalhar com logs de fluxo](working-with-flow-logs.md).
**Topics**
+ [Tráfego aceito e rejeitado](#flow-log-example-accepted-rejected)
+ [Sem dados e registros ignorados](#flow-log-example-no-data)
+ [Regras de grupo de segurança e ACL de rede](#flow-log-example-security-groups)
+ [Tráfego IPv6](#flow-log-example-ipv6)
+ [Sequência de sinalizadores TCP](#flow-log-example-tcp-flag)
+ [Tráfego por um gateway NAT de zona](#flow-log-example-nat)
+ [Tráfego por meio de um gateway NAT regional](#flow-log-example-regional-nat)
+ [Tráfego por meio de um gateway de trânsito](#flow-log-example-tgw)
+ [Nome do serviço, caminho de tráfego e direção do fluxo](#flow-log-example-traffic-path)
## Tráfego aceito e rejeitado
Veja a seguir exemplos de registros de log de fluxo padrão.
Neste exemplo, o tráfego SSH (porta de destino 22, protocolo TCP) do endereço IP 172.31.16.139 para a interface de rede com endereço IP privado é 172.31.16.21 e o ID eni-1235b8ca123456789 na conta 123456789010 foi permitido.
```
2 123456789010 eni-1235b8ca123456789 172.31.16.139 172.31.16.21 20641 22 6 20 4249 1418530010 1418530070 ACCEPT OK
```
Neste exemplo, o tráfego RDP (porta de destino 3389, protocolo TCP) para a interface de rede eni-1235b8ca123456789 na conta 123456789010 foi rejeitado.
```
2 123456789010 eni-1235b8ca123456789 172.31.9.69 172.31.9.12 49761 3389 6 20 4249 1418530010 1418530070 REJECT OK
```
## Sem dados e registros ignorados
Veja a seguir exemplos de registros de log de fluxo padrão.
Neste exemplo, nenhum dado foi registrado durante o intervalo de agregação.
```
2 123456789010 eni-1235b8ca123456789 - - - - - - - 1431280876 1431280934 - NODATA
```
Os logs de fluxo da VPC ignoram registros que não conseguem capturar dados de logs de fluxo durante um intervalo de agregação porque excedem a capacidade interna. Um único registro ignorado pode representar vários fluxos que não foram capturados para a interface de rede durante o intervalo de agregação.
```
2 123456789010 eni-11111111aaaaaaaaa - - - - - - - 1431280876 1431280934 - SKIPDATA
```
**nota**
Alguns registros de log de fluxo podem ser ignorados durante o intervalo de agregação (consulte *log-status* em [Campos disponíveis](flow-log-records.md#flow-logs-fields)). Isso pode ocorrer em virtude de uma restrição de capacidade interna da AWS ou de um erro interno. Se você estiver usando o AWS Cost Explorer para visualizar as cobranças dos logs de fluxo da VPC e alguns logs de fluxo forem ignorados durante o intervalo de agregação de logs de fluxo, o número de logs de fluxo relatados AWS Cost Explorer será maior do que o número de logs de fluxo publicados pela Amazon VPC.
## Regras de grupo de segurança e ACL de rede
Se você estiver usando logs de fluxo para diagnosticar regras de grupo de segurança ou regras de ACL de rede exageradamente restritivas ou permissivas, fique atento ao estado desses recursos. Os grupos de segurança são com estado. Isso significa que as respostas ao tráfego permitido são também permitidas, mesmo que as regras em seu grupo de segurança não permitam isso. Inversamente, as ACLs de rede são stateless e, portanto, as respostas ao tráfego permitido estão sujeitas a regras de ACL de rede.
Por exemplo, você usa o comando **ping** em seu computador doméstico (o endereço IP é 203.0.113.12) para a sua instância (o endereço IP privado da interface de rede é 172.31.16.139). As regras de entrada do grupo de segurança permitem tráfego ICMP, mas as regras de saída não permitem tráfego ICMP. Como os grupos de segurança são com estado, o ping de resposta da sua instância é permitido. Sua ACL de rede permite tráfego ICMP de entrada, mas não permite tráfego ICMP de saída. Como as ACLs de rede são stateless, o ping de resposta é interrompido e não chega ao seu computador doméstico. Em um log de fluxo padrão, isso é exibido como dois registros de log de fluxo:
+ Um registro ACCEPT para o ping originário foi permitido tanto pela ACL de rede quanto pelo grupo de segurança e, por isso, obteve permissão para acessar sua instância.
+ Um registro REJECT para o ping de resposta que a ACL de rede negou.
```
2 123456789010 eni-1235b8ca123456789 203.0.113.12 172.31.16.139 0 0 1 4 336 1432917027 1432917142 ACCEPT OK
```
```
2 123456789010 eni-1235b8ca123456789 172.31.16.139 203.0.113.12 0 0 1 4 336 1432917094 1432917142 REJECT OK
```
Se sua ACL de rede permitir tráfego ICMP de saída, o log de fluxo exibirá dois registros ACCEPT (um para o ping originário e outro para o ping de resposta). Se seu grupo de segurança negar tráfego ICMP de entrada, o log de fluxo exibirá um único registro REJECT, porque o tráfego não recebeu permissão para acessar sua instância.
## Tráfego IPv6
Veja a seguir um exemplo de um registro de log de fluxo padrão. No exemplo, o tráfego SSH (porta 22) do endereço IPv6 2001:db8:1234:a100:8d6e:3477:df66:f105 para a interface de rede eni-1235b8ca123456789 na conta 123456789010 foi permitido.
```
2 123456789010 eni-1235b8ca123456789 2001:db8:1234:a100:8d6e:3477:df66:f105 2001:db8:1234:a102:3304:8879:34cf:4071 34892 22 6 54 8855 1477913708 1477913820 ACCEPT OK
```
## Sequência de sinalizadores TCP
Esta seção inclui exemplos de logs de fluxo personalizados que capturam os campos a seguir, na ordem abaixo.
```
version vpc-id subnet-id instance-id interface-id account-id type srcaddr dstaddr srcport dstport pkt-srcaddr pkt-dstaddr protocol bytes packets start end action tcp-flags log-status
```
O campo tcp-flags nos exemplos desta seção é representado pelo penúltimo valor no log de fluxo. Sinalizadores TCP podem ajudar você a identificar a direção do tráfego como, por exemplo, qual servidor iniciou a conexão.
**nota**
Para saber mais sobre a opção tcp-flags e obter uma explicação de cada um dos sinalizadores TCP, consulte [Campos disponíveis](flow-log-records.md#flow-logs-fields).
Nos registros a seguir (que começam às 19:47:55 e terminam às 19:48:53), as duas conexões foram iniciadas por um cliente em um servidor em execução na porta 5001. Dois sinalizadores SYN (2) foram recebidos pelo servidor do cliente de portas de origem diferentes no cliente (43416 e 43418). Para cada SYN, um SYN-ACK foi enviado do servidor para o cliente (18) na porta correspondente.
```
3 vpc-abcdefab012345678 subnet-aaaaaaaa012345678 i-01234567890123456 eni-1235b8ca123456789 123456789010 IPv4 52.213.180.42 10.0.0.62 43416 5001 52.213.180.42 10.0.0.62 6 568 8 1566848875 1566848933 ACCEPT 2 OK
3 vpc-abcdefab012345678 subnet-aaaaaaaa012345678 i-01234567890123456 eni-1235b8ca123456789 123456789010 IPv4 10.0.0.62 52.213.180.42 5001 43416 10.0.0.62 52.213.180.42 6 376 7 1566848875 1566848933 ACCEPT 18 OK
3 vpc-abcdefab012345678 subnet-aaaaaaaa012345678 i-01234567890123456 eni-1235b8ca123456789 123456789010 IPv4 52.213.180.42 10.0.0.62 43418 5001 52.213.180.42 10.0.0.62 6 100701 70 1566848875 1566848933 ACCEPT 2 OK
3 vpc-abcdefab012345678 subnet-aaaaaaaa012345678 i-01234567890123456 eni-1235b8ca123456789 123456789010 IPv4 10.0.0.62 52.213.180.42 5001 43418 10.0.0.62 52.213.180.42 6 632 12 1566848875 1566848933 ACCEPT 18 OK
```
No segundo intervalo de agregação, uma das conexões que foi estabelecida durante o fluxo anterior agora está fechada. O servidor enviou um sinalizador FIN (1) para o cliente para a conexão na porta 43418. O cliente respondeu com um FIN para o servidor na porta 43418.
```
3 vpc-abcdefab012345678 subnet-aaaaaaaa012345678 i-01234567890123456 eni-1235b8ca123456789 123456789010 IPv4 10.0.0.62 52.213.180.42 5001 43418 10.0.0.62 52.213.180.42 6 63388 1219 1566848933 1566849113 ACCEPT 1 OK
3 vpc-abcdefab012345678 subnet-aaaaaaaa012345678 i-01234567890123456 eni-1235b8ca123456789 123456789010 IPv4 52.213.180.42 10.0.0.62 43418 5001 52.213.180.42 10.0.0.62 6 23294588 15774 1566848933 1566849113 ACCEPT 1 OK
```
Para conexões curtas (por exemplo, alguns segundos) que são abertas e fechadas em um único intervalo de agregação, os sinalizadores podem ser definidos na mesma linha no registro de log do fluxo de tráfego na mesma direção. No exemplo a seguir, a conexão é estabelecida e finalizada no mesmo intervalo de agregação. Na primeira linha, o valor do sinalizador TCP é 3, que indica o envio de um SYN e de uma mensagem FIN do cliente para o servidor. Na segunda linha, o valor do sinalizador TCP é 19, que indica o envio de um SYN-ACK e de uma mensagem FIN do servidor para o cliente.
```
3 vpc-abcdefab012345678 subnet-aaaaaaaa012345678 i-01234567890123456 eni-1235b8ca123456789 123456789010 IPv4 52.213.180.42 10.0.0.62 43638 5001 52.213.180.42 10.0.0.62 6 1260 17 1566933133 1566933193 ACCEPT 3 OK
3 vpc-abcdefab012345678 subnet-aaaaaaaa012345678 i-01234567890123456 eni-1235b8ca123456789 123456789010 IPv4 10.0.0.62 52.213.180.42 5001 43638 10.0.0.62 52.213.180.42 6 967 14 1566933133 1566933193 ACCEPT 19 OK
```
## Tráfego por um gateway NAT de zona
Nesse exemplo, uma instância em uma sub-rede privada acessa a internet por meio de um gateway NAT de zona que está em uma sub-rede pública.
![\[Acesso à internet por meio de um gateway NAT de zona\]](http://docs.aws.amazon.com/pt_br/vpc/latest/userguide/images/flow-log-nat-gateway.png)
O log de fluxo personalizado a seguir para a interface de rede do gateway NAT de zona captura os seguintes campos nesta ordem:
```
instance-id interface-id srcaddr dstaddr pkt-srcaddr pkt-dstaddr
```
O log de fluxo mostra o fluxo do tráfego do endereço IP da instância (10.0.1.5) por meio da interface de rede do gateway NAT de zona para um host na internet (203.0.113.5). A interface de rede do gateway NAT de zona é uma interface de rede gerenciada pelo solicitante e, portanto, o registro de log de fluxo exibe um símbolo “-” para o campo instance-id. A linha a seguir mostra o tráfego da instância de origem para a interface de rede do gateway NAT de zona. Os valores dos campos dstaddr e pkt-dstaddr são diferentes. O campo dstaddr exibe o endereço IP privado da interface de rede do gateway NAT de zona, e o campo pkt-dstaddr exibe o endereço IP de destino final do host na internet.
```
- eni-1235b8ca123456789 10.0.1.5 10.0.0.220 10.0.1.5 203.0.113.5
```
As duas próximas linhas mostram o tráfego da interface de rede do gateway NAT de zona para o host de destino na internet e o tráfego de resposta do host para a interface de rede do gateway NAT.
```
- eni-1235b8ca123456789 10.0.0.220 203.0.113.5 10.0.0.220 203.0.113.5
- eni-1235b8ca123456789 203.0.113.5 10.0.0.220 203.0.113.5 10.0.0.220
```
A linha a seguir mostra o tráfego de resposta da interface de rede do gateway NAT de zona para a instância de origem. Os valores dos campos srcaddr e pkt-srcaddr são diferentes. O campo srcaddr exibe o endereço IP privado da interface de rede do gateway NAT de zona, e o campo pkt-srcaddr exibe o endereço IP do host na internet.
```
- eni-1235b8ca123456789 10.0.0.220 10.0.1.5 203.0.113.5 10.0.1.5
```
Você cria outro log de fluxo personalizado usando o mesmo conjunto de campos acima. Você cria o log de fluxo da interface de rede para a instância na sub-rede privada. Nesse caso, o campo instance-id retorna o ID da instância que se associa à interface de rede, e não há diferença entre os campos dstaddr e pkt-dstaddr e os campos srcaddr e pkt-srcaddr. Diferentemente da interface de rede do gateway NAT de zona, essa interface de rede não é intermediária para tráfego.
```
i-01234567890123456 eni-1111aaaa2222bbbb3 10.0.1.5 203.0.113.5 10.0.1.5 203.0.113.5 #Traffic from the source instance to host on the internet
i-01234567890123456 eni-1111aaaa2222bbbb3 203.0.113.5 10.0.1.5 203.0.113.5 10.0.1.5 #Response traffic from host on the internet to the source instance
```
## Tráfego por meio de um gateway NAT regional
Um gateway NAT regional pode se conectar a várias sub-redes em diferentes zonas de disponibilidade. Neste exemplo, duas instâncias em sub-redes privadas de duas zonas de disponibilidade diferentes acessam a internet por meio do mesmo gateway NAT regional. Os logs de fluxo a seguir mostram o tráfego de uma das instâncias para a internet por meio do gateway NAT regional.
![\[Acesso à internet por meio de um gateway NAT regional\]](http://docs.aws.amazon.com/pt_br/vpc/latest/userguide/images/flow-log-regional-nat-gateway.png)
O log de fluxo personalizado a seguir para o gateway NAT regional captura os seguintes campos nesta ordem:
```
resource-id instance-id interface-id subnet-id srcaddr dstaddr pkt-srcaddr pkt-dstaddr
```
O log de fluxo mostra o fluxo do tráfego do endereço IP da instância (10.0.1.5) por meio do gateway NAT regional para um host na internet (203.0.113.5). instance-id, interface-id e subnet-id não se aplicam ao gateway NAT regional. Portanto, o registro de log de fluxo exibe um símbolo “-” para esses campos. Em vez disso, o campo resource-id exibe o ID do gateway NAT regional. Os campos dstaddr e pkt-dstaddr exibem o endereço IP de destino final do host na internet.
```
nat-1234567890abcdef - - - 10.0.1.5 203.0.113.5 10.0.1.5 203.0.113.5
```
As duas próximas linhas mostram o tráfego do gateway NAT regional (endereço IP público 107.22.182.139) para o host de destino na internet e o tráfego de resposta do host para o gateway NAT regional.
```
nat-1234567890abcdef - - - 107.22.182.139 203.0.113.5 107.22.182.139 203.0.113.5
nat-1234567890abcdef - - - 203.0.113.5 107.22.182.139 203.0.113.5 107.22.182.139
```
A linha a seguir mostra o tráfego de resposta do gateway NAT regional para a instância de origem. Os campos srcaddr e pkt-srcaddr exibem o endereço IP do host na internet.
```
nat-1234567890abcdef - - - 203.0.113.5 10.0.1.5 203.0.113.5 10.0.1.5
```
Você cria outro log de fluxo personalizado usando o mesmo conjunto de campos acima. Você cria o log de fluxo da interface de rede para a instância na sub-rede privada. Nesse caso, o campo instance-id retorna o ID da instância que se associa à interface de rede, e resource-id é “-”. Não há diferença entre os campos dstaddr e pkt-dstaddr e os campos srcaddr e pkt-srcaddr.
```
- i-01234567890123456 eni-1111aaaa2222bbbb3 subnet-aaaaaaaa012345678 10.0.1.5 203.0.113.5 10.0.1.5 203.0.113.5 #Traffic from the source instance to host on the internet
- i-01234567890123456 eni-1111aaaa2222bbbb3 subnet-aaaaaaaa012345678 203.0.113.5 10.0.1.5 203.0.113.5 10.0.1.5 #Response traffic from host on the internet to the source instance
```
## Tráfego por meio de um gateway de trânsito
Neste exemplo, um cliente na VPC A se conecta a um servidor da Web na VPC B por meio de um gateway de trânsito. O cliente e o servidor estão em zonas de disponibilidade diferentes. O tráfego chega no servidor na VPC B utilizando um ID de interface de rede elástica (neste exemplo, vamos supor que o ID seja eni-111111111111111111111) e sai do VPC B utilizando outro (por exemplo, eni-222222222222222).
![\[Tráfego por meio de um gateway de trânsito\]](http://docs.aws.amazon.com/pt_br/vpc/latest/userguide/images/flow-log-tgw.png)
Você cria um log de fluxo personalizado para a VPC B com o seguinte formato.
```
version interface-id account-id vpc-id subnet-id instance-id srcaddr dstaddr srcport dstport protocol tcp-flags type pkt-srcaddr pkt-dstaddr action log-status
```
As linhas a seguir dos registros de log de fluxo demonstram o fluxo de tráfego na interface de rede para o servidor da Web. A primeira linha é o tráfego de solicitação do cliente e a última linha é o tráfego de resposta do servidor da Web.
```
3 eni-33333333333333333 123456789010 vpc-abcdefab012345678 subnet-22222222bbbbbbbbb i-01234567890123456 10.20.33.164 10.40.2.236 39812 80 6 3 IPv4 10.20.33.164 10.40.2.236 ACCEPT OK
...
3 eni-33333333333333333 123456789010 vpc-abcdefab012345678 subnet-22222222bbbbbbbbb i-01234567890123456 10.40.2.236 10.20.33.164 80 39812 6 19 IPv4 10.40.2.236 10.20.33.164 ACCEPT OK
```
A linha a seguir é o tráfego de solicitação na eni-11111111111111111, uma interface de rede gerenciada pelo solicitante para o gateway de trânsito na sub-rede subnet-11111111aaaaaaaaa. O registro de log de fluxo exibe, portanto, um símbolo “-” para o campo instance-id. O campo srcaddr exibe o endereço IP privado da interface de rede de gateway de trânsito, e o campo pkt-srcaddr exibe o endereço IP de origem do cliente na VPC A.
```
3 eni-11111111111111111 123456789010 vpc-abcdefab012345678 subnet-11111111aaaaaaaaa - 10.40.1.175 10.40.2.236 39812 80 6 3 IPv4 10.20.33.164 10.40.2.236 ACCEPT OK
```
A linha a seguir é o tráfego de solicitação na eni-22222222222222222, uma interface de rede gerenciada pelo solicitante para o gateway de trânsito na sub-rede subnet-22222222bbbbbbbbb. O campo dstaddr exibe o endereço IP privado da interface de rede de gateway de trânsito, e o campo pkt-dstaddr exibe o endereço IP do cliente na VPC A.
```
3 eni-22222222222222222 123456789010 vpc-abcdefab012345678 subnet-22222222bbbbbbbbb - 10.40.2.236 10.40.2.31 80 39812 6 19 IPv4 10.40.2.236 10.20.33.164 ACCEPT OK
```
## Nome do serviço, caminho de tráfego e direção do fluxo
Veja a seguir um exemplo dos campos para um registro de log de fluxo personalizado.
```
version srcaddr dstaddr srcport dstport protocol start end type packets bytes account-id vpc-id subnet-id instance-id interface-id region az-id sublocation-type sublocation-id action tcp-flags pkt-srcaddr pkt-dstaddr pkt-src-aws-service pkt-dst-aws-service traffic-path flow-direction log-status
```
No exemplo a seguir, a versão é a 5 porque os registros incluem campos da versão 5. Uma instância do EC2 aciona o serviço do Amazon S3. Os logs de fluxo são capturados na interface de rede para a instância. O primeiro registro tem uma direção de fluxo de ingress e o segundo, uma direção de fluxo de egress. Para o registro egress, o traffic-path é 8, indicando que o tráfego passa por um gateway da Internet. O campo traffic-path não é compatível com o tráfego ingress. Quando pkt-srcaddr ou pkt-dstaddr for um endereço IP público, o nome do serviço será exibido.
```
5 52.95.128.179 10.0.0.71 80 34210 6 1616729292 1616729349 IPv4 14 15044 123456789012 vpc-abcdefab012345678 subnet-aaaaaaaa012345678 i-0c50d5961bcb2d47b eni-1235b8ca123456789 ap-southeast-2 apse2-az3 - - ACCEPT 19 52.95.128.179 10.0.0.71 S3 - - ingress OK
5 10.0.0.71 52.95.128.179 34210 80 6 1616729292 1616729349 IPv4 7 471 123456789012 vpc-abcdefab012345678 subnet-aaaaaaaa012345678 i-0c50d5961bcb2d47b eni-1235b8ca123456789 ap-southeast-2 apse2-az3 - - ACCEPT 3 10.0.0.71 52.95.128.179 - S3 8 egress OK
```
# Limitações do log de fluxo
Para usar logs de fluxo, você precisa estar atento às seguintes limitações:
+ Após criar um log de fluxo, você não verá os dados do log de fluxo até que haja tráfego ativo para a interface de rede, sub-rede ou VPC que você selecionou.
+ Você não pode habilitar logs de fluxo para VPCs emparelhadas com a sua VPC, a menos que a VPC emparelhada esteja em sua conta.
+ Após criar um log de fluxo, não é possível alterar sua configuração ou o formato do registro do log de fluxo. Por exemplo, não é possível associar uma função do IAM diferente ao log de fluxo, nem adicionar ou remover campos no registro do log de fluxo. Em vez disso, você pode excluir o log de fluxo e criar um novo com a configuração necessária.
+ Se sua interface de rede tiver vários endereços IPv4 e o tráfego for enviado para um endereço IPv4 privado secundário, o log de fluxo exibirá o endereço IPv4 privado primário no campo `dstaddr`. Para capturar o endereço IP de destino original, crie um log de fluxo com o campo `pkt-dstaddr`.
+ Se o tráfego for enviado para uma interface de rede e o destino não for nenhum dos endereços IP da interface de rede, o log de fluxo exibirá o endereço IPv4 privado principal no campo `dstaddr`. Para capturar o endereço IP de destino original, crie um log de fluxo com o campo `pkt-dstaddr`.
+ Caso o tráfego seja enviado de uma interface de rede e a origem não corresponda a nenhum dos endereços IP dessa interface de rede, quando o registro de log for referente a um fluxo de saída, o log mostrará o endereço IPv4 privado principal no campo `srcaddr`. Para capturar o endereço IP de origem original, crie um log de fluxo com o campo `pkt-srcaddr`. Caso o registro de log seja para um fluxo de entrada na interface de rede, o endereço IP privado principal da interface de rede não será mostrado no campo `srcaddr`.
+ Quando uma interface de rede é anexada a uma [instância baseada em Nitro](https://docs.aws.amazon.com/ec2/latest/instancetypes/ec2-nitro-instances.html), o intervalo de agregação é sempre 1 minuto ou menos, independentemente do intervalo de agregação máximo especificado.
+ Para os campos `pkt-srcaddr` e `pkt-dstaddr`, se a camada intermediária tiver a Preservação do endereço IP do cliente ativada, esse campo poderá mostrar o IP do cliente preservado, em vez do endereço IP da camada intermediária.
+ Para o campo `traffic-path`, o valor é o mesmo para fluxos por meio de recursos na mesma VPC e fluxos que passam por um gateway local do Outpost.
+ Alguns registros de log de fluxo podem ser ignorados durante o intervalo de agregação (consulte *log-status* em [Campos disponíveis](flow-log-records.md#flow-logs-fields)). Isso pode ocorrer em virtude de uma restrição de capacidade interna da AWS ou de um erro interno. Se você estiver usando o AWS Cost Explorer para visualizar as cobranças dos logs de fluxo da VPC e alguns logs de fluxo forem ignorados durante o intervalo de agregação de logs de fluxo, o número de logs de fluxo relatados AWS Cost Explorer será maior do que o número de logs de fluxo publicados pela Amazon VPC.
+ Se você estiver usando o atributo [Bloquear o Acesso Público (BPA) da VPC](security-vpc-bpa-assess-impact-main.md#security-vpc-bpa-fl):
+ Os logs de fluxo para o BPA da VPC não incluem os [registros ignorados](flow-logs-records-examples.md#flow-log-example-no-data).
+ Os logs de fluxo para o BPA da VPC não incluem [`bytes`](flow-log-records.md#flow-logs-fields) mesmo que você inclua o campo `bytes` no log de fluxo.
Os logs de fluxo não capturam todo o tráfego de IP. Os tipos de tráfego a seguir não são registrados:
+ O tráfego gerado por instâncias quando elas entram em contato com o servidor de DNS da Amazon. Se você usar seu próprio servidor de DNS, todo tráfego para esse servidor de DNS será registrado.
+ O tráfego gerado por uma instância Windows para ativação de licença do Amazon Windows.
+ O tráfego para e proveniente de `169.254.169.254` para metadados de instância.
+ O tráfego para e proveniente de `169.254.169.123` para o Serviço de Sincronização Temporal da Amazon.
+ Tráfego DHCP.
+ Tráfego de origem do [tráfico espelhado](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-how-it-works.html). Você só verá tráfego de destino do tráfego espelhado.
+ Tráfego para o endereço IP reservado para o router padrão da VPC.
+ Trafegue entre uma interface de rede do endpoint e uma interface de rede do Network Load Balancer.
+ Tráfego do Protocolo de Resolução de Endereço (ARP).
+ O tráfego em um gateway NAT regional de curta duração, que é excluído alguns minutos após a criação.
Limitações específicas dos campos do ECS disponíveis na versão 7:
+ Os campos do ECS não serão computados se as tarefas subjacentes do ECS não pertencerem ao proprietário da assinatura do log de fluxo. Por exemplo, se você compartilhar uma sub-rede (`SubnetA`) com outra conta (`AccountB`) e, em seguida, criar uma assinatura de log de fluxo para a `SubnetA`, se `AccountB` iniciar tarefas do ECS na sub-rede compartilhada, sua assinatura receberá logs de tráfego das tarefas do ECS iniciadas por `AccountB`, mas os campos do ECS desses logs não serão calculados devido a questões de segurança.
+ Se você criar assinaturas de log de fluxo com campos do ECS no nível de recurso de VPC/sub-rede, qualquer tráfego gerado para interfaces de rede não pertencentes ao ECS também será entregue para suas assinaturas. Os valores dos campos do ECS serão “-” para tráfego IP não pertencente ao ECS. Por exemplo, você tem uma sub-rede (`subnet-000000`) e cria uma assinatura de log de fluxo para essa sub-rede com campos do ECS (`fl-00000000`). Na `subnet-000000`, você executa uma instância do EC2 (`i-0000000`) que está conectada à Internet e está gerando ativamente tráfego IP. Você também inicia uma tarefa do ECS em execução (`ECS-Task-1`) na mesma sub-rede. Como ambos `i-0000000` e `ECS-Task-1` estão gerando tráfego IP, sua assinatura de log de fluxo `fl-00000000` fornecerá logs de tráfego para ambas as entidades. No entanto, só `ECS-Task-1` terá metadados efetivos do ECS para os campos do ECS que você incluiu em seu logFormat. Para tráfego relacionado a `i-0000000`, esses campos terão um valor de “-”.
+ `ecs-container-id` e `ecs-second-container-id` são ordenados à medida que o serviço VPC Flow Logs recebê-los do fluxo de eventos do ECS. Não há garantias de que eles estarão na mesma ordem em que você os vê no console do ECS ou na chamada de API DescribetAsk. Se um contêiner entrar no status PARADO enquanto a tarefa ainda estiver em execução, ela poderá continuar aparecendo no seu log.
+ Os metadados do ECS e os registros de tráfego IP são provenientes de duas origens diferentes. Começaremos a computar seu tráfego do ECS assim que obtivermos todas as informações necessárias das dependências upstream. Depois que você inicia uma nova tarefa, começaremos a calcular seus campos do ECS 1) quando recebermos tráfego IP para a interface de rede subjacente e 2) quando recebermos o evento do ECS contendo os metadados da sua tarefa do ECS para indicar que a tarefa está em execução. Depois que você interromper uma tarefa, vamos parar de calcular seus campos do ECS 1) quando não recebermos mais tráfego IP para a interface de rede subjacente ou recebermos tráfego IP atrasado por mais de um dia e 2) quando recebermos o evento do ECS contendo os metadados da sua tarefa do ECS para indicar que a tarefa não está mais em execução.
+ Só há compatibilidade com tarefas do ECS iniciadas no [modo de rede](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html) `awsvpc`.
Limitações específicas do campo `encryption-status`:
+ O status da criptografia pode ser “-” (não disponível) em alguns fluxos, devido à limitação de alguns dispositivos de rede em relatar o status da criptografia. Os usuários podem ignorar esses fluxos na análise.
+ Aparecer como criptografado no modo de monitoramento não significa que o fluxo será permitido no modo de imposição. E vice-versa.
+ Se um fluxo for criptografado no modo de monitoramento, ele pode não estar em conformidade com o modo de imposição:
+ Se o fluxo envolver uma ENI criada por um serviço da AWS, o serviço precisará oferecer suporte aos controles de criptografia.
+ Se o fluxo passar pelo emparelhamento de VPC, a VPC emparelhada pode não forçar controles de criptografia.
+ Se um fluxo não for criptografado no modo de monitoramento, ele ainda poderá estar em conformidade no modo de imposição, já que o serviço relacionado ao fluxo é adicionado como uma exclusão.
## Preços
As cobranças de ingestão e de arquivamento de dados para logs fornecidos se aplicam quando você publica logs de fluxo. Para obter mais informações sobre preços ao publicar logs fornecidos, abra [Amazon CloudWatch Pricing](https://aws.amazon.com/cloudwatch/pricing/) (Preços do Amazon CloudWatch), selecione **Logs** e encontre **Vended Logs** (Logs fornecidos).
Para rastrear cobranças da publicação de logs de fluxo, você pode aplicar tags de alocação de custos ao recurso de destino. Em seguida, o relatório de alocação de custos da AWS incluirá o uso e os custos agregados por essas tags. É possível aplicar tags que representem categorias de negócios (como centros de custos, nomes de aplicativos ou proprietários) para organizar os custos. Para saber mais, consulte:
+ [Usar tags de alocação de custos](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html) no *Guia do usuário do AWS Billing*.
+ [Tag log groups in Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#log-group-tagging) (Marcar grupos de logs no Amazon CloudWatch Logs) no *Amazon CloudWatch Logs User Guide* (Guia do usuário do Amazon CloudWatch Logs)
+ [Using cost allocation S3 bucket tags](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CostAllocTagging.html) (Usar tags de alocação de custos para buckets do S3) no *Amazon Simple Storage Service User Guide* (Guia do usuário do Amazon Simple Storage Service)
+ [Marcar fluxos de entrega](https://docs.aws.amazon.com/firehose/latest/dev/firehose-tagging.html) no *Guia do desenvolvedor do Amazon Data Firehose*
# Trabalhar com logs de fluxo
É possível trabalhar com logs de fluxo usando os consoles do Amazon EC2 e da Amazon VPC.
**Topics**
+ [1. Controlar o uso de logs de fluxo com o IAM](#controlling-use-of-flow-logs)
+ [2. Criar um log de fluxo](#create-flow-log)
+ [3. Marcar um log de fluxo](#modify-tags-flow-logs)
+ [4. Excluir um log de fluxo](#delete-flow-log)
+ [Visão geral da linha de comando](#flow-logs-api-cli)
## 1. Controlar o uso de logs de fluxo com o IAM
Por padrão, os usuários do não têm permissão para trabalhar com logs de fluxo. É possível criar um perfil do IAM com uma política anexada que conceda permissões aos usuários para criar, descrever e excluir logs de fluxo.
Veja a seguir uma política de exemplo que concede aos usuários as permissões totais para criar, descrever e excluir logs de fluxo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DeleteFlowLogs",
"ec2:CreateFlowLogs",
"ec2:DescribeFlowLogs"
],
"Resource": "*"
}
]
}
```
------
Para obter mais informações, consulte [Como a Amazon VPC funciona com o IAM](security_iam_service-with-iam.md).
## 2. Criar um log de fluxo
É possível criar logs de fluxos para suas VPCs, sub-redes ou interfaces de rede. Ao criar um log de fluxo, você deve especificar um destino para o log de fluxo. Para saber mais, consulte:
+ [Criar um log de fluxo que publique no CloudWatch Logs](flow-logs-cwl-create-flow-log.md)
+ [Criar um log de fluxo para publicação no Amazon S3](flow-logs-s3-create-flow-log.md)
+ [Criar um log de fluxo para publicação no Amazon Data Firehose](flow-logs-firehose-create-flow-log.md)
## 3. Marcar um log de fluxo
Você pode adicionar ou remover tags de um log de fluxo a qualquer momento.
**Para gerenciar tags para um log de fluxo**
1. Execute um destes procedimentos:
+ Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/). No painel de navegação, selecione **Network Interfaces**. Marque a caixa de seleção para a interface de rede.
+ Abra o console da Amazon VPC em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). No painel de navegação, escolha **Your VPCs (Suas VPCs)**. Marque a caixa de seleção da VPC.
+ Abra o console da Amazon VPC, em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). No painel de navegação, escolha **Sub-redes**. Marque a caixa de seleção da sub-rede.
1. Escolha **Flow Logs**.(Logs de fluxo).
1. Selecione **Ações**, **Gerenciar tags**.
1. Para adicionar uma nova tag, escolha **Add new tag** (Adicionar nova tag) e insira a chave e o valor da tag. Para remover uma tag, selecione **Remover**.
1. Ao finalizar a adição ou a remoção de tags, escolha **Save** (Salvar).
## 4. Excluir um log de fluxo
É possível excluir um log de fluxo a qualquer momento. Depois que você exclui um log de fluxo, pode levar vários minutos para a coleta de dados se encerrar.
A exclusão de um log de fluxo não exclui os dados do log do destino nem modifica o recurso de destino. Você deve excluir os dados do log de fluxo existente diretamente no destino e limpar o recurso de destino usando o console do serviço de destino.
**Para excluir um log de fluxo**
1. Execute um destes procedimentos:
+ Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/). No painel de navegação, selecione **Network Interfaces**. Marque a caixa de seleção para a interface de rede.
+ Abra o console da Amazon VPC em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). No painel de navegação, escolha **Your VPCs (Suas VPCs)**. Marque a caixa de seleção da VPC.
+ Abra o console da Amazon VPC, em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). No painel de navegação, escolha **Sub-redes**. Marque a caixa de seleção da sub-rede.
1. Escolha **Flow Logs**.(Logs de fluxo).
1. Escolha **Actions**, (Ações), **Delete flow logs** (Excluir logs de fluxo).
1. Quando a confirmação for solicitada, insira **delete** e escolha **Delete** (Excluir).
## Visão geral da linha de comando
É possível executar as tarefas descritas nesta página por meio da linha de comando.
**Criar um log de fluxos**
+ [create-flow-logs](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-flow-logs.html) (AWS CLI)
+ [New-EC2FlowLog](https://docs.aws.amazon.com/powershell/latest/reference/items/New-EC2FlowLog.html) (AWS Tools for Windows PowerShell)
**Descrever um log de fluxo**
+ [describe-flow-logs](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-flow-logs.html) (AWS CLI)
+ [Get-EC2FlowLog](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2FlowLog.html) (AWS Tools for Windows PowerShell)
**Marcar um log de fluxo**
+ [create-tags](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-tags.html) and [delete-tags](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-tags.html) (AWS CLI)
+ [New-EC2Tag](https://docs.aws.amazon.com/powershell/latest/reference/items/New-EC2Tag.html) e [Remove-EC2Tag](https://docs.aws.amazon.com/powershell/latest/reference/items/Remove-EC2Tag.html) (AWS Tools for Windows PowerShell)
**Excluir um log de fluxo**
+ [delete-flow-logs](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-flow-logs.html) (AWS CLI)
+ [Remove-EC2FlowLog](https://docs.aws.amazon.com/powershell/latest/reference/items/Remove-EC2FlowLog.html) (AWS Tools for Windows PowerShell)
# Publicar logs de fluxo no CloudWatch Logs
Os logs de fluxos podem publicar os dados de log de fluxos diretamente no Amazon CloudWatch. O Amazon CloudWatch é um serviço abrangente de monitoramento e observabilidade. Ele coleta e rastreia métricas, registros e dados de eventos de vários recursos da AWS, bem como de seus serviços e aplicações. O CloudWatch fornece visibilidade sobre a utilização de recursos, performance de aplicações e integridade operacional, permitindo detectar e responder a mudanças na performance e a possíveis problemas em todo o sistema. Com o CloudWatch, você pode definir alarmes, visualizar registros e métricas e reagir automaticamente para coletar e otimizar seus recursos na nuvem. Ele é uma ferramenta essencial para garantir a confiabilidade, a disponibilidade e a performance da infraestrutura e das aplicações baseadas na nuvem.
Ao publicar no CloudWatch Logs, os dados de log de fluxo são publicados em um grupo de logs, e cada interface de rede tem um stream de logs exclusivo no grupo de logs. Os fluxos de log contêm registros de log de fluxo. Você pode criar vários logs de fluxo que publicam dados no mesmo grupo de logs. Se houver uma mesma interface de rede em um ou mais logs de fluxo no mesmo grupo de logs, haverá um stream misto de logs. Se tiver especificado que um log de fluxo deve capturar tráfego rejeitado e outro log de fluxo deve capturar o tráfego aceito, o stream misto de logs capturará todos os tráfegos.
No CloudWatch Logs, o campo **timestamp (carimbo de data/hora)** corresponde à hora de início capturada no registro de log do fluxo. O campo **ingestionTime (Tempo de consumo)** indica a data e a hora em que o registro de log do fluxo foi recebido pelo CloudWatch Logs. Esse timestamp é posterior à hora de término capturada no registro de log do fluxo.
Para obter mais informações sobre o CloudWatch Logs, consulte [Logs sent to CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html#AWS-logs-infrastructure-CWL) (Logs enviados ao CloudWatch Logs) no *Guia do usuário do Amazon CloudWatch Logs*.
**Preços**
As cobranças de arquivamento e ingestão de dados para logs vendidos se aplicam quando você publica logs de fluxos no CloudWatch Logs. Para obter mais informações, abra [Amazon CloudWatch Pricing](https://aws.amazon.com/cloudwatch/pricing/) (Preços do Amazon CloudWatch), selecione **Logs** e encontre **Vended Logs** (Logs fornecidos).
**Topics**
+ [Perfil do IAM para publicar logs de fluxo no CloudWatch Logs](flow-logs-iam-role.md)
+ [Criar um log de fluxo que publique no CloudWatch Logs](flow-logs-cwl-create-flow-log.md)
+ [Visualizar registros de log de fluxo com o CloudWatch Logs](view-flow-log-records-cwl.md)
+ [Procurar registros de log de fluxo](search-flow-log-records-cwl.md)
+ [Processar registros de log de fluxo no CloudWatch Logs](process-records-cwl.md)
# Perfil do IAM para publicar logs de fluxo no CloudWatch Logs
A função do IAM associada ao log de fluxo deve ter permissões suficientes para publicar logs de fluxo para o grupo de logs especificado no CloudWatch Logs. A função do IAM deve pertencer à sua conta da AWS.
A política do IAM anexada à sua função do IAM deve incluir pelo menos as permissões a seguir.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogGroups",
"logs:DescribeLogStreams"
],
"Resource": "*"
}
]
}
```
------
Verifique se a sua função tem a política de confiança a seguir, que permite que o serviço de logs de fluxo assuma a função.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "vpc-flow-logs.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Recomendamos o uso das chaves de condição `aws:SourceAccount` e `aws:SourceArn` para se proteger contra [O problema do agente confuso](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html). Por exemplo, você poderia adicionar o bloco de condições a seguir na política de confiança anterior. A conta de origem é o proprietário do log de fluxo e o ARN de origem é o ARN do log de fluxo. Se você não souber o ID do log de fluxos, poderá substituir essa parte do ARN por um caractere curinga (\$1) e, em seguida, atualizar a política depois de criar o log de fluxos.
```
"Condition": {
"StringEquals": {
"aws:SourceAccount": "account_id"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:ec2:region:account_id:vpc-flow-log/flow-log-id"
}
}
```
## Criar um perfil do IAM para logs de fluxo
Você pode atualizar um perfil existente conforme descrito acima. Como alternativa, você pode usar o seguinte procedimento para criar um novo perfil para usar com os logs de fluxo. Você especificará esse perfil ao criar o log de fluxo.
**Como criar um perfil do IAM para logs de fluxos**
1. Abra o console do IAM, em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação, escolha **Policies**.
1. Selecione **Criar política**.
1. Na página **Create policy (Criar política)** faça o seguinte:
1. Escolha **JSON**.
1. Substitua o conteúdo dessa janela pela política de permissões no início desta seção.
1. Escolha **Próximo**.
1. Insira um nome e uma descrição e tags opcionais para a política e escolha **Criar política**.
1. No painel de navegação, escolha **Perfis**.
1. Escolha **Criar Perfil**.
1. Em **Trusted entity type** (Tipo de entidade confiável), escolha **Custom trust policy** (Política de confiança personalizada). Em **Custom trust policy** (Política de confiança personalizada), substitua `"Principal": {},` pelo seguinte e escolha **Next** (Próximo).
```
"Principal": {
"Service": "vpc-flow-logs.amazonaws.com"
},
```
1. Na página **Add permissions** (Adicionar permissões), marque a caixa de seleção correspondente à política que você criou anteriormente neste procedimento e, em seguida, escolha **Next** (Próximo).
1. Insira um nome para a função e, opcionalmente, uma descrição.
1. Selecione **Create role**.
# Criar um log de fluxo que publique no CloudWatch Logs
É possível criar logs de fluxos para suas VPCs, sub-redes ou interfaces de rede. Caso execute essas etapas como um usuário usando um perfil do IAM específico, verifique se o perfil tem permissões para usar a ação `iam:PassRole`.
**Pré-requisito**
Verifique se a entidade principal do IAM que você está usando para fazer a solicitação tem permissões para chamar a ação `iam:PassRole`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": "arn:aws:iam::111122223333:role/flow-log-role-name"
}
]
}
```
------
**Para criar um log de fluxo usando o console**
1. Execute um destes procedimentos:
+ Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/). No painel de navegação, selecione **Network Interfaces**. Marque a caixa de seleção para a interface de rede.
+ Abra o console da Amazon VPC em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). No painel de navegação, escolha **Your VPCs (Suas VPCs)**. Marque a caixa de seleção da VPC.
+ Abra o console da Amazon VPC, em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). No painel de navegação, escolha **Sub-redes**. Marque a caixa de seleção da sub-rede.
1. Selecione **Ações**, **Criar log de fluxo**.
1. Em **Filter (Filtrar)**, especifique o tipo de tráfego a ser registrado em log. Selecione **All (Todos)** para registrar em log o tráfego aceito e rejeitado, **Rejected (Rejeitado)** para registrar somente o tráfego rejeitado ou **Accepted (Aceito)** para registrar somente o tráfego aceito.
1. Em **Maximum aggregation interval (Intervalo máximo de agregação)**, escolha o período máximo durante o qual um fluxo é capturado e agregado em um registro de log de fluxo.
1. Para **Destination** (Destino), escolha **Send to CloudWatch Logs** (Enviar para o CloudWatch Logs).
1. Em **Grupo de logs de destino**, escolha o nome de um grupo de logs existente ou insira o nome de um novo grupo de logs. Se você inserir um nome, criaremos o grupo de registros quando houver tráfego para registrar em log.
1. Para o **Acesso ao serviço**, escolha um [perfil de serviço do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html) existente que tenha permissões para publicar logs no CloudWatch Logs ou escolha criar um novo perfil de serviço.
1. Em **Formato de registro do log** , selecione o formato para o registro de log de fluxo.
+ Para usar o formato padrão, escolha **AWS Formato padrão**.
+ Para usar um formato personalizado, escolha **Formato personalizado** e, em seguida, selecione os campos de **Formato de log**.
1. Para **Metadados adicionais**, escolha se quer incluir metadados do Amazon ECS no formato de log.
1. (Opcional) Selecione **Adicionar nova tag** para aplicar tags ao log de fluxo.
1. Selecione **Criar log de fluxo**.
**Como criar um log de fluxo usando a linha de comando**
Use um dos seguintes comandos.
+ [create-flow-logs](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-flow-logs.html) (AWS CLI)
+ [New-EC2FlowLog](https://docs.aws.amazon.com/powershell/latest/reference/items/New-EC2FlowLog.html) (AWS Tools for Windows PowerShell)
O exemplo de AWS CLI a seguir cria um log de fluxo que captura todo o tráfego aceito para a sub-rede especificada. Os logs de fluxo são entregues ao grupo de logs especificado. O parâmetro `--deliver-logs-permission-arn` especifica o perfil do IAM necessário para publicar no CloudWatch Logs.
```
aws ec2 create-flow-logs --resource-type Subnet --resource-ids subnet-1a2b3c4d --traffic-type ACCEPT --log-group-name my-flow-logs --deliver-logs-permission-arn arn:aws:iam::123456789101:role/publishFlowLogs
```
# Visualizar registros de log de fluxo com o CloudWatch Logs
É possível visualizar os registros dos logs de fluxo por meio do console do CloudWatch Logs. Depois que o log de fluxo é criado, pode levar alguns minutos para ele ficar visível no console.
**Para visualizar registros de log de fluxo publicados no CloudWatch Logs**
1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação, selecione **Logs**, **Grupos de log**.
1. Selecione o nome do grupo de logs que contém os logs de fluxo para abrir a página de detalhes.
1. Selecione o nome do fluxo de logs que contém os registros de log de fluxo. Para obter mais informações, consulte [Registros de log de fluxo](flow-log-records.md).
**Para visualizar registros de log de fluxo publicados no CloudWatch Logs usando a linha de comando**
+ [get-log-events](https://docs.aws.amazon.com/cli/latest/reference/logs/get-log-events.html) (AWS CLI)
+ [Get-CWLLogEvent](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-CWLLogEvent.html) (AWS Tools for Windows PowerShell)
# Procurar registros de log de fluxo
É possível pesquisar os registros de log de fluxo publicados no CloudWatch Logs usando o console do CloudWatch Logs. Os [filtros de métrica](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html) podem ser usados para filtrar registros de log de fluxo. Os registros de log de fluxo são delimitados por espaço.
**Como pesquisar registros de log de fluxo usando o console do CloudWatch Logs**
1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação, selecione **Logs**, **Grupos de log**.
1. Selecione o grupo de logs que contém o log de fluxo e, em seguida, selecione o fluxo de logs se você souber a interface de rede que está pesquisando. Como alternativa, escolha **Search log group** (Pesquisar grupo de logs). Isso pode levar algum tempo se houver muitas interfaces de rede no grupo de logs ou dependendo do intervalo de tempo selecionado.
1. Em **Filtrar eventos**, insira a sequência abaixo. Isso pressupõe que o registro de log de fluxo usa o [formato padrão](flow-log-records.md#flow-logs-default).
```
[version, accountid, interfaceid, srcaddr, dstaddr, srcport, dstport, protocol, packets, bytes, start, end, action, logstatus]
```
1. Modifique o filtro conforme necessário especificando valores para os campos. Os exemplos a seguir filtram por endereços IP de origem específicos.
```
[version, accountid, interfaceid, srcaddr = 10.0.0.1, dstaddr, srcport, dstport, protocol, packets, bytes, start, end, action, logstatus]
[version, accountid, interfaceid, srcaddr = 10.0.2.*, dstaddr, srcport, dstport, protocol, packets, bytes, start, end, action, logstatus]
```
Os exemplos a seguir filtram por porta de destino, número de bytes e se o tráfego foi rejeitado.
```
[version, accountid, interfaceid, srcaddr, dstaddr, srcport, dstport = 80 || dstport = 8080, protocol, packets, bytes, start, end, action, logstatus]
[version, accountid, interfaceid, srcaddr, dstaddr, srcport, dstport = 80 || dstport = 8080, protocol, packets, bytes >= 400, start, end, action = REJECT, logstatus]
```
# Processar registros de log de fluxo no CloudWatch Logs
É possível processar registros de log de fluxo do mesmo modo que você trabalharia com outros eventos de coletados pelo CloudWatch Logs. Para obter mais informações sobre como monitorar dados de log e filtros de métricas, consulte [Creating metrics from log events using filter](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/MonitoringLogData.html) no * Guia do usuário do Amazon CloudWatch Logs*.
## Exemplo: criação de um filtro de métricas no CloudWatch e um alarme para um log de fluxo
Neste exemplo, há um log de fluxo para `eni-1a2b3c4d`. Pode ser útil criar um alarme que o alerte se houver 10 ou mais tentativas rejeitadas de conexão à sua instância pela porta TCP 22 (SSH) no período de 1 hora. Primeiro, você deve criar um filtro de métrica que corresponda ao padrão do tráfego para o qual o alarme será criado. Depois, você pode criar um alarme para o filtro de métricas.
**Como criar um filtro de métricas para tráfego SSH rejeitado e um alarme para o filtro**
1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação, escolha **Logs**, **Log groups** (Grupos de log).
1. Marque a caixa de seleção do grupo de log e, em seguida, escolha **Actions** (Ações), **Create metric filter** (Criar filtro de métrica).
1. Em **Filter Pattern** (Padrão de filtro), insira a seguinte string.
```
[version, account, eni, source, destination, srcport, destport="22", protocol="6", packets, bytes, windowstart, windowend, action="REJECT", flowlogstatus]
```
1. Em **Select Log Data to Test** (Selecionar dados de log para teste), selecione o fluxo de logs da interface de rede. (Opcional) Para visualizar as linhas de dados de log que correspondem ao padrão do filtro, escolha **Test Pattern** (Padrão de teste).
1. Quando estiver pronto, selecione **Avançar**.
1. Insira um nome de filtro, um namespace de métrica e o nome da métrica. Defina o valor da métrica como 1. Quando terminar, escolha **Next** (Avançar) e, em seguida, escolha **Create metric filter** (Criar filtro de métrica).
1. No painel de navegação, selecione **Alarmes**, **Todos os alarmes**.
1. Selecione **Criar alarme**.
1. Selecione o nome da métrica que você criou e, em seguida. escolha **Selecionar métrica**.
1. Configure o alarme como indicado a seguir e, em seguida, selecione **Avançar**:
+ Em **Estatística**, selecione **Soma**. Isso garante que o número total de pontos de dados do período especificado seja capturado.
+ Em **Período**, selecione **1 hora**.
+ Em **Sempre que TimeSinceLastActive for...**, escolha **Maior que/igual a** e insira 10 como limite.
+ Em **Additional configuration** (Configuração adicional), **Datapoints to alarm** (Pontos de dados para alarme), deixe o padrão de 1.
1. Escolha **Próximo**.
1. Em **Notification** (Notificação), escolha um tópico existente do SNS ou **Create new topic** (Criar tópico) para criar um. Escolha **Próximo**.
1. Insira um nome e uma descrição para o alarme e selecione **Avançar**.
1. Quando terminar de pré-visualizar o alarme, escolha **Criar alarme**.
# Publicar logs de fluxo no Amazon S3
Os logs de fluxo podem publicar dados de log de fluxo no Amazon S3. O Amazon S3 (Simple Storage Service) é um serviço de armazenamento de objetos altamente escalável e durável. Ele foi desenvolvido para armazenar e recuperar qualquer volume de dados, de qualquer lugar na Web. O S3 oferece durabilidade e disponibilidade líderes do setor, além de recursos integrados de controle de versão de dados, criptografia e controle de acesso.
Quando é feita uma publicação no Amazon S3, os dados de log de fluxo são publicados no bucket existente do Amazon S3 especificado. Os registros de log de fluxo para todas as interfaces de rede monitoradas são publicados em uma série de objetos de arquivos de log armazenados no bucket. Se o log de fluxo captura dados para uma VPC, o log de fluxo publica registros de log de fluxo em todas as interfaces de rede da VPC selecionada.
Para criar um bucket do Amazon S3 para usar com logs de fluxo, consulte [Criação de um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) no *Guia do usuário do Amazon S3*.
Para obter mais informações sobre como simplificar a ingestão de logs de fluxo de VPC, o processamento e a visualização de logs de fluxo, consulte [Log centralizado com o OpenSearch](https://aws.amazon.com/solutions/implementations/centralized-logging-with-opensearch/) na Biblioteca de soluções da AWS.
Para obter mais informações sobre o CloudWatch Logs, consulte [Logs enviados ao Amazon S3](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html#AWS-logs-infrastructure-S3) no *Guia do usuário do Amazon CloudWatch Logs*.
**Preços**
As cobranças de ingestão e de arquivamento de dados para logs vendidos se aplicam quando você publica logs de fluxo no Amazon S3. Para obter mais informações, abra [Amazon CloudWatch Pricing](https://aws.amazon.com/cloudwatch/pricing/) (Preços do Amazon CloudWatch), selecione **Logs** e encontre **Vended Logs** (Logs fornecidos).
**Topics**
+ [Arquivos de log de fluxo](flow-logs-s3-path.md)
+ [Permissões do bucket do Amazon S3 para logs de fluxo](flow-logs-s3-permissions.md)
+ [Política de chaves obrigatórias para uso com SSE-KMS](flow-logs-s3-cmk-policy.md)
+ [Permissões de arquivo de log do Amazon S3](flow-logs-file-permissions.md)
+ [Criar um log de fluxo para publicação no Amazon S3](flow-logs-s3-create-flow-log.md)
+ [Visualizar registros de log de fluxo com o Amazon S3](view-flow-log-records-s3.md)
# Arquivos de log de fluxo
O VPC Flow Logs coleta dados sobre o tráfego de IP proveniente de e que segue para a sua VPC em registros de log, agrega esses registros em arquivos de log e publica os arquivos de log no bucket do Amazon S3 em intervalos de 5 minutos. É possível haver a publicação de vários arquivos e cada arquivo de log pode conter alguns ou todos os registros de log de fluxo para o tráfego de IP registrado nos últimos 5 minutos.
No Amazon S3, o campo **Last modified (Última modificação)** do arquivo de log do fluxo indica a data e hora na qual o arquivo foi carregado para o bucket do Amazon S3. Esta indicação é posterior à data/hora no nome do arquivo e difere pela quantidade de tempo necessária para carregar o arquivo para o bucket do Amazon S3.
**Formato do arquivo de log**
É possível especificar um dos formatos a seguir para os arquivos de log. Cada arquivo é compactado em um único arquivo Gzip.
+ **Texto**: texto sem formatação. Esse é o formato padrão.
+ **Parquet**: Apache Parquet é um formato colunar de dados. Consultas sobre dados no formato Parquet são 10 a 100 vezes mais rápidas em comparação com consultas em dados em texto simples. Dados em formato Parquet com compressão Gzip ocupam 20% menos espaço de armazenamento do que o texto simples com compactação Gzip.
**nota**
Se os dados no formato Parquet com compactação Gzip forem inferiores a 100 KB por período de agregação, o armazenamento de dados no formato Parquet poderá ocupar mais espaço do que texto simples com a compactação Gzip devido aos requisitos de memória do arquivo Parquet.
**Opções do arquivo de log**
Opcionalmente, é possível especificar as seguintes opções.
+ **Prefixos S3 compatíveis com Hive**: habilite prefixos compatíveis com o Hive em vez de importar partições para as ferramentas compatíveis com o Hive. Antes de executar consultas, use o comando **MSCK REPAIR TABLE**.
+ **Partições por hora**: se houver um grande volume de logs e tipicamente direcionar consultas para uma hora específica, pode-se obter resultados mais rápidos e economizar em custos de consulta ao particionar os logs a cada hora.
**Estrutura do arquivo de log do bucket do S3**
Os arquivos de log são salvos no bucket do Amazon S3 especificado por meio de uma estrutura de pastas determinada pelo ID do log de fluxo, pela região, pela data de criação e pelas opções de destino.
Por padrão, os arquivos são entregues no local a seguir.
```
bucket-and-optional-prefix/AWSLogs/account_id/vpcflowlogs/region/year/month/day/
```
Ao habilitar prefixos S3 compatíveis com HIVE, os arquivos serão entregues no local a seguir.
```
bucket-and-optional-prefix/AWSLogs/aws-account-id=account_id/aws-service=vpcflowlogs/aws-region=region/year=year/month=month/day=day/
```
Ao habilitar partições por hora, os arquivos serão entregues no local a seguir.
```
bucket-and-optional-prefix/AWSLogs/account_id/vpcflowlogs/region/year/month/day/hour/
```
Ao habilitar partições compatíveis com o Hive e particionar o log de fluxo por hora, os arquivos serão entregues no local a seguir.
```
bucket-and-optional-prefix/AWSLogs/aws-account-id=account_id/aws-service=vpcflowlogs/aws-region=region/year=year/month=month/day=day/hour=hour/
```
**Nomes do arquivo de log**
O nome de um arquivo de log é baseado na ID do log de fluxo, na região e na data e na hora de criação. Os nomes de arquivo usam o seguinte formato.
```
aws_account_id_vpcflowlogs_region_flow_log_id_YYYYMMDDTHHmmZ_hash.log.gz
```
Veja a seguir um exemplo de arquivo de log para um log de fluxo criado pela conta 123456789012 da AWS para um recurso na região us-east-1 em June 20, 2018 às 16:20 UTC. O arquivo contém os registros de log de fluxo com um horário de término entre 16:20:00 e 16:24:59.
```
123456789012_vpcflowlogs_us-east-1_fl-1234abcd_20180620T1620Z_fe123456.log.gz
```
# Permissões do bucket do Amazon S3 para logs de fluxo
Por padrão, os buckets do Amazon S3 e os objetos que eles contêm são privados. Somente o proprietário do bucket pode acessá-los. No entanto, o proprietário do bucket pode conceder acesso a outros recursos e usuários por meio da criação de uma política de acesso.
Se o usuário que cria um log de fluxo for proprietário do bucket e tiver as permissões `PutBucketPolicy` e `GetBucketPolicy` para este bucket, as políticas a seguir serão automaticamente anexadas. Esta política substitui qualquer política existente anexada ao bucket.
Caso contrário, o proprietário do bucket deve adicionar essa política ao bucket, especificando o ID da conta da AWS do criador de log de fluxo ou falha na criação do log de fluxo. Para obter mais informações, consulte [Uso de políticas de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-policies.html) no *Guia do usuário do Amazon Simple Storage Service*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AWSLogDeliveryWrite",
"Effect": "Allow",
"Principal": {
"Service": "delivery.logs.amazonaws.com"
},
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "123456789012",
"s3:x-amz-acl": "bucket-owner-full-control"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:logs:us-east-1:123456789012:*"
}
}
},
{
"Sid": "AWSLogDeliveryAclCheck",
"Effect": "Allow",
"Principal": {
"Service": "delivery.logs.amazonaws.com"
},
"Action": "s3:GetBucketAcl",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "123456789012"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:logs:us-east-1:123456789012:*"
}
}
}
]
}
```
------
O ARN especificado para *my-s3-arn* depende do uso ou não de prefixos S3 compatíveis com Hive.
+ Prefixos padrão
```
arn:aws:s3:::bucket_name/optional_folder/AWSLogs/account_id/*
```
+ Prefixos S3 compatíveis com Hive
```
arn:aws:s3:::bucket_name/optional_folder/AWSLogs/aws-account-id=account_id/*
```
É uma prática recomendada conceder essas permissões à entidade principal do serviço de entrega de logs em vez de concedê-las a ARNs individuais da Conta da AWS. Outra prática recomendada é o uso das chaves de condição `aws:SourceAccount` e `aws:SourceArn` para se proteger contra [O problema do agente confuso](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html). A conta de origem é o proprietário do log de fluxo e o ARN de origem é o ARN curinga (\$1) do serviço de logs.
Vale ressaltar que o serviço de entrega de logs realiza a ação `HeadBucket` da API do Amazon S3 para verificar a existência e a localização do bucket do S3. Não é necessário conceder permissão ao serviço de entrega de logs para executar essa ação; ele continuará a entregar os logs de fluxo da VPC mesmo que não consiga confirmar a existência do bucket do S3 e a localização. Entretanto, haverá um erro `AccessDenied` na chamada para `HeadBucket` nos logs do CloudTrail.
# Política de chaves obrigatórias para uso com SSE-KMS
É possível proteger os dados no bucket do Amazon S3 habilitando a criptografia no lado do servidor com chaves gerenciadas pelo Amazon S3 (SSE-S3) ou a criptografia no lado do servidor com chaves do KMS (SSE-KMS) em seu bucket do S3. Para obter mais informações, consulte [Proteger dados usando criptografia do lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html) no *Manual do usuário do Amazon S3*.
Se você escolher SSE-S3, nenhuma configuração adicional será necessária. O Amazon S3 lida com a chave de criptografia.
Se você escolher SSE-KMS, deverá usar um ARN de chave gerenciada pelo cliente. Se você usar um ID de chave, poderá se deparar com um erro [LogDestination não pode ser entregue](flow-logs-troubleshooting.md#flow-logs-troubleshooting-kms-id) ao criar um log de fluxo. Além disso, você deve atualizar a política de chaves para a chave gerenciada pelo cliente para que a conta de entrega de logs possa gravar no bucket do S3. Para obter mais informações sobre a política de chaves exigida para uso com o SEE-KMS, consulte [Criptografia no lado do servidor de buckets do Amazon S3](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html#AWS-logs-SSE-KMS-S3) no *Guia do usuário do Amazon CloudWatch Logs*.
# Permissões de arquivo de log do Amazon S3
Além das políticas de bucket necessárias, o Amazon S3 usa listas de controle de acesso (ACLs) para gerenciar o acesso aos arquivos de log criados por um log de fluxo. Por padrão, o proprietário do bucket tem permissões `FULL_CONTROL` em cada arquivo de log. O proprietário da entrega de logs, se é diferente do proprietário do bucket, não tem nenhuma permissão. A conta de entrega de logs tem permissões `READ` e `WRITE`. Para obter mais informações, consulte [Visão geral da lista de controle de acesso (ACL)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html) no *Guia do usuário do Amazon S3*.
# Criar um log de fluxo para publicação no Amazon S3
Depois de criar e configurar o bucket do Amazon S3, você poderá criar logs de fluxo para as interfaces de rede, sub-redes e VPCs.
**Pré-requisito**
A entidade principal do IAM que cria o log de fluxo deve estar usando um perfil do IAM com as permissões a seguir, necessárias para publicar logs de fluxo no bucket de destino do Amazon S3.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogDelivery",
"logs:DeleteLogDelivery"
],
"Resource": "*"
}
]
}
```
------
**Para criar um log de fluxo usando o console**
1. Execute um destes procedimentos:
+ Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/). No painel de navegação, selecione **Network Interfaces**. Marque a caixa de seleção para a interface de rede.
+ Abra o console da Amazon VPC em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). No painel de navegação, escolha **Your VPCs (Suas VPCs)**. Marque a caixa de seleção da VPC.
+ Abra o console da Amazon VPC, em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). No painel de navegação, escolha **Sub-redes**. Marque a caixa de seleção da sub-rede.
1. Selecione **Ações**, **Criar log de fluxo**.
1. Em **Filter (Filtro)**, especifique o tipo de dados de tráfego de IP para registrar em log.
+ **Aceitar**: registre em log somente o tráfego aceito
+ **Rejeitar**: registre em log somente o tráfego rejeitado
+ **Todos**: registre em log o tráfego aceito e rejeitado.
1. Em **Maximum aggregation interval (Intervalo máximo de agregação)**, escolha o período máximo durante o qual um fluxo é capturado e agregado em um registro de log de fluxo.
1. Em **Destination (Destino)**, escolha **Send to an Amazon S3 bucket (Enviar para um bucket do Amazon S3)**.
1. Em **ARN do bucket do S3**, especifique o nome de recurso da Amazon (ARN) de um bucket existente do Amazon S3. Opcionalmente, é possível incluir uma subpasta. Por exemplo, para especificar uma subpasta chamada `my-logs` em um bucket chamado `my-bucket`, use o seguinte ARN:
`arn:aws:s3:::my-bucket/my-logs/`
O bucket não pode usar `AWSLogs` como um nome de subpasta, pois se trata de um termo reservado.
Se você for o proprietário do bucket, uma política de recurso será automaticamernte criada e anexada ao bucket. Para obter mais informações, consulte [Permissões do bucket do Amazon S3 para logs de fluxo](flow-logs-s3-permissions.md).
1. Em **Formato de registro de log**, selecione o formato para o registro de log de fluxo.
+ Para usar o formato de registro de log de fluxo padrão, escolha **AWS Formato padrão**.
+ Para criar um formato personalizado, escolha **Formato personalizado**. Em **Formato de log**, selecione os campos a serem incluídos no registro de log de fluxo.
1. Para **Metadados adicionais**, escolha se quer incluir metadados do Amazon ECS no formato de log.
1. Em **Formato de registro de log**, especifique o formato do arquivo de log.
+ **Texto**: texto sem formatação. Esse é o formato padrão.
+ **Parquet**: Apache Parquet é um formato colunar de dados. Consultas sobre dados no formato Parquet são 10 a 100 vezes mais rápidas em comparação com consultas em dados em texto simples. Dados em formato Parquet com compressão Gzip ocupam 20% menos espaço de armazenamento do que o texto simples com compactação Gzip.
1. (Opcional) Para usar prefixos S3 compatíveis com o Hive, escolha **Prefixo do S3 compatível com Hive**, **Habilitar**.
1. (Opcional) Para particionar seus logs de fluxo por hora, selecione **A cada 1 hora (60 minutos)**.
1. (Opcional) Para adicionar uma etiqueta ao log de fluxo, escolha **Adicionar nova tag** e especifique a chave e o valor da tag.
1. Selecione **Criar log de fluxo**.
**Como criar um log de fluxo que publique no Amazon S3 usando a linha de comando**
Use um dos seguintes comandos:
+ [create-flow-logs](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-flow-logs.html) (AWS CLI)
+ [New-EC2FlowLog](https://docs.aws.amazon.com/powershell/latest/reference/items/New-EC2FlowLog.html) (AWS Tools for Windows PowerShell)
O exemplo de AWS CLI a seguir cria um log de fluxo que captura todo o tráfego da VPC especificada e fornece os logs de fluxo ao bucket do Amazon S3 especificado. O parâmetro `--log-format` especifica um formato personalizado para os registros de log de fluxo.
```
aws ec2 create-flow-logs --resource-type VPC --resource-ids vpc-00112233344556677 --traffic-type ALL --log-destination-type s3 --log-destination arn:aws:s3:::flow-log-bucket/custom-flow-logs/ --log-format '${version} ${vpc-id} ${subnet-id} ${instance-id} ${srcaddr} ${dstaddr} ${srcport} ${dstport} ${protocol} ${tcp-flags} ${type} ${pkt-srcaddr} ${pkt-dstaddr}'
```
# Visualizar registros de log de fluxo com o Amazon S3
Você pode visualizar os registros de log de fluxo usando o console do Amazon S3. Depois que o log de fluxo é criado, pode levar alguns minutos para ele ficar visível no console.
Os arquivos de log são compactados. Quando os arquivos de log são abertos usando o console do Amazon S3, eles serão descompactados, e os registros de log de fluxo serão exibidos. Se os arquivos forem baixados, será necessário descompactá-los para visualizar os registros de log de fluxo.
**Como visualizar os registros de log de fluxo publicados no Amazon S3**
1. Abra o console do Amazon S3, em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Selecione o nome do bucket para abrir sua página de detalhes.
1. Navegue até a pasta com os arquivos de log. Por exemplo, *prefixo*/AWSLogs/*id\$1da\$1conta*/vpcflowlogs/*região*/*ano*/*mês*/*dia*/.
1. Marque a caixa de seleção ao lado do nome do arquivo e escolha **Download** (Baixar).
Também é possível consultar os registros de log de fluxo nos arquivos de log usando o Amazon Athena. O Amazon Athena é um serviço de consultas interativas que facilita a análise de dados no Amazon S3 usando SQL padrão. Para obter mais informações, consulte [Consultar os Amazon VPC Flow Logs](https://docs.aws.amazon.com/athena/latest/ug/vpc-flow-logs.html) no *Manual do usuário do Amazon Athena*.
# Publicar logs de fluxo no Amazon Data Firehose
Os logs de fluxo podem publicar dados de logs de fluxo diretamente no Amazon Data Firehose. O Amazon Data Firehose é um serviço totalmente gerenciado que coleta, transforma e entrega fluxos de dados em tempo real em vários armazenamentos de dados e serviços de analytics da AWS. Ele se encarrega da ingestão de dados em seu nome.
Quando se trata de logs de fluxo de VPC, o Firehose pode ser útil. Os logs de fluxo da VPC capturam informações sobre o tráfego de IP entrando e saindo das interfaces de rede em sua VPC. Esses dados podem ser cruciais para monitoramento de segurança, análise de performance e conformidade regulatória. No entanto, gerenciar o armazenamento e o processamento desse fluxo contínuo de dados de log pode ser uma tarefa complexa e que consome muitos recursos.
Ao integrar o Firehose com seus logs de fluxo de VPC, você pode entregar esses dados ao seu destino preferido, como Amazon S3 ou Amazon Redshift. O Firehose se expandirá para lidar com a ingestão, transformação e entrega de seus logs de fluxo de VPC, aliviando você dessa sobrecarga operacional. Isso permite que você se concentre na análise dos logs e na obtenção de insights, em vez de precisar se preocupar com a infraestrutura subjacente.
Além disso, o Firehose oferece recursos como transformação, compactação e criptografia de dados, os quais podem aumentar a eficiência e a segurança do seu pipeline de processamento de logs de fluxo de VPC. Usar o Firehose para logs de fluxo de VPC pode simplificar o gerenciamento de dados e permitir que você obtenha insights dos dados de tráfego da rede.
Ao publicar no Amazon Data Firehose, os dados de logs de fluxo são publicados em um fluxo de entrega do Amazon Data Firehose como texto sem formatação.
**Preços**
São aplicadas as taxas padrão de ingestão e entrega. Para obter mais informações, abra [Amazon CloudWatch Pricing](https://aws.amazon.com/cloudwatch/pricing/) (Preços do Amazon CloudWatch), selecione **Logs** e encontre **Vended Logs** (Logs fornecidos).
**Topics**
+ [Perfis do IAM para entrega entre contas](firehose-cross-account-delivery.md)
+ [Criar um log de fluxo para publicação no Amazon Data Firehose](flow-logs-firehose-create-flow-log.md)
# Perfis do IAM para entrega entre contas
Ao publicar no Amazon Data Firehose, você pode escolher um fluxo de entrega que esteja na mesma conta que o recurso a ser monitorado (a conta de origem) ou em uma conta diferente (a conta de destino). Para permitir a entrega de logs de fluxo entre contas para o Amazon Data Firehose, você deve criar um perfil do IAM na conta de origem e um perfil do IAM na conta de destino.
**Topics**
+ [Função da conta de origem](#firehose-source-account-role)
+ [Função da conta de destino](#firehose-destination-account-role)
## Função da conta de origem
Na conta de origem, crie uma função que conceda as seguintes permissões. Neste exemplo, o nome do perfil é `mySourceRole`, mas é possível escolher um nome diferente para este perfil. A última instrução permite que o perfil na conta de destino assuma este perfil. As instruções de condição garantem que esse perfil seja passado somente para o serviço de entrega de logs e somente ao monitorar o recurso especificado. Ao criar a política, especifique as VPCs, as interfaces de rede ou as sub-redes que sendo monitoradas com a chave de condição `iam:AssociatedResourceARN`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::123456789012:role/mySourceRole",
"Condition": {
"StringEquals": {
"iam:PassedToService": "delivery.logs.amazonaws.com"
},
"StringLike": {
"iam:AssociatedResourceARN": [
"arn:aws:ec2:us-east-1:123456789012:vpc/vpc-00112233344556677"
]
}
}
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogDelivery",
"logs:DeleteLogDelivery",
"logs:ListLogDeliveries",
"logs:GetLogDelivery"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111122223333:role/AWSLogDeliveryFirehoseCrossAccountRole"
}
]
}
```
------
Verifique se a essa função tem a política de confiança a seguir, que permite que o serviço de entrega de logs assuma a função.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "delivery.logs.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Na conta de origem, use o procedimento a seguir para criar a função.
**Para criar a função da conta de origem**
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação, escolha **Policies**.
1. Selecione **Criar política**.
1. Na página **Create policy (Criar política)** faça o seguinte:
1. Escolha **JSON**.
1. Substitua o conteúdo dessa janela pela política de permissões no início desta seção.
1. Escolha **Próximo**.
1. Insira um nome e uma descrição e tags opcionais para a política e escolha **Criar política**.
1. No painel de navegação, escolha **Perfis**.
1. Escolha **Criar Perfil**.
1. Em **Trusted entity type** (Tipo de entidade confiável), escolha **Custom trust policy** (Política de confiança personalizada). Em **Custom trust policy** (Política de confiança personalizada), substitua `"Principal": {},` pelo seguinte, que especifica o serviço de entrega de logs. Selecione **Avançar**.
```
"Principal": {
"Service": "delivery.logs.amazonaws.com"
},
```
1. Na página **Adicionar permissões**, marque a caixa de seleção correspondente à política criada anteriormente neste procedimento e, em seguida, escolha **Avançar**.
1. Insira um nome para a função e, opcionalmente, uma descrição.
1. Selecione **Create role**.
## Função da conta de destino
Na conta de destino, crie uma função com um nome que comece com **AWSLogDeliveryFirehoseCrossAccountRole**. Esse perfil deve conceder as seguintes permissões.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:CreateServiceLinkedRole",
"firehose:TagDeliveryStream"
],
"Resource": "*"
}
]
}
```
------
Certifique-se de que essa função tenha a seguinte política de confiança, que permite que a função que você criou na conta de origem assuma esta função.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/mySourceRole"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Na conta de destino, use o procedimento a seguir para criar a função.
**Para criar a função da conta de destino**
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação, escolha **Policies**.
1. Selecione **Criar política**.
1. Na página **Create policy (Criar política)** faça o seguinte:
1. Escolha **JSON**.
1. Substitua o conteúdo dessa janela pela política de permissões no início desta seção.
1. Escolha **Próximo**.
1. Insira um nome para a política que comece com **AWSLogDeliveryFirehoseCrossAccountRole** e, em seguida, selecione **Criar política**.
1. No painel de navegação, escolha **Perfis**.
1. Escolha **Criar Perfil**.
1. Em **Trusted entity type** (Tipo de entidade confiável), escolha **Custom trust policy** (Política de confiança personalizada). Em **Custom trust policy** (Política de confiança personalizada), substitua `"Principal": {},` pelo seguinte, que especifica a função da conta de origem. Escolha **Próximo**.
```
"Principal": {
"AWS": "arn:aws:iam::source-account:role/mySourceRole"
},
```
1. Na página **Adicionar permissões**, marque a caixa de seleção correspondente à política criada anteriormente neste procedimento e, em seguida, escolha **Avançar**.
1. Insira um nome para a função e, opcionalmente, uma descrição.
1. Selecione **Create role**.
# Criar um log de fluxo para publicação no Amazon Data Firehose
É possível criar logs de fluxos para suas VPCs, sub-redes ou interfaces de rede.
**Pré-requisitos**
+ Crie o fluxo de entrega de destino do Amazon Data Firehose. Usar **Direct Put** (Inserção direta) como origem. Para obter mais informações, consulte [Criar um fluxo de entrega do Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html).
+ A conta que cria o log de fluxo deve estar usando um perfil do IAM que conceda as permissões a seguir para publicar logs de fluxo no Amazon Data Firehose.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogDelivery",
"logs:DeleteLogDelivery",
"iam:CreateServiceLinkedRole",
"firehose:TagDeliveryStream"
],
"Resource": "*"
}
]
}
```
------
+ Se você estiver publicando logs de fluxo em uma conta diferente, crie os perfis do IAM necessários, conforme descrito em [Perfis do IAM para entrega entre contas](firehose-cross-account-delivery.md).
**Para criar um log de fluxo que publique no Amazon Data Firehose**
1. Execute um destes procedimentos:
+ Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/). No painel de navegação, selecione **Network Interfaces**. Marque a caixa de seleção para a interface de rede.
+ Abra o console da Amazon VPC em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). No painel de navegação, escolha **Your VPCs (Suas VPCs)**. Marque a caixa de seleção da VPC.
+ Abra o console da Amazon VPC, em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). No painel de navegação, escolha **Sub-redes**. Marque a caixa de seleção da sub-rede.
1. Selecione **Ações**, **Criar log de fluxo**.
1. Em **Filter (Filtrar)**, especifique o tipo de tráfego a ser registrado em log.
+ **Accept** (Aceitar): registre em log somente o tráfego aceito
+ **Reject** (Rejeitar): registre em log somente o tráfego rejeitado
+ **All** (Todos): registre em log o tráfego aceito e rejeitado
1. Em **Maximum aggregation interval (Intervalo máximo de agregação)**, escolha o período máximo durante o qual um fluxo é capturado e agregado em um registro de log de fluxo.
1. Em **Destination** (Destino), escolha uma das seguintes opções:
+ **Enviar para o Amazon Data Firehose na mesma conta**: o fluxo de entrega e o recurso a serem monitorados estão na mesma conta.
+ **Enviar para o Amazon Data Firehose em uma conta diferente**: o fluxo de entrega e o recurso a serem monitorados estão em contas diferentes.
1. No nome do fluxo do **Amazon Data Firehose**, selecione o fluxo de entrega que você criou.
1. [Somente para entrega entre contas] Para o **Acesso ao serviço**, escolha um [perfil de serviço do IAM existente para entrega entre contas](firehose-cross-account-delivery.md) que tenha permissões para publicar logs ou selecione **Configurar permissões** para abrir o console do IAM e criar um perfil de serviço.
1. Em **Formato de registro de log**, selecione o formato para o registro de log de fluxo.
+ Para usar o formato de registro de log de fluxo padrão, escolha **AWS Formato padrão**.
+ Para criar um formato personalizado, escolha **Formato personalizado**. Em **Formato de log**, selecione os campos a serem incluídos no registro de log de fluxo.
1. Para **Metadados adicionais**, escolha se quer incluir metadados do Amazon ECS no formato de log.
1. (Opcional) Escolha **Adicionar tag** para aplicar tags ao log de fluxo.
1. Selecione **Criar log de fluxo**.
**Como criar um log de fluxo que publique no Amazon Data Firehose usando a linha de comando**
Use um dos seguintes comandos:
+ [create-flow-logs](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-flow-logs.html) (AWS CLI)
+ [New-EC2FlowLog](https://docs.aws.amazon.com/powershell/latest/reference/items/New-EC2FlowLog.html) (AWS Tools for Windows PowerShell)
O exemplo de AWS CLI a seguir cria um log de fluxo que captura todo o tráfego da VPC especificada e entrega os logs de fluxo ao fluxo de entrega do Amazon Data Firehose na mesma conta.
```
aws ec2 create-flow-logs --traffic-type ALL \
--resource-type VPC \
--resource-ids vpc-00112233344556677 \
--log-destination-type kinesis-data-firehose \
--log-destination arn:aws:firehose:us-east-1:123456789012:deliverystream/flowlogs_stream
```
O exemplo de AWS CLI a seguir cria um log de fluxo que captura todo o tráfego da VPC especificada e entrega os logs de fluxo ao fluxo de entrega do Amazon Data Firehose em uma conta diferente.
```
aws ec2 create-flow-logs --traffic-type ALL \
--resource-type VPC \
--resource-ids vpc-00112233344556677 \
--log-destination-type kinesis-data-firehose \
--log-destination arn:aws:firehose:us-east-1:123456789012:deliverystream/flowlogs_stream \
--deliver-logs-permission-arn arn:aws:iam::source-account:role/mySourceRole \
--deliver-cross-account-role arn:aws:iam::destination-account:role/AWSLogDeliveryFirehoseCrossAccountRole
```
Como resultado da criação do log de fluxo, é possível obter os dados de log de fluxo no destino que você configurou para o fluxo de entrega.
# Consultar logs de fluxo usando o Amazon Athena
O Amazon Athena é um serviço de consulta interativa que permite analisar dados no Amazon S3, como seus logs de fluxo, usando o SQL padrão. Você pode usar o Athena com o VPC Flow Logs para obter rapidamente insights acionáveis sobre o tráfego que atravessa a sua VPC. Por exemplo, você pode identificar quais recursos em suas virtual private clouds (VPCs) são os principais locutores ou identificar os endereços IP com as conexões TCP mais rejeitadas.
**Opções**
+ Você pode simplificar e automatizar a integração dos logs de fluxo da VPC com o Athena gerando um modelo do CloudFormation que cria os recursos necessários da AWS e as consultas predefinidas que você pode executar para obter insights sobre o tráfego que atravessa a VPC.
+ Você pode criar suas próprias consultas usando o Athena. Para obter mais informações, consulte [Consulta de logs de fluxo usando o Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/vpc-flow-logs.html) no *Guia do usuário do Amazon Athena*.
**Preços**
Você incorre em [cobranças padrão do Amazon Athena](https://aws.amazon.com/athena/pricing/) pelas consultas feitas. [Cobranças padrão da AWS Lambda](https://aws.amazon.com/lambda/pricing/) serão aplicadas à função do Lambda que carrega novas partições em uma programação recorrente (para quando você especifica uma frequência de carregamento de partição, mas deixa de especificar uma data de início e término).
**Topics**
+ [Gerar o modelo do CloudFormation usando o console](flow-logs-generate-template-console.md)
+ [Gerar o modelo do CloudFormation usando a AWS CLI](flow-logs-generate-template-cli.md)
+ [Executar uma consulta predefinida](flow-logs-run-athena-query.md)
# Gerar o modelo do CloudFormation usando o console
Depois que os primeiros logs de fluxo forem entregues ao seu bucket do S3, você pode integrar ao Athena gerando um modelo do CloudFormation e usando o modelo para criar uma pilha.
**Requisitos**
+ A região selecionada deve ser compatível com o AWS Lambda e o Amazon Athena.
+ Os buckets do Amazon S3 devem estar na região selecionada.
+ O formato de registro de log para o log de fluxo deve incluir os campos usados pelas consultas predefinidas específicas que você desejar executar.
**Para gerar o modelo usando o console**
1. Execute um destes procedimentos:
+ Abra o console da Amazon VPC. No painel de navegação, escolha **Your VPCs** (Suas VPCs) e, em seguida, selecione a sua VPC.
+ Abra o console da Amazon VPC. No painel de navegação, escolha **Subnets** (Sub-redes) e, em seguida, selecione a sua sub-rede.
+ Abra o console do Amazon EC2. No painel de navegação, escolha **Network Interfaces** (Interfaces de rede) e, em seguida, selecione a sua interface de rede.
1. Na guia **Flow logs** (Logs de fluxo), selecione um log de fluxo que publica no Amazon S3 e, em seguida, escolha **Actions** (Ações) e **Generate Athena integration** (Gerar integração ao Athena).
1. Especifique a frequência de carregamento da partição. Se escolher **None** (Nenhum), você deve especificar as datas de início e término da partição, usando datas do passado. Se escolher **Daily** (Diário), **Weekly** (Semanal) ou **Monthly** (Mensal), as datas de início e término da partição serão opcionais. Se você não especificar datas de início e término, o modelo do CloudFormation cria uma função do Lambda que carrega novas partições em uma programação recorrente.
1. Selecione ou crie um bucket do S3 para o modelo gerado e um bucket do S3 para os resultados da consulta.
1. Escolha **Generate Athena integration** (Gerar integração ao Athena).
1. (Opcional) Na mensagem de êxito, escolha o link para navegar até o bucket que especificou para o modelo do CloudFormation e personalize o modelo.
1. Na mensagem de êxito, escolha **Create CloudFormation stack** (Criar pilha do CloudFormation) para abrir o assistente **Create Stack** (Criar pilha) no console do CloudFormation. A URL do modelo do CloudFormation gerado é especificado na seção **Template** (Modelo). Conclua o assistente para criar os recursos especificados no modelo.
**Recursos desenvolvidos pelo modelo do CloudFormation**
+ Um banco de dados do Athena. O nome do banco de dados é vpcflowlogsathenadatabase<*flow-logs-subscription-id*>.
+ Um grupo de trabalho do Athena. O nome do grupo de trabalho é <*flow-log-subscription-id*><*partition-load-frequency*><*start-date*><*end-date*>workgroup
+ Uma tabela particionada do Athena que corresponde aos seus registros de log de fluxo. O nome da tabela é <*flow-log-subscription-id*><*partition-load-frequency*><*start-date*><*end-date*>.
+ Um conjunto de consultas nomeadas do Athena. Para obter mais informações, consulte [Consultas predefinidas](flow-logs-run-athena-query.md#predefined-queries).
+ Uma função do Lambda que carrega novas partições para a tabela de acordo com a programação especificada (diária, semanal ou mensal).
+ Uma função do IAM que concede permissão para executar as funções do Lambda.
# Gerar o modelo do CloudFormation usando a AWS CLI
Depois que os primeiros logs de fluxo forem entregues ao bucket do S3, você poderá gerar e usar um modelo do CloudFormation para fazer a integração ao Athena.
Use o comando a seguir [get-flow-logs-integration-template](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-flow-logs-integration-template.html) para gerar o modelo do CloudFormation.
```
aws ec2 get-flow-logs-integration-template --cli-input-json file://config.json
```
Este é um exemplo do arquivo `config.json`.
```
{
"FlowLogId": "fl-12345678901234567",
"ConfigDeliveryS3DestinationArn": "arn:aws:s3:::my-flow-logs-athena-integration/templates/",
"IntegrateServices": {
"AthenaIntegrations": [
{
"IntegrationResultS3DestinationArn": "arn:aws:s3:::my-flow-logs-analysis/athena-query-results/",
"PartitionLoadFrequency": "monthly",
"PartitionStartDate": "2021-01-01T00:00:00",
"PartitionEndDate": "2021-12-31T00:00:00"
}
]
}
}
```
Use o comando a seguir [create-stack](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) para criar uma pilha usando o modelo do CloudFormation gerado.
```
aws cloudformation create-stack --stack-name my-vpc-flow-logs --template-body file://my-cloudformation-template.json
```
# Executar uma consulta predefinida
O modelo do CloudFormation gerado fornece um conjunto de consultas predefinidas que você pode realizar para obter rapidamente insights significativos sobre o tráfego em sua rede da AWS. Depois de criar a pilha e verificar se todos os recursos foram criados corretamente, você pode realizar uma das consultas predefinidas.
**Para realizar uma consulta predefinida usando o console**
1. Abra o console do Athena.
1. No painel de navegação, selecione **Query editor** (Editor de consultas). Em **Workgroup** (Grupo de trabalho), selecione o grupo de trabalho criado pelo modelo do CloudFormation.
1. Selecione **Saved queries** (Consultas salvas), selecione uma consulta, modifique os parâmetros conforme necessário e execute a consulta. Para obter uma lista das consultas predefinidas disponíveis, consulte [Predefined queries](#predefined-queries) (Consultas predefinidas).
1. Em **Query results** (Resultados da consulta), veja os resultados da consulta.
## Consultas predefinidas
A seguir, uma lista completa das consultas nomeadas do Athena. As consultas predefinidas fornecidas quando você gera o modelo dependem dos campos que fazem parte do formato de registro de log para o log de fluxo. Assim sendo, o modelo pode não conter todas essas consultas predefinidas.
+ **VPCFlowLogsAcceptedTraffic**: as conexões TCP que foram permitidas com base nos seus grupos de segurança e ACLs de rede.
+ **VpcFlowLogsAdminPortTraffic**: os 10 principais endereços IP com mais tráfego, conforme registrado por aplicações que atendem solicitações em portas administrativas.
+ **VPCFlowLogsiPv4Traffic**: o total registrado de bytes de tráfego IPv4.
+ **VPCFlowLogsiPv6Traffic**: o total registrado de bytes de tráfego IPv6.
+ **VPCFlowLogsRejectedTCPTraffic**: as conexões TCP que foram rejeitadas com base nos seus grupos de segurança ou ACLs de rede.
+ **VPCFlowLogsRejectedTraffic**: o tráfego que foi rejeitado com base nos seus grupos de segurança ou ACLs de rede.
+ **VPCFlowLogsShrdpTraffic**: o tráfego SSH e RDP.
+ **VPCFlowLogStopTalkers**: os 50 endereços IP com mais tráfego registrado.
+ **VPCFlowLogStopTalkersPacketLevel**: os 50 endereços IP no nível de pacote com mais tráfego registrado.
+ **VPCFlowLogStoptalkingInstances**: os IDs das 50 instâncias com mais tráfego registrado.
+ **VPCFlowLogStopTalkingSubnets**: os IDs das 50 sub-redes com mais tráfego registrado.
+ **VPCFlowLogStoptCPTraffic**: todo o tráfego TCP registrado para um endereço IP de origem.
+ **VPCFlowLogsTotalByTestransFerred**: os 50 pares de endereços IP de origem e destino com mais bytes registrados.
+ **VPCFlowLogsTotalByTestRansFerredPacketLevel**: os 50 pares de endereços IP de origem e destino no nível de pacote com mais bytes registrados.
+ **VPCFlowLogsTrafficFrmsRcaddr**: o tráfego registrado para um endereço IP de origem específico.
+ **VPCFlowLogsTrafficTodStaddr**: o tráfego registrado para um endereço IP de destino específico.
# Solucionar problemas do VPC Flow Logs
Veja a seguir os possíveis problemas que você pode ter ao trabalhar com logs de fluxo.
**Topics**
+ [Registros incompletos de log de fluxo](#flow-logs-troubleshooting-incomplete-records)
+ [O log de fluxo está ativo, mas não há registro de log de fluxo nem grupo de logs](#flow-logs-troubleshooting-no-log-group)
+ [Erro “LogDestinationNotFoundException” ou “Access Denied for LogDestination”](#flow-logs-troubleshooting-not-found)
+ [Exceder o limite de políticas de buckets do Amazon S3](#flow-logs-troubleshooting-policy-limit)
+ [LogDestination não pode ser entregue](#flow-logs-troubleshooting-kms-id)
+ [Inconsistência de tamanho de dados entre logs do fluxo e os dados de cobrança](#flow-logs-data-size-mismatch)
## Registros incompletos de log de fluxo
**Problema**
Os registros do log de fluxo estão incompletos ou não estão mais sendo publicados.
**Causa**
Pode haver um problema ao entregar os logs de fluxo para o grupo de logs do CloudWatch Logs ou [Entradas SkipData podem estar presentes](flow-logs-records-examples.md#flow-log-example-no-data).
**Solução**
Verifique a guia **Logs de fluxo** para visualizar a VPC, a sub-rede ou a interface da rede. Vale ressaltar que você não pode descrever logs de fluxo para uma VPC ou sub-rede que foi compartilhada com você, mas pode descrever logs de fluxo para uma interface da rede que você criar em uma VPC ou sub-rede compartilhada com você. Se houver algum erro, ele será mostrado na coluna **Status**. Outra opção é usar o comando [describe-flow-logs](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-flow-logs.html) e verificar o valor retornado no campo `DeliverLogsErrorMessage`.
Os seguintes são valores possíveis de erro para o status:
+ `Rate limited`: esse erro poderá ocorrer se o controle de utilização de logs do CloudWatch Logs tiver sido aplicado: quando o número de registros de log de fluxo de uma interface de rede for superior ao número máximo de registros que podem ser publicados em um intervalo de tempo específico. Esse erro também poderá ocorrer se for atingida a cota do número de grupos de logs do CloudWatch Logs que podem ser criados. Para obter mais informações, consulte [cotas de serviço do CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_limits.html) no *Manual do usuário do Amazon CloudWatch*.
+ `Access error`: esse erro pode ocorrer por um dos seguintes motivos:
+ A função do IAM de seu log de fluxo não tem permissões suficientes para publicar registros de log de fluxo no grupo de logs do CloudWatch.
+ A função do IAM não tem uma relação de confiança com o serviço de logs de fluxo
+ A relação de confiança não especifica o serviço de logs de fluxo como principal
Para obter mais informações, consulte [Perfil do IAM para publicar logs de fluxo no CloudWatch Logs](flow-logs-iam-role.md).
+ `Unknown error`: ocorreu um erro interno nos logs de fluxos.
## O log de fluxo está ativo, mas não há registro de log de fluxo nem grupo de logs
**Problema**
Você criou um log de fluxo. O console da Amazon VPC ou do Amazon EC2 exibe esse log de fluxo como `Active`. No entanto, não é possível ver nenhum stream de log no CloudWatch Logs nem arquivos de log no bucket do Amazon S3.
**Possíveis causas**
+ O log de fluxo ainda está sendo criado. Em alguns casos, pode demorar dez minutos ou mais após a criação do log de fluxo para que o grupo de logs seja criado e para que os dados sejam exibidos.
+ Nenhum tráfego foi registrado até o momento para suas interfaces de rede. O grupo de logs no CloudWatch Logs só é criado quando o tráfego é registrado.
**Solução**
Aguarde alguns minutos para que o grupo de logs seja criado ou para o tráfego ser registrado.
## Erro “LogDestinationNotFoundException” ou “Access Denied for LogDestination”
**Problema**
Você recebe um erro `Access Denied for LogDestination` ou `LogDestinationNotFoundException` quando tenta criar um log de fluxo.
**Possíveis causas**
+ Ao criar um log de fluxo que publica dados em um bucket do Amazon S3, esse erro indica que o bucket do S3 especificado não pôde ser encontrado ou que a política de bucket não permite que logs sejam entregues ao bucket.
+ Ao criar um log de fluxo que publica dados no Amazon CloudWatch Logs, esse erro indica que a função do IAM não permite que os logs sejam entregues ao grupo de logs.
**Solução**
+ Ao publicar no Amazon S3, verifique se você especificou o ARN de um bucket do S3 existente e se o ARN está no formato correto. Se não for proprietário do bucket do S3, verifique se a [política de bucket](flow-logs-s3-permissions.md) tem as permissões necessárias e usa o ID da conta e o nome do bucket corretos no ARN.
+ Ao publicar no CloudWatch Logs, verifique se a [função do IAM](flow-logs-iam-role.md) tem as permissões necessárias.
## Exceder o limite de políticas de buckets do Amazon S3
**Problema**
Você obtém o seguinte erro ao tentar criar um log de fluxo: `LogDestinationPermissionIssueException`.
**Possíveis causas**
As políticas de buckets do Amazon S3 são limitadas a 20 KB.
Toda vez que você cria um log de fluxo que é publicado em um bucket do Amazon S3, automaticamente adicionamos o ARN do bucket especificado, que inclui o caminho da pasta, ao elemento `Resource` na política do bucket.
Criar vários logs de fluxo que são publicados no mesmo bucket pode fazer com que você exceda o limite da política do bucket.
**Solução**
+ Limpe a política de bucket removendo as entradas de log de fluxo que não são mais necessárias.
+ Conceda permissões para o bucket inteiro substituindo as entradas de log de fluxo individuais pelo seguinte.
```
arn:aws:s3:::bucket_name/*
```
Se você conceder permissões para o bucket inteiro, as novas assinaturas de log de fluxo não adicionam novas permissões à política de bucket.
## LogDestination não pode ser entregue
**Problema**
Você obtém o seguinte erro ao tentar criar um log de fluxo: `LogDestination is undeliverable`.
**Possíveis causas**
O bucket de destino do Amazon S3 é criptografado usando a criptografia do lado do servidor com AWS KMS (SSE-KMS) e a criptografia padrão do bucket é um ID de chave do KMS.
**Solução**
O valor deve ser um ARN de chave do KMS. Altere o tipo de criptografia S3 padrão, de ID da chave KMS para ARN de chave do KMS. Para obter mais informações, consulte [Configuração da criptografia padrão](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-bucket-encryption.html) no *Guia do usuário do Amazon Simple Storage Service*.
## Inconsistência de tamanho de dados entre logs do fluxo e os dados de cobrança
**Problema**
O tamanho total dos dados dos seus logs de fluxo não corresponde ao tamanho relatado pelos dados de cobrança.
**Possíveis causas**
Pode haver entradas SKIPDATA em seus logs de fluxo. Consulte [Sem dados e registros ignorados](flow-logs-records-examples.md#flow-log-example-no-data) para obter uma explicação sobre entradas SKIPDATA.
**Solução**
Confirme se as entradas SKIPDATA estão presentes em suas entradas de log consultando seus logs em busca de entradas diferentes no campo de status do log.
Exemplos de consultas para verificar a presença de SKIPDATA:
Insights do CW:
```
fields @timestamp, @message, @logStream, @log
| filter interfaceId = 'eni-123'
| stats count(*) by interfaceId, logStatus
| sort by interfaceId, logStatus
```
Athena:
```
SELECT log_status, interface_id, count(1)
FROM vpc_flow_logs
WHERE interface_id IN ('eni-1', 'eni-2', 'eni-3')
GROUP BY log_status, interface_id
```