Como monitorar o Anthos Config Management

O Anthos Config Management usa o Prometheus para coletar e mostrar métricas relacionadas a seus processos.

Também é possível configurar o Cloud Monitoring para extrair métricas personalizadas do Prometheus. Em seguida, você poderá ver métricas personalizadas no Prometheus e no Monitoring. Para mais informações, consulte Como usar o Prometheus.

Como capturar as métricas

Todas as métricas do Prometheus estão disponíveis para captura na porta 8675. Para analisar as métricas, configure seu cluster para o Prometheus de duas maneiras. Siga uma destas instruções:

Siga a documentação do Prometheus para configurar seu cluster para capturas, ou

Use o operador Prometheus fornecido pelo CoreOS com os manifestos a seguir, que capturarão todas as métricas do Anthos Config Management a cada 10 segundos.

Crie um diretório temporário para conter os arquivos de manifesto.
```
mkdir acm-monitor
cd acm-monitor
```
Faça o download do manifesto do Prometheus Operator no repositório do CoreOS usando o comando curl:
```
curl -o bundle.yaml https://raw.githubusercontent.com/coreos/prometheus-operator/master/bundle.yaml
```
Esse manifesto é configurado para usar o namespace default, o que não é recomendável. A próxima etapa modifica a configuração para usar um namespace chamado monitoring. Para usar um namespace diferente, substitua-o onde houver monitoring nas etapas restantes.

Crie um arquivo para atualizar o namespace do ClusterRoleBinding no pacote acima.

# patch-crb.yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: prometheus-operator
subjects:
- kind: ServiceAccount
  name: prometheus-operator
  namespace: monitoring # we are patching from default namespace

Crie um arquivo kustomization.yaml que aplique o patch e modifique o namespace para outros recursos no manifesto.

# kustomization.yaml
resources:
- bundle.yaml

namespace: monitoring

patchesStrategicMerge:
- patch-crb.yaml

Crie o namespace monitoring: É possível usar um nome diferente para o namespace. Se você fizer isso, altere também o valor de namespace nos manifestos YAML das etapas anteriores.
```
kubectl create namespace monitoring
```
Aplique o manifesto kustomized usando os seguintes comandos:
```
kubectl apply -k .

until kubectl get customresourcedefinitions servicemonitors.monitoring.coreos.com ; \
do date; sleep 1; echo ""; done
```
O segundo comando permanece bloqueado até que os CRDs estejam disponíveis no cluster.

Crie o manifesto para os recursos necessários para configurar um servidor Prometheus que rastreie as métricas do Anthos Config Management.

# acm.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: prometheus-acm
  namespace: monitoring
---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRole
metadata:
  name: prometheus-acm
rules:
- apiGroups: [""]
  resources:
  - nodes
  - services
  - endpoints
  - pods
  verbs: ["get", "list", "watch"]
- apiGroups: [""]
  resources:
  - configmaps
  verbs: ["get"]
- nonResourceURLs: ["/metrics"]
  verbs: ["get"]
---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: prometheus-acm
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: prometheus-acm
subjects:
- kind: ServiceAccount
  name: prometheus-acm
  namespace: monitoring
---
apiVersion: monitoring.coreos.com/v1
kind: Prometheus
metadata:
  name: acm
  namespace: monitoring
  labels:
    prometheus: acm
spec:
  replicas: 2
  serviceAccountName: prometheus-acm
  serviceMonitorSelector:
    matchLabels:
      prometheus: config-management
  podMonitorSelector:
    matchLabels:
      prometheus: config-management
  alerting:
    alertmanagers:
    - namespace: default
      name: alertmanager
      port: web
  resources:
    requests:
      memory: 400Mi
---
apiVersion: v1
kind: Service
metadata:
  name: prometheus-acm
  namespace: monitoring
  labels:
    prometheus: acm
spec:
  type: NodePort
  ports:
  - name: web
    nodePort: 31900
    port: 9190
    protocol: TCP
    targetPort: web
  selector:
    app: prometheus
    prometheus: acm
---
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: acm-service
  namespace: monitoring
  labels:
    prometheus: config-management
spec:
  selector:
    matchLabels:
      monitored: "true"
  namespaceSelector:
    matchNames:
    - config-management-system
  endpoints:
  - port: metrics
    interval: 10s
---
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: cnrm
  namespace: monitoring
  labels:
    prometheus: config-management
spec:
  endpoints:
  - interval: 10s
    port: metrics
  namespaceSelector:
    matchNames:
    - cnrm-system
  selector:
    matchLabels:
      cnrm.cloud.google.com/monitored: "true"
      cnrm.cloud.google.com/system: "true"
---
apiVersion: monitoring.coreos.com/v1
kind: PodMonitor
metadata:
  name: acm-pod
  namespace: monitoring
  labels:
    prometheus: config-management
spec:
  selector:
    matchLabels:
      monitored: "true"
  namespaceSelector:
    matchNames:
    - gatekeeper-system
  podMetricsEndpoints:
  - port: metrics
    interval: 10s

Aplique o manifesto usando os comandos a seguir:
```
kubectl apply -f acm.yaml

until kubectl rollout status statefulset/prometheus-acm -n monitoring; \
do sleep 1; done
```
O segundo comando permanece bloqueado até que os pods estejam em execução.
É possível verificar a instalação encaminhando a porta da Web do servidor do Prometheus para a máquina local.
```
kubectl -n monitoring port-forward svc/prometheus-acm 9190
```
Agora é possível acessar a IU da Web do Prometheus em http://localhost:9190.
Remova o diretório temporário.
```
cd ..
rm -rf acm-monitor
```

Métricas disponíveis

O Anthos Config Management coleta as métricas a seguir e as disponibiliza para o Prometheus. A coluna Rótulos lista todos os rótulos (em inglês) aplicáveis a cada métrica. As métricas sem rótulos representam uma única medida ao longo do tempo, enquanto as métricas com rótulos representam várias medidas, uma para cada combinação de valores de rótulo.

Se essa tabela ficar dessincronizada, filtre as métricas por prefixo na interface do usuário do Prometheus, e todas as métricas começarão com o prefixo gkeconfig_.

Nome	Tipo	Rótulos	Descrição
`gkeconfig_importer_cycle_duration_seconds_bucket`	Histograma	status	Número de ciclos que o importador tentou importar configs para o cluster (distribuído em intervalos pela duração de cada ciclo)
`gkeconfig_importer_cycle_duration_seconds_count`	Histograma	status	Número de ciclos que o importador tentou importar configs para o cluster (ignorando a duração)
`gkeconfig_importer_cycle_duration_seconds_sum`	Histograma	status	Soma das durações de todos os ciclos que o importador tentou importar configs para o cluster
`gkeconfig_importer_namespace_configs`	Medidor		Número de configurações de namespace no estado atual
`gkeconfig_monitor_errors`	Medidor	componente	Número de erros no repositório de configuração agrupado pelo componente em que ocorreram
`gkeconfig_monitor_configs`	Medidor	estado	Número de configs (cluster e namespace) agrupados por status de sincronização
`gkeconfig_monitor_last_import_timestamp`	Medidor		Carimbo de data/hora da importação mais recente
`gkeconfig_monitor_last_sync_timestamp`	Medidor		Carimbo de data/hora da sincronização mais recente
`gkeconfig_monitor_sync_latency_seconds_bucket`	Histograma		Número de medições de importação para sincronização realizadas (distribuídas em intervalos por latência entre os dois)
`gkeconfig_monitor_sync_latency_seconds_count`	Histograma		Número de medições de importação para sincronização realizadas (ignorando a latência entre as duas)
`gkeconfig_monitor_sync_latency_seconds_sum`	Histograma		Soma das latências de todas as medições de importação para sincronização realizadas
`gkeconfig_syncer_api_duration_seconds_bucket`	Histograma	operação, tipo, status	Número de chamadas feitas pelo sincronizador para o servidor de API (distribuído em intervalos pela duração de cada chamada)
`gkeconfig_syncer_api_duration_seconds_count`	Histograma	operação, tipo, status	Número de chamadas feitas pelo importador para o servidor da API (ignorando a duração)
`gkeconfig_syncer_api_duration_seconds_sum`	Histograma	operação, tipo, status	Soma das durações de todas as chamadas feitas pelo sincronizador para o servidor da API
`gkeconfig_syncer_controller_restarts_total`	Contador	fonte	Número total de reinicializações para os controladores de configuração de namespace e cluster
`gkeconfig_syncer_operations_total`	Contador	operação, tipo, status	Número total de operações realizadas para sincronizar recursos com configurações
`gkeconfig_syncer_reconcile_duration_seconds_bucket`	Histograma	tipo, status	Número de eventos de reconciliação processados pela sincronização (distribuídos em intervalos por duração)
`gkeconfig_syncer_reconcile_duration_seconds_count`	Histograma	tipo, status	Número de eventos de reconciliação processados pela sincronização (ignorando a duração)
`gkeconfig_syncer_reconcile_duration_seconds_sum`	Histograma	tipo, status	Soma das durações de todos os eventos de reconciliação processados pela sincronização
`gkeconfig_syncer_reconcile_event_timestamps`	Medidor	tipo	Data e hora em que os eventos de reconciliação de sincronização ocorreram

Se você estiver usando o Config Connector, poderá encontrar a lista de métricas em Como monitorar o Config Connector com o Prometheus.

Se o Policy Controller estiver ativado no cluster, as seguintes métricas também estarão disponíveis (todas prefixadas com gatekeeper_):

Nome	Tipo	Rótulos	Descrição
`gatekeeper_audit_duration_seconds`	Histograma		Distribuição da duração do ciclo de auditoria
`gatekeeper_audit_last_run_time`	Medidor		O carimbo de data e hora da época desde o último ambiente de execução da auditoria, fornecido como segundos em ponto flutuante
`gatekeeper_constraint_template_ingestion_count`	Contador	status	Número total de ações de ingestão de modelo de restrição
`gatekeeper_constraint_template_ingestion_duration_seconds`	Histograma	status	Distribuição de duração de ingestão de modelo de restrição
`gatekeeper_constraint_templates`	Medidor	status	Número atual de modelos de restrição
`gatekeeper_constraints`	Medidor	enforcement_action, status	Número atual de restrições
`gatekeeper_request_count`	Contador	admission_status	Contagem de solicitações de admissão do servidor da API
`gatekeeper_request_duration_seconds`	Histograma	admission_status	Distribuição da duração do pedido de admissão
`gatekeeper_violations`	Medidor	enforcement_action	Número de violações de auditoria detectadas no último ciclo de auditoria
`gatekeeper_watch_manager_intended_watch_gvk`	Medidor		Quantos Policy Controller do GroupVersionKinds exclusivos precisam estar assistindo. Essa é uma combinação de recursos e restrições sincronizados. Não implementado no momento
`gatekeeper_watch_manager_watched_gvk`	Medidor		Quantos Policy Controller do GroupVersionKinds exclusivos estão realmente assistindo. Isso precisa convergir para ser igual a gatekeeper_watch_manager_intended_watch_gvk Não implementado no momento
`gatekeeper_sync`	Medidor	tipo, status	Quantos recursos foram replicados no cache do OPA
`gatekeeper_sync_duration_seconds`	Histograma		Distribuição da duração da sincronização de objetos
`gatekeeper_sync_last_run_time`	Medidor		A última vez em que um recurso foi sincronizado

Procedimentos de depuração de exemplo

Nos exemplos a seguir, ilustramos alguns padrões para usar métricas do Prometheus, campos de status de objetos e anotações de objetos para detectar e diagnosticar problemas relacionados ao Anthos Config Management. Nos exemplos, mostramos como começar com o monitoramento de alto nível que detecta um problema e refinar progressivamente sua pesquisa para detalhar e diagnosticar a causa principal do problema.

Como consultar configs por status

O processo monitor fornece métricas de alto nível que fornecem informações úteis sobre uma visão geral de como o Anthos Config Management está operando no cluster. É possível ver se algum erro ocorreu e até mesmo configurar alertas para ele (em inglês).

gkeconfig_monitor_errors

Como usar `nomos status` para exibir erros

Além de usar as métricas do Prometheus para monitorar o status do Anthos Config Management nos clusters, use o comando nomos status para imprimir erros de todos os clusters na linha de comando.

Como consultar operações de importação e sincronização por status

O Anthos Config Management usa um processo de duas etapas para aplicar configs do repo a um cluster. A métrica gkeconfig_monitor_errors é identificada pelo componente para que você possa ver onde ocorreram erros.

gkeconfig_monitor_errors{component="importer"}
gkeconfig_monitor_errors{component="syncer"}

Também é possível verificar as métricas dos processos de importação e sincronização.

gkeconfig_importer_cycle_duration_seconds_count{status="error"}
gkeconfig_syncer_reconcile_duration_seconds_count{status="error"}

Como verificar o status do objeto de configuração

O Anthos Config Management define dois objetos Kubernetes personalizados: ClusterConfig e NamespaceConfig. Esses objetos definem um campo de status que contém informações sobre a alteração aplicada mais recentemente ao config e os erros que ocorreram. Por exemplo, se houver um erro em um namespace chamado shipping-dev, é possível verificar o status do NamespaceConfig correspondente.

kubectl get namespaceconfig shipping-dev -o yaml

Como verificar a anotação `token` de um objeto

É possível saber quando um objeto Kubernetes gerenciado foi atualizado pela última vez pelo Anthos Config Management. Cada objeto gerenciado é anotado com o hash da confirmação do Git quando foi modificado pela última vez, bem como o caminho para o config que apresentava a modificação.

kubectl get clusterrolebinding namespace-readers

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  annotations:
    configmanagement.gke.io/source-path: cluster/namespace-reader-clusterrolebinding.yaml
    configmanagement.gke.io/token: bbb6a1e2f3db692b17201da028daff0d38797771
  name: namespace-readers
...

Para mais informações, consulte rótulos e anotações.

A seguir

Veja o guia de início rápido.
Saiba mais sobre como visualizar os registros do Anthos Config Management.