Versão 1.1. Esta versão não é mais compatível, conforme descrito na Política de suporte da versão do Anthos. Para ver os patches e as atualizações mais recentes sobre vulnerabilidades de segurança, exposições e problemas que afetam os clusters do Anthos no VMware (GKE On-Prem), faça o upgrade para uma versão compatível. Você pode encontrar a versão mais recente neste link.

Versões disponíveis

Como usar a geração de registros e o monitoramento

Nesta página, explicamos como usar o Stackdriver, o Prometheus e o Grafana para a geração de registros e o monitoramento. Consulte Visão geral do Logging e do Monitoring para ver um resumo das opções de configuração disponíveis.

Como usar o Stackdriver

As seções a seguir explicam como usar o Stackdriver com clusters do GKE On-Prem.

Recursos monitorados

Os recursos monitorados são a forma como o Google representa recursos, como clusters, nós, pods e contêineres. Para saber mais, consulte a documentação Tipos de recursos monitorados do Cloud Monitoring.

Para consultar registros e métricas, você precisa conhecer pelo menos estes rótulos de recursos:

project_id: ID do projeto associado ao cluster do GKE On-Prem.
location: uma região do GCP em que você quer armazenar registros do Stackdriver. É uma boa ideia escolher uma região próxima ao seu data center local. Você forneceu esse valor durante a instalação.
cluster_name: nome do cluster que você escolheu quando criou o cluster.

É possível recuperar o valor cluster_name do administrador ou do cluster de usuário inspecionando o recurso personalizado do Stackdriver:
```
  kubectl -n kube-system get stackdrivers stackdriver -o yaml | grep 'clusterName:'
```

Como acessar dados de registro

É possível acessar registros usando o Explorador de registros no console do Google Cloud. Por exemplo, para acessar os registros de um contêiner:

Abra o Visualizador de registros do seu projeto no console do Google Cloud.
Encontre registros de um contêiner da seguinte maneira:
1. Clique na caixa suspensa do catálogo de registros no canto superior esquerdo e selecione Contêiner do Kubernetes.
2. Selecione o nome do cluster, o namespace e um contêiner da hierarquia.

Como acessar dados de métricas

É possível escolher entre mais de 3.000 métricas usando o Metrics Explorer. Para acessar o Metrics Explorer, siga estas etapas:

No Console do Google Cloud, selecione Monitoring ou use o seguinte botão:

Acessar Monitoring
Selecione Recursos > Metrics Explorer.

Como acessar metadados do Stackdriver

Os metadados são usados indiretamente por meio de métricas. Ao filtrar por métricas no Stackdriver Metrics Explorer, você verá opções para filtrar métricas por metadata.systemLabels e metadata.userLabels. Os rótulos do sistema são como nome do nó e nome do serviço para pods. Os rótulos de usuário são atribuídos a pods nos arquivos YAML do Kubernetes na seção "metadados" da especificação do pod.

Prometheus e Grafana

Nas seções a seguir, explicamos como usar o Prometheus e o Grafana com clusters do GKE On-Prem.

Como acessar métricas de monitoramento nos painéis do Grafana

O Grafana exibe métricas coletadas dos clusters. Para visualizar essas métricas, acesse os painéis do Grafana:

Receba o nome do pod do Grafana em execução no namespace kube-system de um cluster de usuário:
```
kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] -n kube-system get pods
```
em que [USER_CLUSTER_KUBECONFIG] é o arquivo kubeconfig do cluster de usuário.
O contêiner no pod do Grafana detecta atividade na porta TCP 3000. Encaminhe uma porta local para a porta 3000 no pod a fim de visualizar os painéis do Grafana em um navegador da Web.

Por exemplo, suponha que o nome do pod seja grafana-0. Para encaminhar a porta 50000 para a porta 3000 no pod, digite este comando:
```
kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] -n kube-system port-forward grafana-0 50000:3000
```
Em um navegador da Web, acesse http://localhost:50000. O painel inicial do Grafana do cluster de usuário será carregado.
Para acessar outros painéis, clique no menu suspenso Página inicial no canto superior esquerdo da página.

Para um exemplo de uso do Grafana, consulte Criar um painel do Grafana.

Como acessar alertas

O Prometheus Alertmanager coleta alertas do servidor do Prometheus. É possível ver esses alertas em um painel do Grafana. Para ver os alertas, acesse o painel:

O contêiner no pod alertmanger-0 detecta atividade na porta TCP 9093. Encaminhe uma porta local para a porta 9093 no pod:
```
kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] port-forward \
   -n kube-system alertmanager-0 50001:9093
```
Em um navegador da Web, acesse http://localhost:50001.

Como alterar a configuração do Prometheus Alertmanager

É possível alterar a configuração padrão do Prometheus Alertmanager editando o arquivo monitoring.yaml do cluster de usuário. Faça isso se quiser direcionar alertas para um destino específico, em vez de mantê-los no painel. Saiba como configurar o Alertmanager na documentação de Configuração do Prometheus.

Para alterar a configuração do Alertmanager, execute as seguintes etapas:

Faça uma cópia do arquivo de manifesto monitoring.yaml do cluster de usuário:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] -n kube-system \
   get monitoring monitoring-sample -o yaml > monitoring.yaml

Para configurar o Alertmanager, faça alterações nos campos em spec.alertmanager.yml. Quando terminar, salve o manifesto alterado.

Aplique o manifesto ao cluster:

kubectl apply --kubeconfig [USER_CLUSTER_KUBECONIFG] -f monitoring.yaml

Como escalonar recursos do Prometheus

A configuração de monitoramento padrão é compatível com até cinco nós. Para clusters maiores, é possível ajustar os recursos do servidor do Prometheus. A recomendação é de 50 milhões de núcleos de CPU e 500 Mi de memória por nó de cluster. Verifique se o cluster contém dois nós, cada um com recursos suficientes para caber no Prometheus. Para mais informações, consulte Como redimensionar um cluster de usuário.

Para alterar os recursos do servidor do Prometheus, execute as seguintes etapas:

Faça uma cópia do arquivo de manifesto monitoring.yaml do cluster de usuário:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] -n kube-system get monitoring monitoring-sample -o yaml > monitoring.yaml

Para modificar recursos, faça alterações nos campos em spec.resourceOverride. Quando terminar, salve o manifesto alterado. Exemplo:

spec:
  resourceOverride:
  - component: Prometheus
    resources:
      requests:
        cpu: 300m
        memory: 3000Mi
      limits:
        cpu: 300m
        memory: 3000Mi

Aplique o manifesto ao cluster:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] apply -f monitoring.yaml

Criar um painel do Grafana

Você implantou um aplicativo que expõe uma métrica, verificou se ela foi exposta e verificou se o Prometheus extrai a métrica. Agora é possível adicionar a métrica no nível do aplicativo a um painel personalizado do Grafana.

Para criar um painel do Grafana, siga estas etapas:

Se necessário, tenha acesso ao Grafana.
No painel inicial, clique no menu suspenso Início no canto superior esquerdo da página.
No menu lateral direito, clique em Novo painel.
Na seção Novo painel, clique em Gráfico. Um painel de gráfico vazio é exibido.
Clique em Título do painel e, depois, em Editar. O painel inferior Gráfico é aberto na guia Métricas.
No menu suspenso Fonte de dados, selecione usuário. Clique em Adicionar consulta e insira foo no campo pesquisa.
Clique no botão Voltar para o painel no canto superior direito da tela. O painel é exibido.
Para salvar o painel, clique em Salvar painel no canto superior direito da tela. Escolha um nome para o painel e clique em Salvar.

Como desativar o monitoramento no cluster

Para desativar o monitoramento no cluster, digite o seguinte comando:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] -n kube-system delete monitoring monitoring-sample

Exemplo: como adicionar métricas no nível do aplicativo a um painel do Grafana

As seções a seguir explicam como adicionar métricas em um aplicativo. Nesta seção, você concluirá as seguintes tarefas:

Implantar um aplicativo de exemplo que exponha uma métrica chamada foo.
Verificar se o Prometheus expõe e extrai a métrica.
Criar um painel personalizado do Grafana.

Implantar o aplicativo de exemplo

O aplicativo de exemplo é executado em um único pod. O contêiner do pod expõe uma métrica, foo, com um valor constante de 40.

Crie o seguinte manifesto do pod, pro-pod.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: prometheus-example
  annotations:
    prometheus.io/scrape: 'true'
    prometheus.io/port: '8080'
    prometheus.io/path: '/metrics'
spec:
  containers:
  - image: k8s.gcr.io/prometheus-dummy-exporter:v0.1.0
    name: prometheus-example
    command:
    - /bin/sh
    - -c
    - ./prometheus_dummy_exporter --metric-name=foo --metric-value=40 --port=8080

Em seguida, aplique o manifesto do pod ao cluster de usuário:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] apply -f pro-pod.yaml

Verificar se a métrica foi exposta e extraída

O contêiner no pod prometheus-example detecta atividade na porta TCP 8080. Encaminhe uma porta local para a porta 8080 no pod:
```
kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] port-forward prometheus-example 50002:8080
```
Para verificar se o aplicativo expõe a métrica, execute o seguinte comando:
```
curl localhost:50002/metrics | grep foo
```
O comando retorna a seguinte saída:
```
# HELP foo Custom metric
# TYPE foo gauge
foo 40
```
O contêiner no pod prometheus-0 detecta atividade na porta TCP 9090. Encaminhe uma porta local para a porta 9090 no pod:
```
kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] port-forward prometheus-0 50003:9090
```
Para verificar se o Prometheus está extraindo a métrica, acesse http://localhost:50003/targets, que levará você ao pod prometheus-0 no grupo de destino prometheus-io-pods.
Para visualizar métricas no Prometheus, acesse http://localhost:50003/graph. No campo pesquisa, digite foo e clique em Executar. A página deve exibir a métrica.