Registo e monitorização de aplicações

Esta página mostra como configurar um cluster de utilizadores para o Google Distributed Cloud, de modo que as métricas e os registos personalizados das aplicações do utilizador sejam enviados para o Cloud Logging e o Cloud Monitoring. As métricas das aplicações do utilizador são recolhidas com o serviço gerido do Google Cloud para o Prometheus.

Ativar o Managed Service for Prometheus para aplicações de utilizador

A configuração do Managed Service for Prometheus é mantida num objeto do Stackdriver denominado stackdriver.

1. Abra o objeto stackdriver para edição:

   kubectl --kubeconfig=USER_CLUSTER_KUBECONFIG --namespace kube-system edit stackdriver stackdriver
   

   Substitua USER_CLUSTER_KUBECONFIG pelo caminho do ficheiro kubeconfig do cluster de utilizadores.

2. Em spec, defina enableGMPForApplications como true:

     apiVersion: addons.gke.io/v1alpha1
     kind: Stackdriver
     metadata:
       name: stackdriver
       namespace: kube-system
     spec:
       projectID: ...
       clusterName: ...
       clusterLocation: ...
       proxyConfigSecretName: ...
       enableGMPForApplications: true
       enableVPC: ...
       optimizedMetrics: true
   

3. Feche o ficheiro editado. Esta ação inicia a execução de componentes do Prometheus (GMP) geridos pela Google no cluster.

4. Para verificar os componentes, execute o seguinte comando:

   kubectl --kubeconfig=USER_CLUSTER_KUBECONFIG --namespace gmp-system get pods
   

   O resultado deste comando é semelhante ao seguinte:

    NAME                                 READY   STATUS    RESTARTS        AGE
    collector-abcde                      2/2     Running   1 (5d18h ago)   5d18h
    collector-fghij                      2/2     Running   1 (5d18h ago)   5d18h
    collector-klmno                      2/2     Running   1 (5d18h ago)   5d18h
    gmp-operator-68d49656fc-abcde        1/1     Running   0               5d18h
    rule-evaluator-7c686485fc-fghij      2/2     Running   1 (5d18h ago)   5d18h
   

O Managed Service for Prometheus suporta a avaliação de regras e os alertas. Para configurar a avaliação de regras, consulte o artigo Avaliação de regras.

Executar uma aplicação de exemplo

Nesta secção, cria uma aplicação que emite métricas do Prometheus e usa o Prometheus gerido pela Google para recolher as métricas. Para mais informações, consulte o Google Cloud Managed Service for Prometheus.

Implemente a aplicação de exemplo

1. Crie o espaço de nomes gmp-test para os recursos que criar como parte da aplicação de exemplo:

   kubectl --kubeconfig=USER_CLUSTER_KUBECONFIG create ns gmp-test
   

2. O serviço gerido fornece um manifesto para uma aplicação de exemplo que emite métricas do Prometheus na respetiva porta metrics. A aplicação usa três réplicas.

   Para implementar a aplicação de exemplo, execute o seguinte comando:

   kubectl --kubeconfig USER_CLUSTER_KUBECONFIG -n gmp-test apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/examples/example-app.yaml
   

Configure um recurso PodMonitoring

Para carregar os dados de métricas emitidos pela aplicação de exemplo, usa a extração de destinos. O serviço gerido usa recursos personalizados PodMonitoring (CRs) para configurar a recolha de dados e o carregamento de métricas de destino. Pode converter os seus recursos prometheus-operator existentes em CRs PodMonitoring.

Um CR PodMonitoring extrai alvos apenas no espaço de nomes em que o CR está implementado. Para extrair alvos em vários espaços de nomes, implemente o mesmo CR PodMonitoring em cada espaço de nomes. Pode verificar se o recurso PodMonitoring está instalado no espaço de nomes pretendido executando o seguinte comando:

 kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get podmonitoring -A

Para ver a documentação de referência sobre todos os CRs do Managed Service for Prometheus, consulte a referência da API prometheus-engine/doc/.

O manifesto seguinte define um recurso PodMonitoring, prom-example, no espaço de nomes gmp-test. O recurso encontra todos os pods no espaço de nomes que têm a etiqueta app com o valor prom-example. Os pods correspondentes são extraídos numa porta denominada metrics, a cada 30 segundos, no caminho HTTP /metrics.

apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: prom-example
spec:
  selector:
    matchLabels:
      app: prom-example
  endpoints:
  - port: metrics
    interval: 30s

Para aplicar este recurso, execute o seguinte comando:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG -n gmp-test apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/examples/pod-monitoring.yaml

O Managed Service for Prometheus está agora a extrair os pods correspondentes.

Consulte dados de métricas

A forma mais simples de verificar se os seus dados do Prometheus estão a ser exportados é usar consultas PromQL no Explorador de métricas na Google Cloud consola.

Para executar uma consulta PromQL, faça o seguinte:

1. Na Google Cloud consola, aceda à página Monitorização ou clique no botão seguinte:

   Aceder a Monitorização

2. No painel de navegação, selecione Explorador de métricas.

3. Use a linguagem de consulta do Prometheus (PromQL) para especificar os dados a apresentar no gráfico:

   1. Na barra de ferramentas do painel Selecionar uma métrica, selecione Editor de código.

   2. Selecione PromQL no botão Idioma. O botão para alternar o idioma encontra-se na parte inferior do painel Editor de código.

   3. Introduza a consulta no editor de consultas. Por exemplo, para criar um gráfico do número médio de segundos que as CPUs passaram em cada modo na última hora, use a seguinte consulta:

      avg(rate(kubernetes_io:anthos_container_cpu_usage_seconds_total
      {monitored_resource="k8s_node"}[1h]))
      

   Para mais informações sobre a utilização do PromQL, consulte o artigo PromQL no Cloud Monitoring.

A captura de ecrã seguinte mostra um gráfico que apresenta a métrica anthos_container_cpu_usage_seconds_total:

Se recolher muitos dados, é recomendável filtrar as métricas exportadas para reduzir os custos.

Ativar o Cloud Logging para aplicações de utilizador

A configuração do registo está num objeto do Stackdriver denominado stackdriver.

1. Abra o objeto stackdriver para edição:

   kubectl --kubeconfig=USER_CLUSTER_KUBECONFIG --namespace kube-system edit stackdriver stackdriver
   

   Substitua USER_CLUSTER_KUBECONFIG pelo caminho do ficheiro kubeconfig do cluster de utilizadores.

2. Em spec, defina enableCloudLoggingForApplications como true:

     apiVersion: addons.gke.io/v1alpha1
     kind: Stackdriver
     metadata:
       name: stackdriver
       namespace: kube-system
     spec:
       projectID: ...
       clusterName: ...
       clusterLocation: ...
       proxyConfigSecretName: ...
       enableCloudLoggingForApplications: true
       enableVPC: ...
       optimizedMetrics: true
   

3. Feche o ficheiro editado.

Executar uma aplicação de exemplo

Nesta secção, cria uma aplicação que escreve registos personalizados.

1. Guarde o manifesto de implementação seguinte num ficheiro com o nome my-app.yaml.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: "monitoring-example"
     namespace: "default"
     labels:
       app: "monitoring-example"
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: "monitoring-example"
     template:
       metadata:
         labels:
           app: "monitoring-example"
       spec:
         containers:
         - image: gcr.io/google-samples/prometheus-dummy-exporter:latest
           name: prometheus-example-exporter
           imagePullPolicy: Always
           command:
           - /bin/sh
           - -c
           - ./prometheus-dummy-exporter --metric-name=example_monitoring_up --metric-value=1 --port=9090
           resources:
             requests:
               cpu: 100m
   

2. Crie a implementação:

   kubectl --kubeconfig USER_CLUSTER_KUBECONFIG apply -f my-app.yaml
   

Visualizar registos de aplicações

Filtre registos de aplicações

A filtragem de registos de aplicações pode reduzir a faturação de registos de aplicações e o tráfego de rede do cluster para o Cloud Logging. A partir da versão 1.15.0 do Google Distributed Cloud, quando enableCloudLoggingForApplications está definido como true, pode filtrar os registos de aplicações pelos seguintes critérios:

• Etiquetas de agrupamentos (podLabelSelectors)
• Namespaces (namespaces)
• Expressões regulares para conteúdo de registos (contentRegexes)

O Google Distributed Cloud envia apenas os resultados do filtro para o Cloud Logging.

Defina filtros de registo de aplicações

A configuração para o registo é especificada num objeto do Stackdriver denominado stackdriver.

1. Abra o objeto stackdriver para edição:

   kubectl --kubeconfig USER_CLUSTER_KUBECONFIG --namespace kube-system \
       edit stackdriver stackdriver
   

   Substitua USER_CLUSTER_KUBECONFIG pelo caminho para o ficheiro kubeconfig do cluster de utilizadores.

2. Adicione uma secção appLogFilter à spec:

     apiVersion: addons.gke.io/v1alpha1
     kind: Stackdriver
     metadata:
       name: stackdriver
       namespace: kube-system
     spec:
       enableCloudLoggingForApplications: true
       projectID: ...
       clusterName: ...
       clusterLocation: ...
       appLogFilter:
         keepLogRules:
         - namespaces:
           - prod
           ruleName: include-prod-logs
         dropLogRules:
         - podLabelSelectors:
           - disableGCPLogging=yes
           ruleName: drop-logs
   

3. Guarde e feche o ficheiro editado.

4. (Opcional) Se estiver a usar o podLabelSelectors, reinicie o stackdriver-log-forwarder DaemonSet para aplicar as alterações o mais rapidamente possível:

   kubectl --kubeconfig USER_CLUSTER_KUBECONFIG --namespace kube-system \
       rollout restart daemonset stackdriver-log-forwarder
   

   Normalmente, as podLabelSelectors entram em vigor após 10 minutos. O reinício do DaemonSet stackdriver-log-forwarder faz com que as alterações entrem em vigor mais rapidamente.

Exemplo: inclua registos ERROR ou WARN apenas no espaço de nomes prod

O exemplo seguinte ilustra o funcionamento de um filtro de registo de aplicações. Define um filtro que usa um espaço de nomes (prod), uma expressão regular (.*(ERROR|WARN).*) e uma etiqueta de pod (disableGCPLogging=yes). Em seguida, para verificar se o filtro funciona, executa um pod no espaço de nomes prod para testar estas condições de filtro.

Para definir e testar um filtro de registo de aplicações:

1. Especifique um filtro de registo de aplicações no objeto Stackdriver:

   No appLogFilter exemplo seguinte, apenas os registos ERROR ou WARN no espaço de nomes prod são mantidos. Todos os registos de Pods com a etiqueta disableGCPLogging=yes são ignorados:

   apiVersion: addons.gke.io/v1alpha1
   kind: Stackdriver
   metadata:
     name: stackdriver
     namespace: kube-system
   spec:
     ...
     appLogFilter:
       keepLogRules:
       - namespaces:
         - prod
         contentRegexes:
         - ".*(ERROR|WARN).*"
         ruleName: include-prod-logs
       dropLogRules:
       - podLabelSelectors:
         - disableGCPLogging=yes # kubectl label pods pod disableGCPLogging=yes
         ruleName: drop-logs
   ...
   

2. Implemente um pod no espaço de nomes prod e execute um script que gera entradas de registo ERROR e INFO:

   kubectl --kubeconfig USER_CLUSTER_KUBECONFIG run pod1 \
       --image gcr.io/cloud-marketplace-containers/google/debian10:latest \
       --namespace prod --restart Never --command -- \
       /bin/sh -c "while true; do echo 'ERROR is 404\\nINFO is not 404' && sleep 1; done"
   

   Os registos filtrados devem conter apenas as entradas ERROR e não as entradas INFO.

3. Adicione a etiqueta disableGCPLogging=yes ao Pod:

   kubectl --kubeconfig USER_CLUSTER_KUBECONFIG label pods pod1 \
       --namespace prod disableGCPLogging=yes
   

   O registo filtrado já não deve conter entradas para o pod1 pod.

Definição da API de filtro de registo de aplicações

A definição do filtro de registo da aplicação é declarada na definição de recursos personalizados do Stackdriver.

Para obter a definição de recurso personalizado do Stackdriver, execute o seguinte comando:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get crd stackdrivers.addons.gke.io \
    --namespace kube-system -o yaml