Nesta página, mostramos como configurar um cluster para o Google Distributed Cloud para que os registros e as métricas personalizados de aplicativos do usuário sejam enviados ao Cloud Logging, ao Cloud Monitoring e ao Google Cloud Managed Service para Prometheus.
Para a melhor experiência de geração de registros e monitoramento de aplicativos do usuário, recomendamos que você use a seguinte configuração:
Ative o Google Cloud Managed Service para Prometheus definindo
enableGMPForApplications
comotrue
no objetoStackdriver
. Essa configuração permite usar o Prometheus para monitoramento e alertas globais das cargas de trabalho. Para instruções e informações adicionais, consulte Ativar o Google Cloud Managed Service para Prometheus nesta página.Ative o Cloud Logging para aplicativos do usuário definindo
enableCloudLoggingForApplications
comotrue
no objetoStackdriver
. Essa configuração fornece geração de registros das suas cargas de trabalho. Para mais informações e instruções, consulte Ativar o Cloud Logging para aplicativos do usuário nesta página.
Ativar o Google Cloud Managed Service para Prometheus
A configuração do Google Cloud Managed Service para Prometheus é especificada em um
objeto Stackdriver
chamado stackdriver
. Para mais informações, incluindo
práticas recomendadas e solução de problemas, consulte a
documentação do Google Cloud Managed Service para Prometheus.
Para configurar o objeto stackdriver
para ativar o Google Cloud Managed
Service para Prometheus:
Abra o objeto Stackdriver para edição:
kubectl --kubeconfig=CLUSTER_KUBECONFIG \ --namespace kube-system edit stackdriver stackdriver
Substitua
CLUSTER_KUBECONFIG
pelo caminho do seu arquivo kubeconfig do cluster.Em
spec
, definaenableGMPForApplications
comotrue
:apiVersion: addons.gke.io/v1alpha1 kind: Stackdriver metadata: name: stackdriver namespace: kube-system spec: projectID: ... clusterName: ... clusterLocation: ... proxyConfigSecretName: ... enableGMPForApplications: true enableVPC: ... optimizedMetrics: true
Salve e feche o arquivo editado.
Os componentes do Prometheus gerenciados pelo Google são iniciados automaticamente no cluster no namespace
gmp-system
.Verifique os componentes do Prometheus gerenciados pelo Google:
kubectl --kubeconfig=CLUSTER_KUBECONFIG --namespace gmp-system get pods
A saída deste comando é semelhante a:
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 Google Cloud Managed Service para Prometheus oferece suporte à avaliação e ao alerta de regras. Para configurar a avaliação de regras, consulte Avaliação de regras.
Executar um aplicativo de exemplo
O serviço gerenciado fornece um manifesto para um aplicativo de exemplo, prom-example
, que emite
métricas do Prometheus na porta metrics
. O aplicativo usa três réplicas.
Para implantar o aplicativo:
Crie o namespace
gmp-test
para os recursos que você criar como parte do aplicativo de exemplo:kubectl --kubeconfig=CLUSTER_KUBECONFIG create ns gmp-test
Aplique o manifesto do aplicativo com o seguinte comando:
kubectl -n gmp-test apply \ -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/examples/example-app.yaml
Configurar um recurso do PodMonitoring
Nesta seção, você configura um recurso personalizado
PodMonitoring
para capturar dados de métricas emitidos pelo aplicativo de exemplo e
enviá-los ao Google Cloud Managed Service para Prometheus. O recurso personalizado PodMonitoring
usa a cópia de destino. Nesse caso, os agentes do coletor coletam o endpoint /metrics
para o qual o aplicativo de amostra emite dados.
Um recurso personalizado PodMonitoring
raspa os destinos no namespace em que ele é
implantado. Para extrair objetivos em vários namespaces, implante o mesmo
recurso personalizado PodMonitoring
em cada namespace. É possível verificar se o
recurso PodMonitoring
está instalado no namespace pretendido executando o
seguinte comando:
kubectl --kubeconfig CLUSTER_KUBECONFIG get podmonitoring -A
Para ver a documentação de referência sobre todos os recursos personalizados do Google Cloud Managed Service para Prometheus, consulte a referência do prometheus-engine/doc/api.
O manifesto a seguir define um recurso PodMonitoring
, prom-example
, no
namespace gmp-test
. O recurso encontra todos os pods no namespace que têm o rótulo
app
com o valor prom-example
. Os pods correspondentes são copiados em uma porta chamada 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 esse recurso, execute o seguinte comando:
kubectl --kubeconfig CLUSTER_KUBECONFIG -n gmp-test apply \
-f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/examples/pod-monitoring.yaml
O Google Cloud Managed Service para Prometheus agora está coletando os pods correspondentes.
Consultar dados de métricas
A maneira mais simples de verificar se os dados do Prometheus estão sendo exportados é usar consultas em PromQL no Metrics Explorer do console do Google Cloud.
Para executar uma consulta em PromQL, realize estas ações:
No console do Google Cloud, acesse a página Monitoramento ou clique no botão a seguir:
No painel de navegação, selecione Metrics Explorer.
Use a linguagem de consulta do Prometheus (PromQL) para especificar os dados que serão exibidos no gráfico:
Na barra de ferramentas do painel Selecionar uma métrica, clique em Editor de código.
Selecione PromQL no botão de alternância Linguagem. O botão de alternar linguagem fica na parte inferior do painel Editor de código.
Insira sua consulta no editor de consultas. Por exemplo, para gerar um gráfico sobre o número médio de segundos que as CPUs gastaram 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 como usar PromQL, consulte PromQL no Cloud Monitoring.
A captura de tela a seguir mostra um gráfico que exibe a
métrica anthos_container_cpu_usage_seconds_total
:
Se você coletar grandes volumes de dados, filtre as métricas exportadas para manter os custos baixos.
Ativar o Cloud Logging para aplicativos do usuário
A configuração do Cloud Logging e do Cloud Monitoring é mantida em um objeto do Stackdriver chamado stackdriver
.
Abra o objeto Stackdriver para edição:
kubectl --kubeconfig=CLUSTER_KUBECONFIG \ --namespace kube-system edit stackdriver stackdriver
Substitua
CLUSTER_KUBECONFIG
pelo caminho do arquivo kubeconfig do cluster de usuário.Na seção
spec
, definaenableCloudLoggingForApplications
comotrue
:apiVersion: addons.gke.io/v1alpha1 kind: Stackdriver metadata: name: stackdriver namespace: kube-system spec: projectID: ... clusterName: ... clusterLocation: ... proxyConfigSecretName: ... enableCloudLoggingForApplications: true enableVPC: ... optimizedMetrics: true
Salve e feche o arquivo editado.
Executar um aplicativo de exemplo
Nesta seção, você criará um aplicativo que grava registros personalizados.
Salve os seguintes manifestos de implantação em um arquivo chamado
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
Criar a implantação
kubectl --kubeconfig CLUSTER_KUBECONFIG apply -f my-app.yaml
Veja os registros do aplicativo.
Console
Acesse o Explorador de registros no console do Google Cloud.
Clique em Recurso. No menu TODOS OS TIPOS DE RECURSO, selecione Contêiner do Kubernetes.
Em CLUSTER_NAME, selecione o nome do seu cluster de usuário.
Em NAMESPACE_NAME, selecione default.
Clique em Adicionar e em Executar consulta.
Em Resultados da consulta, é possível ver as entradas de registro da implantação
monitoring-example
. Exemplo:{ "textPayload": "2020/11/14 01:24:24 Starting to listen on :9090\n", "insertId": "1oa4vhg3qfxidt", "resource": { "type": "k8s_container", "labels": { "pod_name": "monitoring-example-7685d96496-xqfsf", "cluster_name": ..., "namespace_name": "default", "project_id": ..., "location": "us-west1", "container_name": "prometheus-example-exporter" } }, "timestamp": "2020-11-14T01:24:24.358600252Z", "labels": { "k8s-pod/pod-template-hash": "7685d96496", "k8s-pod/app": "monitoring-example" }, "logName": "projects/.../logs/stdout", "receiveTimestamp": "2020-11-14T01:24:39.562864735Z" }
CLI da gcloud
Execute este comando:
gcloud logging read 'resource.labels.project_id="PROJECT_ID" AND \ resource.type="k8s_container" AND resource.labels.namespace_name="default"'
Substitua
PROJECT_ID
pelo ID do seu projeto.Na saída, é possível ver entradas de registro da implantação
monitoring-example
. Exemplo:insertId: 1oa4vhg3qfxidt labels: k8s-pod/app: monitoring-example k8s- pod/pod-template-hash: 7685d96496 logName: projects/.../logs/stdout receiveTimestamp: '2020-11-14T01:24:39.562864735Z' resource: labels: cluster_name: ... container_name: prometheus-example-exporter location: us-west1 namespace_name: default pod_name: monitoring-example-7685d96496-xqfsf project_id: ... type: k8s_container textPayload: | 2020/11/14 01:24:24 Starting to listen on :9090 timestamp: '2020-11-14T01:24:24.358600252Z'
Filtrar registros de aplicativos
A filtragem de registros de aplicativos pode reduzir o faturamento de geração de registros do aplicativo 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
é definido como true
, é possível filtrar os registros de aplicativos pelos seguintes critérios:
- Identificadores de pods (
podLabelSelectors
) - Namespaces (
namespaces
) - Expressões regulares para o conteúdo de registros (
contentRegexes
)
O Google Distributed Cloud envia apenas os resultados do filtro para o Cloud Logging.
Definir filtros de registro do aplicativo
A configuração do Logging é especificada em um objeto do Stackdriver chamado stackdriver
.
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 arquivo kubeconfig do cluster de usuário.
Adicione uma seção
appLogFilter
aospec
: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
Salve e feche o arquivo editado.
(Opcional) Se você estiver usando
podLabelSelectors
, reinicie o DaemonSetstackdriver-log-forwarder
para aplicar suas alterações o mais rápido possível:kubectl --kubeconfig USER_CLUSTER_KUBECONFIG --namespace kube-system \ rollout restart daemonset stackdriver-log-forwarder
Normalmente,
podLabelSelectors
são efetivas após 10 minutos. Reiniciar o DaemonSetstackdriver-log-forwarder
faz as alterações entrarem em vigor mais rapidamente.
Exemplo: inclua os registros ERROR
ou WARN
apenas no namespace prod
O exemplo a seguir ilustra um funcionamento do filtro de registro do aplicativo. Defina um filtro que use um namespace (prod
), uma expressão regular (.*(ERROR|WARN).*
) e um identificador de pod (disableGCPLogging=yes
). Em seguida, para verificar se o filtro funciona, execute um pod no namespace prod
para testar essas condições de filtro.
Para definir e testar um filtro de registro do aplicativo:
Especifique um filtro de registro do aplicativo no objeto do Stackdriver:
No exemplo
appLogFilter
a seguir, apenas os registrosERROR
ouWARN
no namespaceprod
são mantidos. Todos os registros de pods com o identificadordisableGCPLogging=yes
são descartados: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 ...
Implante um pod no namespace
prod
e execute um script que gera entradas de registroERROR
eINFO
: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 registros filtrados precisam conter apenas as entradas
ERROR
, não asINFO
.Adicione o identificador
disableGCPLogging=yes
ao pod:kubectl --kubeconfig USER_CLUSTER_KUBECONFIG label pods pod1 \ --namespace prod disableGCPLogging=yes
O registro filtrado não deve mais conter nenhuma entrada para o pod
pod1
.
Definição da API de filtro de registro do aplicativo
A definição do filtro de registro do aplicativo é declarada na definição de recursos personalizados do Stackdriver.
Para conferir a definição do recurso personalizado do Stackdriver, execute o seguinte comando:
kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get crd stackdrivers.addons.gke.io \
--namespace kube-system -o yaml