Como personalizar registros do Cloud Logging para o Google Kubernetes Engine com Fluentd

Neste tutorial, você verá como personalizar a geração de registros do Fluentd (em inglês) em um cluster do Google Kubernetes Engine. Você aprenderá a hospedar o próprio daemonset configurável do Fluentd para enviar registros ao Cloud Logging, em vez de selecionar a opção de geração de registros em nuvem ao criar o cluster do Google Kubernetes Engine (GKE), que não permite a configuração do daemon do Fluentd.

Objetivos

• Implantar o próprio daemonset do Fluentd em um cluster do Google Kubernetes Engine configurado para registrar dados no Cloud Logging (em inglês). Supomos que você já esteja familiarizado com o Kubernetes.
• Personalizar a geração de registros do GKE para remover dados confidenciais dos registros do Cloud Logging.
• Personalizar a geração de registros do GKE para adicionar eventos no nível do nó aos registros do Cloud Logging.

Custos

Neste tutorial, usamos componentes do Cloud Platform que podem ser cobrados, incluindo:

• um cluster do Google Kubernetes Engine com três nós.

A Calculadora de preços estima o custo desse ambiente em cerca de US$ 1,14 por 8 horas.

Antes de começar

1. Faça login na sua conta do Google.

   Se você ainda não tiver uma, inscreva-se.

2. No Console do Cloud, na página do seletor de projetos, selecione ou crie um projeto do Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar a página do seletor de projetos

3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud. Saiba como confirmar se a cobrança está ativada para o seu projeto.

4. Ative as APIs Google Kubernetes Engine, Compute Engine.

   Ative as APIs

Como inicializar variáveis comuns

É preciso definir diversas variáveis que controlam onde os elementos da infraestrutura serão implantados.

1. Em um editor de texto, edite o script a seguir, substituindo [YOUR_PROJECT_ID] pelo código do projeto. O script define a região como us-east-1. Se você fizer alguma alteração no script, verifique se os valores de zona referenciam a região especificada.

   region=us-east1
   zone=${region}-b
   project_id=[YOUR_PROJECT_ID]
   

2. Acesse o Cloud Shell.

   Abrir o Cloud Shell

3. Copie o script na janela do Cloud Shell e execute-o.

4. Execute os seguintes comandos para definir a zona padrão e o ID do projeto. Dessa maneira, você não precisa especificar esses valores em cada comando subsequente:

   gcloud config set compute/zone ${zone}
   gcloud config set project ${project_id}
   

Como criar o cluster do GKE

A menos que seja observado o contrário, você insere todos os comandos deste tutorial na linha de comando do computador ou no Cloud Shell.

1. Clone o repositório de amostra. O repositório de amostra inclui os manifestos do Kubernetes referentes ao demonset do Fluentd e um programa de geração de registros de teste que você implantará:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-customize-fluentd
   

2. Altere o diretório de trabalho para o repositório clonado:

   cd kubernetes-engine-customize-fluentd
   

3. Crie o cluster do GKE com o registro somente do sistema ativado:

   gcloud beta container clusters create gke-with-custom-fluentd \
      --zone us-east1-b \
      --enable-logging-monitoring-system-only \
      --tags=gke-cluster-with-customized-fluentd \
      --scopes=logging-write
   

Como implantar o aplicativo de teste que gera registros

Por padrão, o aplicativo de amostra que você implanta emite log statements aleatórios continuamente. O contêiner do Docker que ele usa está disponível em gcr.io/cloud-solutions-images/test-logger e o código-fonte dele está incluído no subdiretório test-logger.

1. Implante o aplicativo test-logger no cluster do GKE:

   kubectl apply -f kubernetes/test-logger.yaml
   

2. Visualize o status dos pods test-logger:

   kubectl get pods
   

3. Repita esse comando até que a resposta tenha a seguinte aparência, com todos os três pods test-logger em execução:

   

Como implantar o daemonset do Fluentd no cluster

Em seguida, você fará a configuração e a implantação do daemonset do Fluentd.

Observação: como você ativou a geração de registros somente do sistema, um daemonset do Fluentd gerenciado pelo GKE foi implantado e é responsável pelos registros do sistema. Os manifestos do Kubernetes para o Fluentd que você implanta neste procedimento são versões modificadas daquelas que estão disponíveis no site do Kubernetes para geração de registros com o Cloud Logging e como monitorar as alterações em arquivos de registro do Docker.

1. Implante a configuração do Fluentd:

   kubectl apply -f kubernetes/fluentd-configmap.yaml
   

2. Implante o daemonset do Fluentd:

   kubectl apply -f kubernetes/fluentd-daemonset.yaml
   

3. Verifique se os pods do Fluentd foram iniciados:

   kubectl get pods --namespace=kube-system
   

   Se eles estiverem funcionando, você verá uma resposta como a seguinte:

   

4. Confirme se você vê registros no Logging. No console, no lado esquerdo, selecione Logging > Visualizador de registros e selecione Kubernetes Container como um tipo de recurso na lista Recurso.

5. Clique em Run.

6. No Explorador de campo de registros, selecione test-logger para CONTAINER_NAME:

   

Como filtrar informações do arquivo de registro

A próxima etapa é especificar que o Fluentd precisa filtrar determinados dados, de maneira que eles não sejam registrados. Para este tutorial, você filtra os CPFs ou os CNPJs, os números de cartão de crédito e os endereços de e-mail. Para fazer essa atualização, você altera o daemonset para usar um ConfigMap diferente que contém esses filtros. Você usa o recurso de atualizações contínuas do Kubernetes e preserva a versão anterior do ConfigMap.

1. Abra o arquivo kubernetes/fluentd-configmap.yaml em um editor.

2. Remova a marca de comentário das linhas e não inclua as linhas ### sample log scrubbing filters e ### end sample log scrubbing filters:

   kubernetes/fluentd-configmap.yaml

   Ver no GitHub

   ############################################################################################################
   #  ### sample log scrubbing filters
   #  #replace social security numbers
   # <filter reform.**>
   #   @type record_transformer
   #   enable_ruby true
   #   <record>
   #     log ${record["log"].gsub(/[0-9]{3}-*[0-9]{2}-*[0-9]{4}/,"xxx-xx-xxxx")}
   #   </record>
   # </filter>
   # # replace credit card numbers that appear in the logs
   # <filter reform.**>
   #   @type record_transformer
   #   enable_ruby true
   #   <record>
   #      log ${record["log"].gsub(/[0-9]{4} *[0-9]{4} *[0-9]{4} *[0-9]{4}/,"xxxx xxxx xxxx xxxx")}
   #   </record>
   # </filter>
   # # replace email addresses that appear in the logs
   # <filter reform.**>
   #   @type record_transformer
   #   enable_ruby true
   #   <record>
   #     log ${record["log"].gsub(/[\w+\-]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+/i,"[e-mail]")}
   #   </record>
   # </filter>
   # ### end sample log scrubbing filters
   #############################################################################################################

3. Altere o nome do ConfigMap de fluentd-gcp-config para fluentd-gcp-config-filtered editando o campo metadata.name:

   kubernetes/fluentd-configmap.yaml

   Ver no GitHub

   name: fluentd-gcp-config
   namespace: kube-system
   labels:
     k8s-app: fluentd-gcp-custom

4. Salve e feche o arquivo.

Como atualizar o daemonset do Fluentd para usar a nova configuração

Altere kubernetes/fluentd-daemonset.yaml para ativar o ConfigMap fluentd-gcp-config-filtered, em vez de fluentd-gcp-config.

1. Abra o arquivo kubernetes/fluentd-daemonset.yaml em um editor.

2. Altere o nome do ConfigMap de fluentd-gcp-config para fluentd-gcp-config-filtered editando o campo configMap.name:

   kubernetes/fluentd-daemonset.yaml

   Ver no GitHub

   - configMap:
       defaultMode: 420
       name: fluentd-gcp-config
     name: config-volume

3. Implante a nova versão do ConfigMap no cluster:

   kubectl apply -f kubernetes/fluentd-configmap.yaml
   

4. Implante a nova versão do daemonset:

   kubectl apply -f kubernetes/fluentd-daemonset.yaml

5. Implante a atualização e aguarde até ser concluída:

   kubectl rollout status ds/fluentd-gcp-v3.2.0 --namespace=kube-system
   

   

6. Quando a implantação for concluída, atualize os registros do Logging e verifique se os dados de CPF ou CNPJ, número de cartão de crédito e endereço de e-mail foram removidos pelo filtro.

   

Como registrar eventos no nível do nó

Para que os eventos ocorridos nos nós do GKE também sejam mostrados no Logging, adicione as seguintes linhas ao ConfigMap e siga as instruções descritas na última seção:

<source>
  @type systemd
  filters [{ "SYSLOG_IDENTIFIER": "sshd" }]
  pos_file /var/log/journal/gcp-journald-ssh.pos
  read_from_head true
  tag sshd
</source>

<source>
  @type systemd
  filters [{ "SYSLOG_IDENTIFIER": "sudo" }]
  pos_file /var/log/journal/gcp-journald-sudo.pos
  read_from_head true
  tag sudo
</source>

Limpar

Depois que tiver terminado o tutorial, você poderá limpar os recursos criados no GCP para não haver faturamento deles no futuro.

Como excluir o projeto

O jeito mais fácil de evitar cobranças é excluindo o projeto que você criou para o tutorial.

Para excluir o projeto:

Cuidado: excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto atual para seguir este tutorial, a exclusão dele incluirá quaisquer outras ações feitas no projeto.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja explorar vários tutoriais e guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

1. No Console do Cloud, acesse a página Gerenciar recursos:

   Acessar a página "Gerenciar recursos"

2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Como excluir o cluster do GKE

Se você não quiser excluir o projeto todo, execute o seguinte comando para excluir o cluster do GKE:

gcloud container clusters delete gke-with-custom-fluentd --zone us-east1-b

A seguir

• Analise a documentação do Fluentd mais detalhadamente.
• Analise a documentação do Google Kubernetes Engine mais detalhadamente.
• Teste outros recursos do Google Cloud. Veja nossos tutoriais.