Uma nova versão dos clusters do Anthos na AWS (GKE na AWS) foi lançada em 29 de setembro. Consulte as Notas de lançamento para mais informações.

Como configurar a geração de registros e monitorar clusters do Anthos na AWS

Neste tópico, mostramos como exportar registros e métricas de clusters do Anthos no cluster de usuário da AWS para o Cloud Logging e o Cloud Monitoring.

Visão geral

Há várias opções para gerar registros e monitorar com os clusters do Anthos na AWS. O Anthos pode ser integrado ao Cloud Logging e ao Cloud Monitoring. Como o Anthos é baseado no Kubernetes de código aberto, muitas ferramentas de código aberto e de terceiros são compatíveis.

Opções de geração de registros e monitoramento

Há várias opções de geração de registros e monitoramento para clusters do Anthos:

  1. Implantar os agentes do Cloud Logging e do Cloud Monitoring para monitorar e visualizar registros das cargas de trabalho no Console do Google Cloud. Este tópico explica essa solução.

  2. Usar ferramentas de código aberto, como Prometheus, Grafana e Elasticsearch. Este tópico não descreve essa solução.

  3. Usar soluções de terceiros, como o Datadog. Este tópico não descreve essa solução.

Cloud Logging e Cloud Monitoring

Com o Anthos, o Cloud Logging e o Cloud Monitoring, é possível criar painéis, enviar alertas, monitorar e analisar registros das cargas de trabalho em execução no cluster. É necessário configurar os agentes do Cloud Logging e do Cloud Monitoring para coletar registros e métricas no projeto do Google Cloud. Se você não configurar esses agentes, os clusters do Anthos na AWS não coletarão dados de geração de registros ou de monitoramento.

Quais dados são coletados

Quando configurados, os agentes coletam registros e dados de métricas do cluster e das cargas de trabalho em execução no cluster. Esses dados são armazenados no projeto do Google Cloud. Você configura o ID do projeto no campo project_id em um arquivo de configuração ao instalar o encaminhador de registros.

Os dados coletados incluem o seguinte:

  • Registros de serviços do sistema em cada um dos nós de worker
  • Registros de aplicativo de todas as cargas de trabalho em execução no cluster
  • Métricas dos serviços de cluster e sistema. Para mais informações sobre métricas específicas, consulte Métricas do Anthos.
  • Métricas de aplicativo para pods, caso os aplicativos estejam configurados com destinos de verificação do Prometheus e anotados com aconfiguração que inclua prometheus.io/scrape, prometheus.io/path e prometheus.io/port.

Os agentes podem ser desativados a qualquer momento. Para mais informações, consulte Como fazer a limpeza. Os dados coletados pelos agentes podem ser gerenciados e excluídos como qualquer outra métrica e dados de registro, conforme descrito na documentação do Cloud Monitoring e do Cloud Logging.

Os dados de registro são armazenados de acordo com as configurações das regras de retenção. A retenção de dados de métricas varia de acordo com o tipo.

Componentes da geração de registros e monitoramento

Para exportar a telemetria no nível do cluster dos clusters do Anthos na AWS para o Google Cloud, implante os seguintes componentes no cluster:

  • Stackdriver Log Forwarder (stackdriver-log-forwarder-*): um DaemonSet do Fluentbit que encaminha registros de cada nó do Kubernetes para o Cloud Logging.
  • Agente de métricas do GKE (gke-metrics-agent-*): um DaemonSet baseado no OpenTelemetry Collector, que coleta dados de métricas e os encaminha para o Cloud Monitoring.

Os manifestos desses componentes estão no repositório anthos-samples no GitHub.

Pré-requisitos

  1. Ter um projeto do Google Cloud com o faturamento ativado. Para mais informações sobre custos, consulte Preços do pacote de operações do Google Cloud.

    O projeto também precisa ter as APIs Cloud Logging e Cloud Monitoring ativadas. Para ativar as APIs, execute os seguintes comandos:

    gcloud services enable logging.googleapis.com
    gcloud services enable monitoring.googleapis.com
    
  2. Clusters do Anthos no ambiente da AWS, incluindo um cluster de usuário registrado no Connect Execute o seguinte comando para verificar se o cluster está registrado.

    gcloud container hub memberships list
    

    Se o cluster estiver registrado, o SDK do Cloud imprime o nome e o ID do cluster.

    NAME       EXTERNAL_ID
    cluster-0  1abcdef-1234-4266-90ab-123456abcdef
    

    Se o cluster não estiver listado, consulte Como se conectar a um cluster com o Connect.

  3. Instale a ferramenta de linha de comando git na sua máquina.

Como configurar permissões para o pacote de operações do Google Cloud

Os agentes de geração de registros e monitoramento usam a identidade da carga de trabalho da frota para se comunicar com o Cloud Logging e o Cloud Monitoring. A identidade precisa de permissões para gravar registros e métricas no projeto. Para adicionar as permissões, execute os seguintes comandos:

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:PROJECT_ID.svc.id.goog[kube-system/stackdriver]" \
  --role=roles/logging.logWriter
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:PROJECT_ID.svc.id.goog[kube-system/stackdriver]" \
  --role=roles/monitoring.metricWriter

Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

Conectar-se ao Bastion Host

Para se conectar aos clusters do Anthos nos recursos da AWS, siga as etapas a seguir. Selecione se você tem uma VPC atual da AWS (ou conexão direta com a VPC) ou criou uma VPC dedicada ao criar seu serviço de gerenciamento.

VPC atual

Se você tiver uma conexão direta ou VPN com uma VPC atual, omita a linha env HTTP_PROXY=http://localhost:8118 dos comandos neste tópico.

VPC dedicada

Quando você cria um serviço de gerenciamento em uma VPC dedicada, o GKE na AWS inclui um bastion host em uma sub-rede pública.

Para se conectar ao serviço de gerenciamento, siga estas etapas:

  1. Mude para o diretório com os clusters do Anthos na configuração da AWS. Você criou esse diretório ao instalar o serviço de gerenciamento.

    cd anthos-aws

  2. Para abrir o túnel, execute o script bastion-tunnel.sh. O túnel encaminha para localhost:8118.

    Para abrir um túnel para o Bastion Host, execute o seguinte comando:

    ./bastion-tunnel.sh -N
    

    As mensagens do túnel SSH aparecem nessa janela. Quando estiver pronto para fechar a conexão, interrompa o processo usando Control+C ou fechando a janela.

  3. Abra um novo terminal e mude para o diretório anthos-aws.

    cd anthos-aws
  4. Verifique se você consegue se conectar ao cluster com kubectl.

    env HTTPS_PROXY=http://localhost:8118 \
    kubectl cluster-info
    

    A saída inclui o URL do servidor da API de serviço de gerenciamento.

Cloud Logging e Cloud Monitoring nos nós do plano de controle

Com clusters do Anthos na AWS 1.8.0 e posterior, o Cloud Logging e o Cloud Monitoring para nós do plano de controle podem ser configurados automaticamente ao criar novos clusters de usuário. Para ativar o Cloud Logging ou o Cloud Monitoring, preencha a seção controlPlane.cloudOperations da configuração AWSCluster.

cloudOperations:
  projectID: PROJECT_ID
  location: GC_REGION
  enableLogging: ENABLE_LOGGING
  enableMonitoring: ENABLE_MONITORING

Substitua:

  • PROJECT_ID: o ID do projeto.
  • GC_REGION: a região do Google Cloud em que você quer armazenar os registros. Escolha uma região próxima à região da AWS. Para mais informações, consulte Locais globais: regiões e zonas. Por exemplo, us-central1.
  • ENABLE_LOGGING: true ou false, se o Cloud Logging está ativado nos nós do plano de controle.
  • ENABLE_MONITORING: true ou false, se o Cloud Monitoring está ativado nos nós do plano de controle.

Em seguida, siga as etapas em Como criar um cluster de usuário personalizado.

Cloud Logging e Cloud Monitoring em nós de trabalho

Como remover a versão anterior

Se você tiver configurado uma versão anterior dos agentes de geração de registros e monitoramento que inclui stackdriver-log-aggregator (Fluentd) e stackdriver-prometheus-k8s (Prometheus), talvez seja necessário desinstalá-los antes de prosseguir.

Como instalar o encaminhador de registros

Nesta seção, você instalará o Encaminhador de registros do Stackdriver no cluster.

  1. No diretório anthos-samples/aws-logging-monitoring/, mude para o diretório logging/.

    cd logging/
    
  2. Altere o arquivo forwarder.yaml para corresponder à configuração do projeto:

    sed -i "s/PROJECT_ID/PROJECT_ID/g" forwarder.yaml
    sed -i "s/CLUSTER_NAME/CLUSTER_NAME/g" forwarder.yaml
    sed -i "s/CLUSTER_LOCATION/GC_REGION/g" forwarder.yaml
    

    Substitua:

    • PROJECT_ID: o ID do projeto.
    • CLUSTER_NAME: o nome do cluster. Por exemplo, cluster-0.
    • GC_REGION: a região do Google Cloud em que você quer armazenar os registros. Escolha uma região próxima à região da AWS. Para mais informações, consulte Locais globais: regiões e zonas. Por exemplo, us-central1.
  3. (Opcional) Com base nas cargas de trabalho, no número de nós no cluster e no número de pods por nó, talvez seja necessário definir solicitações de recursos de CPU e memória. Para mais informações, consulte Alocações recomendadas de CPU e memória.

  4. No diretório anthos-aws, use anthos-gke para alternar o contexto para o cluster de usuário.

    cd anthos-aws
    env HTTPS_PROXY=http://localhost:8118 \
      anthos-gke aws clusters get-credentials CLUSTER_NAME
    Substitua CLUSTER_NAME pelo nome do cluster de usuários.

  5. Crie a conta de serviço stackdriver se ela não existir e implante o encaminhador de registro no cluster.

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl create serviceaccount stackdriver -n kube-system
    env HTTPS_PROXY=http://localhost:8118 \
      kubectl apply -f forwarder.yaml
    
  6. Use kubectl para verificar se os pods foram iniciados.

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl get pods -n kube-system | grep stackdriver-log
    

    Você verá um pod de encaminhador por nó em um pool de nós. Por exemplo, em um cluster de seis nós, você verá seis pods de encaminhador.

    stackdriver-log-forwarder-2vlxb              2/2     Running   0          21s
    stackdriver-log-forwarder-dwgb7              2/2     Running   0          21s
    stackdriver-log-forwarder-rfrdk              2/2     Running   0          21s
    stackdriver-log-forwarder-sqz7b              2/2     Running   0          21s
    stackdriver-log-forwarder-w4dhn              2/2     Running   0          21s
    stackdriver-log-forwarder-wrfg4              2/2     Running   0          21s
    

Como testar o encaminhamento de registro

Nesta seção, você implanta uma carga de trabalho que contém um servidor da Web HTTP básico com um gerador de carga no cluster. Em seguida, você testa se os registros estão presentes no Cloud Logging.

Antes de instalar essa carga de trabalho, é possível verificar os manifestos do servidor da Web e do gerador de carga.

  1. Implante o servidor da Web e o gerador de carga no cluster.

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl apply -f  https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/server/server.yaml
    env HTTPS_PROXY=http://localhost:8118 \
      kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/loadgen/loadgen.yaml
    
  2. Para verificar se você consegue ver os registros do cluster no painel do Cloud Logging, acesse o explorador de registros no Console do Google Cloud:

    Acessar o Explorador de registros

  3. Copie a consulta de amostra abaixo no campo Criador de consultas.

    resource.type="k8s_container" resource.labels.cluster_name="CLUSTER_NAME"
    

    Substitua CLUSTER_NAME pelo nome do seu cluster.

  4. Clique em Run query. Os registros recentes do cluster aparecerão em Resultados da consulta.

    Registros do cluster no pacote de operações do Google Cloud

  5. Depois de confirmar que os registros aparecem nos resultados da consulta, remova o gerador de carga e o servidor da Web.

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/loadgen/loadgen.yaml
    
    env HTTPS_PROXY=http://localhost:8118 \
      kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/server/server.yaml
    

Como instalar o coletor de métricas

Nesta seção, você instala um agente para enviar dados ao Cloud Monitoring.

  1. No diretório anthos-samples/aws-logging-monitoring/logging/, mude para o diretório anthos-samples/aws-logging-monitoring/monitoring/.

    cd ../monitoring
    
  2. Altere o arquivo gke-metrics-agent.yaml para corresponder à configuração do projeto:

    sed -i "s/PROJECT_ID/PROJECT_ID/g" gke-metrics-agent.yaml
    sed -i "s/CLUSTER_NAME/CLUSTER_NAME/g" gke-metrics-agent.yaml
    sed -i "s/CLUSTER_LOCATION/GC_REGION/g" gke-metrics-agent.yaml
    

    Substitua:

    • PROJECT_ID: o ID do projeto.
    • CLUSTER_NAME: o nome do cluster. Por exemplo, cluster-0.
    • GC_REGION: a região do Google Cloud em que você quer armazenar os registros. Escolha uma região próxima à região da AWS. Para mais informações, consulte Locais globais: regiões e zonas. Por exemplo, us-central1.
  3. (Opcional) Com base nas cargas de trabalho, no número de nós no cluster e no número de pods por nó, talvez seja necessário definir solicitações de recursos de CPU e memória. Para mais informações, consulte Alocações recomendadas de CPU e memória.

  4. Se ainda não houver uma conta de serviço stackdriver, crie uma e implante o agente de métricas no cluster.

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl create serviceaccount stackdriver -n kube-system
    env HTTPS_PROXY=http://localhost:8118 \
      kubectl apply -f gke-metrics-agent.yaml
    
  5. Use a ferramenta kubectl para verificar se o pod gke-metrics-agent está em execução.

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl get pods -n kube-system | grep gke-metrics-agent
    

    Você verá um pod do agente por nó em um pool de nós. Por exemplo, em um cluster de três nós, você verá três pods de agente.

    gke-metrics-agent-gjxdj                    2/2     Running   0          102s
    gke-metrics-agent-lrnzl                    2/2     Running   0          102s
    gke-metrics-agent-s6p47                    2/2     Running   0          102s
    
  6. Para verificar se as métricas do cluster estão sendo exportadas para o Cloud Monitoring, acesse o Metrics Explorer no Console do Google Cloud:

    Acessar o Metrics Explorer

  7. No Metrics Explorer, clique em Editor de consultas e copie o seguinte comando:

    fetch k8s_container
    | metric 'kubernetes.io/anthos/otelcol_exporter_sent_metric_points'
    | filter
        resource.project_id == 'PROJECT_ID'
        && (resource.cluster_name =='CLUSTER_NAME')
    | align rate(1m)
    | every 1m
    

    Substitua:

  8. Clique em Run query. A taxa de pontos métricos enviados ao Cloud Monitoring de cada pod gke-metrics-agent no cluster é exibida.

    Como monitorar o cluster

    Algumas outras métricas que vale a pena tentar são as seguintes:

    • kubernetes.io/anthos/container_memory_working_set_bytes: uso da memória do contêiner;
    • kubernetes.io/anthos/container_cpu_usage_seconds_total: uso de CPU do contêiner;
    • kubernetes.io/anthos/apiserver_aggregated_request_total: contagem de solicitações kube-apiserver, disponível apenas se o Cloud Monitoring estiver ativado no plano de controle.

    Para uma lista completa das métricas disponíveis, consulte Métricas do Anthos. Para mais informações sobre como usar a interface do usuário, consulte Metrics Explorer.

Como criar um painel no Cloud Monitoring

Nesta seção, você criará um painel do Cloud Monitoring que monitora o status do contêiner no cluster.

  1. No diretório anthos-samples/aws-logging-monitoring/monitoring/, mude para o diretório anthos-samples/aws-logging-monitoring/monitoring/dashboards.

    cd dashboards
    
  2. Substitua as instâncias da string CLUSTER_NAME em pod-status.json pelo nome do cluster.

    sed -i "s/CLUSTER_NAME/CLUSTER_NAME/g" pod-status.json
    

    Substitua CLUSTER_NAME pelo nome do seu cluster.

  3. Crie um painel personalizado com o arquivo de configuração executando o seguinte comando:

    gcloud monitoring dashboards create --config-from-file=pod-status.json
    
  4. Para verificar se o painel foi criado, acesse os painéis do Cloud Monitoring no Console do Google Cloud.

    Ir para "Painéis"

    Abra o painel recém-criado com um nome no formato CLUSTER_NAME (Anthos cluster on AWS) pod status.

Limpeza

Nesta seção, você remove os componentes de geração de registros e monitoramento do cluster.

  1. Exclua o painel de monitoramento na visualização em lista dos painéis no Console do Google Cloud clicando no botão de exclusão associado ao nome do painel.

  2. Mude para o diretório anthos-samples/aws-logging-monitoring/.

    cd anthos-samples/aws-logging-monitoring
    
  3. Para remover todos os recursos criados neste guia, execute os seguintes comandos:

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl delete -f logging/
    env HTTPS_PROXY=http://localhost:8118 \
      kubectl delete -f monitoring/
    

Alocações de CPU e memória recomendadas

Esta seção inclui alocações recomendadas de CPU e memória para os componentes individuais usados na geração de registros e no monitoramento. Cada uma das tabelas a seguir lista solicitações de CPU e memória para um cluster com um intervalo de tamanhos de nó. Você define as solicitações de recursos para um componente no arquivo listado na tabela.

Para mais informações, consulte Práticas recomendadas do Kubernetes: solicitações de recursos e limites e Como gerenciar recursos de contêineres.

1 a 10 nós

arquivo Recurso Solicitações de CPU Limites de CPU Solicitações de memória Limites de memória
monitoring/gke-metrics-agent.yaml gke-metrics-agent 30 m 100 m 50 Mi 500 Mi
logging/forwarder.yaml stackdriver-log-forwarder 50 m 100 m 100 Mi 600 Mi

10 a 100 nós

arquivo Recurso Solicitações de CPU Limites de CPU Solicitações de memória Limites de memória
monitoring/gke-metrics-agent.yaml gke-metrics-agent 50 m 100 m 50 Mi 500 Mi
logging/forwarder.yaml stackdriver-log-forwarder 60m 100 m 100 Mi 600 Mi

Mais de 100 nós

Arquivo Recurso Solicitações de CPU Limites de CPU Solicitações de memória Limites de memória
monitoring/gke-metrics-agent.yaml gke-metrics-agent 50 m 100 m 100 Mi N/A
logging/forwarder.yaml stackdriver-log-forwarder 60m 100 m 100 Mi 600 Mi

A seguir

Saiba mais sobre o Cloud Logging:

Saiba mais sobre o Cloud Monitoring: