Configuração do roteador de log Testar a aplicação Considerações sobre tamanho Solução de problemas

Inicie o log no AWS Fargate para o seu cluster

O Amazon EKS no Fargate oferece um roteador de log integrado baseado no Fluent Bit. Isso significa que você não executa explicitamente um contêiner do Fluent Bit como um sidecar, mas a Amazon o executa para você. Tudo o que você precisa fazer é configurar o roteador de log. A configuração acontece por meio de um ConfigMap que deve atender aos seguintes critérios:

Nomeado aws-logging
Criado em um namespace dedicado chamado aws-observability
Não pode exceder 5.300 caracteres.

Depois de criar o ConfigMap, o Amazon EKS no Fargate o detecta automaticamente e configura o roteador de log com ele. O Fargate usa uma versão do AWS para Fluent Bit, uma distribuição do Fluent Bit a montante, compatível e gerenciada pela AWS. Para obter mais informações, consulte AWS for Fluent Bit no GitHub.

O roteador de log permite que você use toda a variedade de serviços da AWS para analytics de log e armazenamento. Você pode transmitir logs do Fargate diretamente para o Amazon CloudWatch, Amazon OpenSearch Service. Você também pode transmitir logs para destinos como Amazon S3, Amazon Kinesis Data Streams e ferramentas de parceiros por meio do Amazon Data Firehose.

Um perfil existente do Fargate que especifica um namespace existente do Kubernetes em que você implanta pods do Fargate. Para obter mais informações, consulte Etapa 3: criar um perfil do Fargate para o cluster.
Um perfil de execução existente de pod do Fargate. Para obter mais informações, consulte Etapa 2: criar um perfil de execução de pods do Fargate.

Configuração do roteador de log

Nas etapas a seguir, substitua cada valor de exemplo por seus próprios valores.

Crie um namespace dedicado do Kubernetes chamado aws-observability.
1. Salve o seguinte conteúdo no seu computador, em um arquivo chamado aws-observability-namespace.yaml: O valor para name deve ser aws-observability e o rótulo aws-observability: enabled é obrigatório.
```
kind: Namespace
apiVersion: v1
metadata:
  name: aws-observability
  labels:
    aws-observability: enabled
```
2. Crie o novo namespace.
```
kubectl apply -f aws-observability-namespace.yaml
```
Crie um ConfigMap com um valor de dados do Fluent Conf para enviar logs de contêiner a um destino. Fluent Conf é o Fluent Bit, uma linguagem de configuração de processador de logs rápida e leve usada para encaminhar logs de contêiner para um destino de sua escolha. Para obter mais informações, consulte Configuration File (Arquivo de configuração) na documentação do Fluent Bit.
Importante
As principais seções incluídas em um Fluent Conf típico são Service, Input, Filter e Output. No entanto, o roteador de log do Fargate só aceita:
- As seções Filter e Output.
- Uma seção Parser.
Se você fornecer outras seções, elas serão rejeitadas.
O roteador de log do Fargate gerencia as seções Input e Service. Ele tem a seção Input a seguir, que não pode ser modificada e não é necessária no ConfigMap. Porém, ela pode oferecer informações, como o limite do buffer de memória e a tag aplicada aos logs.
```
[INPUT]
    Name tail
    Buffer_Max_Size 66KB
    DB /var/log/flb_kube.db
    Mem_Buf_Limit 45MB
    Path /var/log/containers/*.log
    Read_From_Head On
    Refresh_Interval 10
    Rotate_Wait 30
    Skip_Long_Lines On
    Tag kube.*
```
Ao criar o ConfigMap, leve em consideração as seguintes regras que o Fargate usa para validar os campos:
- [FILTER],[OUTPUT], e [PARSER] devem ser especificados sob cada chave correspondente. Por exemplo, o [FILTER] deve estar em filters.conf. Você pode ter um ou mais [FILTER]s em filters.conf. As seções [OUTPUT] e [PARSER] também devem estar sob suas chaves correspondentes. Ao especificar várias seções [OUTPUT], você pode rotear os logs para destinos diferentes ao mesmo tempo.
- O Fargate valida as chaves necessárias para cada seção. Name e match são necessários para cada [FILTER] e [OUTPUT]. Name e format são necessários para cada [PARSER]. As chaves não diferenciam maiúsculas de minúsculas.
- Variáveis de ambiente como ${ENV_VAR} não são permitidas no ConfigMap.
- O recuo tem que ser o mesmo para o par de diretivas ou chave-valor dentro de cada filters.conf, output.conf e parsers.conf. Pares chave-valor têm que ser recuados mais do que as diretivas.
- O Fargate valida de acordo com os seguintes filtros compatíveis: grep, parser, record_modifier, rewrite_tag, throttle, nest, modify e kubernetes.
- O Fargate valida de acordo com os seguintes filtros compatíveis: es, firehose, kinesis_firehose, cloudwatch, cloudwatch_logs e kinesis.
- É necessário fornecer ao menos um plug-in Output com suporte no ConfigMap para habilitar o registro em log. Filter e Parser não são necessários para habilitar o registro em log.
  
  Você também pode executar o Fluent Bit no Amazon EC2 usando a configuração desejada para solucionar quaisquer problemas decorrentes da validação. Crie o ConfigMap usando um dos exemplos a seguir.
  
  Importante
  O registro em log do Fargate no Amazon EKS não oferece suporte para a configuração dinâmica de ConfigMap. Quaisquer alterações em um ConfigMap são aplicadas somente aos novos pods. As alterações não são aplicadas a pods existentes.
  
  Crie um ConfigMap usando o exemplo para o destino de log desejado.
  
  nota
  Você também pode usar o Amazon Kinesis Data Streams para seu destino de log. Se você usar o Kinesis Data Streams, verifique se a função de execução do pod recebeu a permissão kinesis:PutRecords. Para obter mais informações, consulte as Permissões do Amazon Kinesis Data Streams no Fluent Bit: manual oficial.
CloudWatch

Você tem duas opções de saída ao usar o CloudWatch:

Um plugin de saída criado em C

Um plugin de saída criado em Golang

O exemplo a seguir mostra como usar o plug-in cloudwatch_logs para enviar logs para o CloudWatch.

Salve o conteúdo a seguir em um arquivo denominado aws-logging-cloudwatch-configmap.yaml. Substitua region-code pela região da AWS em que o cluster se encontra. Os parâmetros em [OUTPUT] são necessários.

kind: ConfigMap apiVersion: v1 metadata: name: aws-logging namespace: aws-observability data: flb_log_cw: "false" # Set to true to ship Fluent Bit process logs to CloudWatch. filters.conf: | [FILTER] Name parser Match * Key_name log Parser crio [FILTER] Name kubernetes Match kube.* Merge_Log On Keep_Log Off Buffer_Size 0 Kube_Meta_Cache_TTL 300s output.conf: | [OUTPUT] Name cloudwatch_logs Match kube.* region region-code log_group_name my-logs log_stream_prefix from-fluent-bit- log_retention_days 60 auto_create_group true parsers.conf: | [PARSER] Name crio Format Regex Regex ^(?<time>[^ ]+) (?<stream>stdout|stderr) (?<logtag>P|F) (?<log>.*)$ Time_Key time Time_Format %Y-%m-%dT%H:%M:%S.%L%z

Aplique o manifesto ao cluster.

kubectl apply -f aws-logging-cloudwatch-configmap.yaml

Amazon OpenSearch Service

Se quiser enviar logs para o Amazon OpenSearch Service, é possível usar a saída es, que é um plug-in escrito em C. O exemplo a seguir mostra como usar o plug-in para enviar logs para o OpenSearch.

Salve o conteúdo a seguir em um arquivo denominado aws-logging-opensearch-configmap.yaml. Substitua cada valor de exemplo por seus próprios valores.

kind: ConfigMap apiVersion: v1 metadata: name: aws-logging namespace: aws-observability data: output.conf: | [OUTPUT] Name es Match * Host search-example-gjxdcilagiprbglqn42jsty66y.region-code.es.amazonaws.com Port 443 Index example Type example_type AWS_Auth On AWS_Region region-code tls On

Aplique o manifesto ao cluster.

kubectl apply -f aws-logging-opensearch-configmap.yaml

Firehose

Você tem duas opções de saída ao enviar logs para o Firehose:

kinesis_firehose: um plug-in de saída escrito em C.

firehose - Um plug-in de saída escrito em Golang.

O exemplo a seguir mostra como usar o plug-in kinesis_firehose para enviar logs para o Firehose.

Salve o conteúdo a seguir em um arquivo denominado aws-logging-firehose-configmap.yaml. Substitua region-code pela região da AWS em que o cluster se encontra.

kind: ConfigMap apiVersion: v1 metadata: name: aws-logging namespace: aws-observability data: output.conf: | [OUTPUT] Name kinesis_firehose Match * region region-code delivery_stream my-stream-firehose

Aplique o manifesto ao cluster.

kubectl apply -f aws-logging-firehose-configmap.yaml
Configure as permissões para o perfil de execução do pod do Fargate para enviar logs ao seu destino.
1. Baixe a política do IAM do seu destino para o computador.
  CloudWatch
  
  Baixe a política de IAM do CloudWatch no computador. Você também pode visualizar a política no GitHub.
  
  curl -O https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/cloudwatchlogs/permissions.json
  
  Amazon OpenSearch Service
  
  Baixe a política do IAM OpenSearch para o seu computador. Você também pode visualizar a política no GitHub.
  
  curl -O https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/amazon-elasticsearch/permissions.json
  
  Verifique se o controle de acesso do OpenSearch Dashboards está configurado corretamente. O all_access role no OpenSearch Dashboards precisa que o perfil de execução de pods do Fargate e o perfil do IAM sejam mapeados. O mesmo mapeamento deve ser feito para a função security_manager. Você pode adicionar os mapeamentos anteriores selecionando Menu, depois Security, depois Roles e, em seguida, selecionar as respectivas funções. Para obter mais informações, consulte How do I troubleshoot CloudWatch Logs so that it streams to my Amazon ES domain? (Como solucionar problemas do CloudWatch Logs para que ele transmita para o meu domínio do Amazon ES?).
  
  Firehose
  
  Baixe a política do IAM do Firehose para o seu computador. Você também pode visualizar a política no GitHub.
  
  curl -O https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/kinesis-firehose/permissions.json
2. Crie uma política do IAM com base no arquivo de política que você baixou.
```
aws iam create-policy --policy-name eks-fargate-logging-policy --policy-document file://permissions.json
```
3. Anexe a política do IAM à função de execução de pod especificada para o seu perfil do Fargate com o comando a seguir. Substitua 111122223333 pelo ID da sua conta. Substitua AmazonEKSFargatePodExecutionRole pelo perfil de execução de pods (para obter mais informações, consulte Etapa 2: criar um perfil de execução de pods do Fargate).
```
aws iam attach-role-policy \
  --policy-arn arn:aws:iam::111122223333:policy/eks-fargate-logging-policy \
  --role-name AmazonEKSFargatePodExecutionRole
                  
```

Suporte ao filtro Kubernetes

Esse recurso requer a seguinte versão mínima do Kubernetes e de nível de plataforma, ou versões superiores.

Versão do Kubernetes	Nível da plataforma
1.23 e posteriores	eks.1

O filtro Kubernetes Fluent Bit permite adicionar metadados do Kubernetes aos arquivos de log. Para mais informações sobre o filtro, consulte Kubernetes na documentação do Fluent Bit. É possível aplicar um filtro usando o endpoint do servidor da API.


filters.conf: |
    [FILTER]
        Name             kubernetes
        Match            kube.*
        Merge_Log           On
        Buffer_Size         0
        Kube_Meta_Cache_TTL 300s

Importante

Kube_URL, Kube_CA_File, Kube_Token_Command e Kube_Token_File são parâmetros de configuração de propriedade do serviço e não devem ser especificados. O Amazon EKS Fargate preenche esses valores.
Kube_Meta_Cache_TTL é o tempo em que o Fluent Bit aguarda até se comunicar com o servidor de API para obter os metadados mais recentes. Se Kube_Meta_Cache_TTL não for especificado, o Amazon EKS Fargate acrescentará um valor padrão de 30 minutos para diminuir a carga no servidor de API.

Para enviar logs de processo do Fluent Bit para sua conta

Opcionalmente, você pode enviar logs de processo do Fluent Bit para o Amazon CloudWatch usando o ConfigMap a seguir. O envio de logs do processo Fluent Bit para o CloudWatch exige custos adicionais de ingestão e armazenamento de logs. Substitua region-code pela região da AWS em que o cluster se encontra.


kind: ConfigMap
apiVersion: v1
metadata:
  name: aws-logging
  namespace: aws-observability
  labels:
data:
  # Configuration files: server, input, filters and output
  # ======================================================
  flb_log_cw: "true"  # Ships Fluent Bit process logs to CloudWatch.

  output.conf: |
    [OUTPUT]
        Name cloudwatch
        Match kube.*
        region region-code
        log_group_name fluent-bit-cloudwatch
        log_stream_prefix from-fluent-bit-
        auto_create_group true

Os logs estão no CloudWatch, na mesma região da AWS que o cluster. O nome do grupo de logs é my-cluster-fluent-bit-logs, e o nome do fluxo de logs do Fluent Bit é fluent-bit-podname-pod-namespace.

nota

Os logs de processo são enviados somente quando o processo do Fluent Bit é iniciado corretamente. Caso haja uma falha ao iniciar o Fluent Bit, os logs do processo serão perdidos. Só é possível enviar logs de processo ao CloudWatch.
Para depurar o envio de logs de processo em sua conta, você pode aplicar o ConfigMap anterior para obter os logs de processo. A falha de inicialização do Fluent Bit geralmente ocorre porque o ConfigMap não foi analisado ou aceito pelo Fluent Bit ao iniciar.

Para interromper os logs do processo de envio do Fluent Bit

O envio de logs do processo Fluent Bit para o CloudWatch exige custos adicionais de ingestão e armazenamento de logs. Para excluir registros do processo em uma configuração ConfigMap existente, siga as etapas a seguir.

Localize o grupo de logs do CloudWatch criado automaticamente para os logs do processo do Fluent Bit do cluster do Amazon EKS, após habilitar o registro em log do Fargate. Ele segue o formato my-cluster-fluent-bit-logs.
Exclua os fluxos de log existentes do CloudWatch criados para os logs de processo de cada pod no grupo de logs do CloudWatch.
Edite ConfigMap e configure flb_log_cw: "false".
Reinicie todos os pods existentes no cluster.

Testar a aplicação

Implante um pod de exemplo.

Salve o seguinte conteúdo no seu computador, em um arquivo chamado sample-app.yaml:


apiVersion: apps/v1
kind: Deployment
metadata:
  name: sample-app
  namespace: same-namespace-as-your-fargate-profile
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          ports:
            - name: http
              containerPort: 80

Aplique o manifesto ao cluster.
```
kubectl apply -f sample-app.yaml
```

Visualize os logs do NGINX usando os destinos que você configurou no ConfigMap.

Considerações sobre tamanho

Sugerimos que você planeje até 50 MB de memória para o roteador de log. Se você espera que a aplicação gere logs com um throughput muito alto, planeje até 100 MB.

Solução de problemas

Para confirmar se o recurso de registro em log está habilitado ou desabilitado por algum motivo, como um ConfigMap inválido, e por que ele está inválido, verifique os eventos de pods com kubectl describe pod pod-name. A saída pode incluir eventos de pods que esclarecem se o registro em log está habilitado ou não, como a saída de exemplo a seguir.


[...]
Annotations:          CapacityProvisioned: 0.25vCPU 0.5GB
                      Logging: LoggingDisabled: LOGGING_CONFIGMAP_NOT_FOUND
                      kubernetes.io/psp: eks.privileged
[...]
Events:
  Type     Reason           Age        From                                                           Message
  ----     ------           ----       ----                                                           -------
  Warning  LoggingDisabled  <unknown>  fargate-scheduler                                              Disabled logging because aws-logging configmap was not found. configmap "aws-logging" not found

Os eventos de pods são temporários, com um intervalo de tempo que depende das configurações. Você também pode visualizar as anotações de um pod usando kubectl describe pod pod-name. A anotação do pod informa se o recurso de registro em log está habilitado ou desabilitado e o motivo.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Coletar métricas

Tipos de instância do Amazon EC2