O produto descrito nesta documentação, os clusters do Anthos na AWS (geração anterior), agora está no modo de manutenção. Todas as novas instalações precisam usar o produto de geração atual Clusters do Anthos na AWS.

Como gerar 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:

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.
Usar ferramentas de código aberto, como Prometheus, Grafana e Elasticsearch. Este tópico não descreve essa solução.
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

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
```
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 fleet memberships list
```
Se o cluster estiver registrado, a Google Cloud CLI imprimirá o nome e o ID dele.
```
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.
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:

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
```
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.
Abra um novo terminal e mude para o diretório anthos-aws.
```
cd anthos-aws
```
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.

Clique para ver comandos para desinstalar a versão anterior.

    kubectl delete -n kube-system statefulset stackdriver-log-aggregator
    kubectl delete -n kube-system configmap stackdriver-log-aggregator-input-config
    kubectl delete -n kube-system configmap stackdriver-log-aggregator-output-config
    kubectl delete -n kube-system networkpolicy stackdriver-log-aggregator-in-forward
    kubectl delete -n kube-system networkpolicy stackdriver-log-aggregator-prometheus-scrape
    kubectl delete -n kube-system serviceaccount stackdriver-log-aggregator
    kubectl delete -n kube-system service stackdriver-log-aggregator-in-forward
    kubectl delete -n kube-system statefulset stackdriver-prometheus-k8s
    kubectl delete -n kube-system service stackdriver-prometheus-k8s
    kubectl delete -n kube-system secret stackdriver-prometheus-scrape
    kubectl delete -n kube-system clusterrolebinding stackdriver-prometheus-scrape
    kubectl delete -n kube-system clusterrole stackdriver-prometheus-scrape
    kubectl delete -n kube-system serviceaccount stackdriver-prometheus-scrape
    kubectl delete -n kube-system clusterrolebinding stackdriver-user:prometheus
    kubectl delete -n kube-system clusterrole stackdriver-user:prometheus
    kubectl delete -n kube-system serviceaccount stackdriver-prometheus
    kubectl delete -n kube-system configmap stackdriver-prometheus-k8s
    kubectl delete -n kube-system configmap stackdriver-prometheus-sidecar-config
    kubectl delete -n kube-system pvc/stackdriver-log-aggregator-persistent-volume-claim-stackdriver-log-aggregator-0
    kubectl delete -n kube-system pvc/stackdriver-log-aggregator-persistent-volume-claim-stackdriver-log-aggregator-1
    kubectl delete -n kube-system pvc/stackdriver-prometheus-data-stackdriver-prometheus-k8s-0
    kubectl delete secret google-cloud-credentials -n kube-system

Como instalar o encaminhador de registros

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

No diretório anthos-samples/aws-logging-monitoring/, mude para o diretório logging/.
```
cd logging/
```
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.
(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.
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.

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

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.

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

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
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.
Clique em Run query. Os registros recentes do cluster aparecerão em Resultados da consulta.

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.

No diretório anthos-samples/aws-logging-monitoring/logging/, mude para o diretório anthos-samples/aws-logging-monitoring/monitoring/.
```
cd ../monitoring
```
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.
(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.

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

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

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
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:
- PROJECT_ID: o ID do projeto.
- CLUSTER_NAME: o nome do cluster que você usou ao criar um cluster de usuário. Por exemplo, cluster-0.
Clique em Run query. A taxa de pontos métricos enviados ao Cloud Monitoring de cada pod gke-metrics-agent no cluster é exibida.

Observação: talvez demore vários minutos até que as métricas fiquem visíveis no Metrics Explorer.

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.

No diretório anthos-samples/aws-logging-monitoring/monitoring/, mude para o diretório anthos-samples/aws-logging-monitoring/monitoring/dashboards.
```
cd dashboards
```
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.
Crie um painel personalizado com o arquivo de configuração executando o seguinte comando:
```
gcloud monitoring dashboards create --config-from-file=pod-status.json
```
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.

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.
Mude para o diretório anthos-samples/aws-logging-monitoring/.
```
cd anthos-samples/aws-logging-monitoring
```

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