Esta página foi traduzida pela API Cloud Translation.
Switch to English

Políticas de amostra

Nesta página, apresentamos uma coleção de políticas de alertas específicas que podem ser usadas como inspiração e para você criar políticas próprias.

Como representar políticas em formato JSON ou YAML

É possível representar políticas de alerta em dois formatos de dados: JSON e YAML. O SDK do Cloud pode ler e gravar os dois formatos. A API REST pode ler JSON.

Para gerar representações YAML (padrão) das suas políticas de alertas e canais de notificação existentes, use os comandos gcloud alpha monitoring policies list e describe ou os comandos gcloud alpha monitoring channels list e describe, respectivamente.

Por exemplo, esse comando recupera uma única política e captura a saída no arquivo test-policy.yaml:

gcloud alpha monitoring policies describe projects/a-gcp-project/alertPolicies/12669073143329903307 > test-policy.yaml

Para gerar representações JSON das suas políticas de alerta e canais de notificação existentes:

Como copiar políticas

Como ilustramos no exemplo de backup/restauração, é possível usar políticas salvas para criar novas cópias delas. Você também pode usá-las como ponto de partida para criar políticas semelhantes.

É possível usar uma política salva em um projeto para criar uma nova ou semelhante em outro projeto. No entanto, você precisa primeiro fazer as seguintes alterações em uma cópia da política salva:

  • Remova os campos a seguir de todos os canais de notificação:
    • name
    • verificationStatus
  • Crie canais de notificação antes de consultar os canais nas políticas de alertas. São necessários os novos identificadores de canal.
  • Remova os campos a seguir de todas as políticas de alertas que você estiver recriando:
    • name
    • condition.name
    • creationRecord
    • mutationRecord

Amostras de política

As políticas aqui são organizadas usando a mesma terminologia usada pelo Google Monitoring no Console do Google Cloud, por exemplo, "política de taxa de alteração", mas existem apenas dois tipos de condições subjacentes a todas essas classificações:

  • Uma condição de limite. Quase todos os tipos de política mencionados na IU são variantes em uma condição de limite.
  • Uma condição de ausência

Nas amostras aqui, elas são indicadas pelas condições conditionThreshold e conditionAbsent. Para mais informações, consulte a página de referência para Condition.

É possível criar muitas dessas políticas manualmente usando o Console do Google Cloud, mas algumas delas só podem ser criadas com a API Monitoring. Para mais informações, consulte Como criar uma política de alertas (IU) ou Como criar políticas (API).

Política de limite de métrica

Uma política de limite de métrica detecta quando algum valor cruza um limite predeterminado. As políticas de limite permitem que você saiba que algo está se aproximando de um ponto importante, portanto, você pode realizar alguma ação. Por exemplo, quando o espaço disponível em disco fica abaixo de 10% do espaço total e seu sistema pode ficar sem espaço em breve.

A política a seguir utiliza o uso médio da CPU como um indicador da integridade de um grupo de VMs. Isso gera um alerta quando o uso médio da CPU de um grupo de VMs em uma instância e zona, medida em intervalos de 60 segundos, excede um limite de 90% de utilização por 15 minutos (900 segundos):

{
    "displayName": "Very high CPU usage",
    "combiner": "OR",
    "conditions": [
        {
            "displayName": "CPU usage is extremely high",
            "conditionThreshold": {
                "aggregations": [
                    {
                        "alignmentPeriod": "60s",
                        "crossSeriesReducer": "REDUCE_MEAN",
                        "groupByFields": [
                            "project",
                            "resource.label.instance_id",
                            "resource.label.zone"
                        ],
                        "perSeriesAligner": "ALIGN_MAX"
                    }
                ],
                "comparison": "COMPARISON_GT",
                "duration": "900s",
                "filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\"
                          AND resource.type=\"gce_instance\"",
                "thresholdValue": 0.9,
                "trigger": {
                    "count": 1
                }
            }
        }
    ],
}

Política de ausência de métrica

A política de ausência de métrica é acionada quando nenhum dado é gravado em uma métrica pelo período especificado.

Uma maneira de demonstrar isso é criar uma métrica personalizada, na qual nada será gravado. Você não precisa de uma métrica personalizada para esse tipo de política, mas, para fins de demonstração, é fácil garantir que não seja usada em qualquer situação.

Veja um descritor de amostra para uma métrica personalizada. É possível criar a métrica usando o APIs Explorer.

{
  "description": "Number of times the pipeline has run",
  "displayName": "Pipeline runs",
  "metricKind": "GAUGE",
  "type": "custom.googleapis.com/pipeline_runs",
  "labels": [
    {
      "description": "The name of the pipeline",
      "key": "pipeline_name",
      "valueType": "STRING"
    },
  ],
  "unit": "1",
  "valueType": "INT64"
}

Consulte Como usar métricas personalizadas para mais informações.

A seguinte política de alertas será acionada se nenhum dado for gravado nessa métrica por um período de aproximadamente uma hora: em outras palavras, seu pipeline por hora não é executado. Observe que a condição usada aqui é conditionAbsent.

{
    "displayName": "Data ingestion functioning",
    "combiner": "OR",
    "conditions": [
        {
            "displayName": "Hourly pipeline is up",
            "conditionAbsent": {
                "duration": "3900s",
                "filter": "resource.type=\"global\"
                          AND metric.type=\"custom.googleapis.com/pipeline_runs\"
                          AND metric.label.pipeline_name=\"hourly\"",
            }
        }
    ],
}

Política de taxa de alteração

Essa política avisa quando a taxa de uso da CPU está aumentando rapidamente:

{
  "displayName": "High CPU rate of change",
  "combiner": "OR",
  "conditions": [
    {
      "displayName": "CPU usage is increasing at a high rate",
      "conditionThreshold": {
         "aggregations": [
           {
             "alignmentPeriod": "900s",
             "perSeriesAligner": "ALIGN_PERCENT_CHANGE",
           }],
        "comparison": "COMPARISON_GT",
        "duration": "180s",
        "filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" AND resource.type=\"gce_instance\"",
        "thresholdValue": 0.5,
        "trigger": {
          "count": 1
         }
      }
    }
  ],
}

Política de agregação de grupo

Esta política alerta quando a utilização média da CPU em um cluster do Google Kubernetes Engine excede um limite:

{
    "displayName": "CPU utilization across GKE cluster exceeds 10 percent",
    "combiner": "OR",
    "conditions": [
         {
            "displayName": "Group Aggregate Threshold across All Instances in Group GKE cluster",
            "conditionThreshold": {
                "filter": "group.id=\"3691870619975147604\" AND metric.type=\"compute.googleapis.com/instance/cpu/utilization\" AND resource.type=\"gce_instance\"",
                "comparison": "COMPARISON_GT",
                "thresholdValue": 0.1,
                "duration": "300s",
                "trigger": {
                    "count": 1
                },
                "aggregations": [
                    {
                        "alignmentPeriod": "60s",
                        "perSeriesAligner": "ALIGN_MEAN",
                        "crossSeriesReducer": "REDUCE_MEAN",
                        "groupByFields": [
                              "project",
                              "resource.label.instance_id",
                              "resource.label.zone"
                        ]
                    },
                    {
                        "alignmentPeriod": "60s",
                        "perSeriesAligner": "ALIGN_SUM",
                        "crossSeriesReducer": "REDUCE_MEAN"
                    }
                ]
            },
        }
    ],
}

Essa política pressupõe a existência do grupo a seguir:

{
    "name": "projects/a-gcp-project/groups/3691870619975147604",
    "displayName": "GKE cluster",
    "filter": "resource.metadata.name=starts_with(\"gke-kuber-cluster-default-pool-6fe301a0-\")"
}

Para identificar os campos equivalentes para os grupos, liste os detalhes do grupo usando o API Explorer na página de referência project.groups.list.

Política de verificação de tempo de atividade

O status das verificações de tempo de atividade aparece na página Visão geral do Monitoring, mas você pode usar uma política de alertas para notificar diretamente se a verificação de tempo de atividade falhar.

Por exemplo, o JSON a seguir descreve uma verificação de tempo de atividade de HTTPS no site do Google Cloud. Ele verifica a disponibilidade a cada 5 minutos.

A verificação de tempo de atividade foi criada com o Console do Google Cloud. A representação JSON foi criada listando as verificações de tempo de atividade no projeto usando a API Monitoring. Veja uptimeCheckConfigs.list. Também é possível criar verificações de tempo de atividade com a API Monitoring.

{
    "name": "projects/a-gcp-project/uptimeCheckConfigs/uptime-check-for-google-cloud-site",
    "displayName": "Uptime check for Google Cloud site",
    "monitoredResource": {
        "type": "uptime_url",
        "labels": {
            "host": "cloud.google.com"
      }
    },
    "httpCheck": {
        "path": "/index.html",
        "useSsl": true,
        "port": 443,
        "authInfo": {}
    },
    "period": "300s",
    "timeout": "10s",
    "contentMatchers": [
        {}
    ]
}

Para criar uma política de alertas para uma verificação de tempo de atividade, consulte a verificação de tempo de atividade por UPTIME_CHECK_ID. Esse ID é definido quando a verificação é criada; ele aparece como o último componente do campo name e é visível na interface do usuário como Check ID no resumo da configuração. Se você estiver usando a API Monitoring, o método uptimeCheckConfigs.create retornará o ID.

O ID é derivado de displayName, que foi definido na IU nesse caso. Ele pode ser verificado listando as verificações de tempo de atividade e observando o valor name.

O ID da verificação de tempo de atividade descrito anteriormente é uptime-check-for-google-cloud-site.

A política de alertas abaixo será acionada se a verificação de tempo de atividade falhar ou se o certificado SSL no site do Google Cloud expirar em menos de 15 dias. Se uma dessas condições ocorrer, a política de alertas enviará uma notificação para o canal de notificação especificado:

{
    "displayName": "Google Cloud site uptime failure",
    "combiner": "OR",
    "conditions": [
        {
            "displayName": "Failure of uptime check_id uptime-check-for-google-cloud-site",
            "conditionThreshold": {
                "aggregations": [
                    {
                        "alignmentPeriod": "1200s",
                        "perSeriesAligner": "ALIGN_NEXT_OLDER",
                        "crossSeriesReducer": "REDUCE_COUNT_FALSE",
                        "groupByFields": [ "resource.label.*" ]
                    }
                ],
                "comparison": "COMPARISON_GT",
                "duration": "600s",
                "filter": "metric.type=\"monitoring.googleapis.com/uptime_check/check_passed\"
                          AND metric.label.check_id=\"uptime-check-for-google-cloud-site\"
                          AND resource.type=\"uptime_url\"",
                "thresholdValue": 1,
                "trigger": {
                    "count": 1
                }
            }
        },
        {
            "displayName": "SSL Certificate for google-cloud-site expiring soon",
            "conditionThreshold": {
                "aggregations": [
                    {
                        "alignmentPeriod": "1200s",
                        "perSeriesAligner": "ALIGN_NEXT_OLDER",
                        "crossSeriesReducer": "REDUCE_MEAN",
                        "groupByFields": [ "resource.label.*" ]
                    }
                ],
                "comparison": "COMPARISON_LT",
                "duration": "600s",
                "filter": "metric.type=\"monitoring.googleapis.com/uptime_check/time_until_ssl_cert_expires\"
                          AND metric.label.check_id=\"uptime-check-for-google-cloud-site\"
                          AND resource.type=\"uptime_url\"",
                "thresholdValue": 15,
                "trigger": {
                    "count": 1
                }
            }
        }
    ],
}

O filtro na política de alerta especifica a métrica monitorada por tipo e rótulo. Os tipos de métrica são monitoring.googleapis.com/uptime_check/check_passed e monitoring.googleapis.com/uptime_check/time_until_ssl_cert_expires. O rótulo de métrica identifica a verificação de tempo de atividade específica que está sendo monitorada. Neste exemplo, o campo de rótulo check_id contém o ID de verificação de tempo de atividade.

AND metric.label.check_id=\"uptime-check-for-google-cloud-site\"

Consulte Como monitorar filtros para mais informações.

Política de integridade do processo

Uma política de integridade do processo poderá notificar você se o número de processos correspondentes a um padrão cruzar um limite. Isso pode ser usado para informar, por exemplo, que um processo parou de ser executado.

Esta política envia uma notificação para o canal de notificação especificado quando nenhum processo correspondente à string nginx, executando como usuário www, está disponível há mais de cinco minutos:

{
    "displayName": "Server health",
    "combiner": "OR",
    "conditions": [
        {
            "displayName": "Process 'nginx' is not running",
            "conditionThreshold": {
                "filter": "select_process_count(\"has_substring(\\\"nginx\\\")\", \"www\") AND resource.type=\"gce_instance\"",
                "comparison": "COMPARISON_LT",
                "thresholdValue": 1,
                "duration": "300s"
            }
        }
    ],
}

Para ver outro exemplo, consulte Integridade do processo.

Proporção da métrica

Recomendamos que você use a linguagem de consulta de monitoramento (MQL, na sigla em inglês) para criar políticas de alertas com base em proporção. A API Cloud Monitoring é compatível com a construção de algumas proporções com base em filtros. No entanto, o MQL fornece uma solução mais flexível e robusta. Para ver exemplos de políticas de proporção baseadas em MQL, consulte exemplos de política de alertas MQL. Para informações gerais sobre a criação de políticas de alertas com MQL, consulte Políticas de alertas com MQL.

Nesta seção, descrevemos uma proporção com base em filtro. Com a API, é possível criar e visualizar uma política que calcula a proporção de duas métricas relacionadas e é acionada quando essa proporção ultrapassa um limite. As métricas relacionadas precisam ter o mesmo MetricKind. Por exemplo, é possível criar uma política de alertas baseada em proporção se as duas métricas forem de medidas. Para determinar o MetricKind de um tipo de métrica, consulte a Lista de métricas.

Uma condição de proporção é uma variante de uma condição de limite simples, em que a condição em uma política de proporção usa dois filtros: a filter usual, que atua como o numerador da proporção, e denominatorFilter, que age como o denominador da proporção.

As séries temporais de ambos os filtros precisam ser agregadas da mesma forma, de modo que o cálculo da proporção dos valores seja significativo. A política de alertas será acionada se a proporção dos dois filtros violar um valor limite para a duração especificada.

A próxima seção descreve como configurar uma política de alertas que monitora a proporção de respostas de erro HTTP a todas as respostas HTTP.

Proporção de erros de HTTP

A política a seguir cria uma condição de limite criada com base na proporção entre a contagem de respostas de erro HTTP e a contagem de todas as respostas HTTP.

{
    "displayName": "HTTP error count exceeds 50 percent for App Engine apps",
    "combiner": "OR",
    "conditions": [
        {
            "displayName": "Ratio: HTTP 500s error-response counts / All HTTP response counts",
            "conditionThreshold": {
                 "filter": "metric.label.response_code>=\"500\" AND
                            metric.label.response_code<\"600\" AND
                            metric.type=\"appengine.googleapis.com/http/server/response_count\" AND
                            project=\"a-gcp-project\" AND
                            resource.type=\"gae_app\"",
                 "aggregations": [
                    {
                        "alignmentPeriod": "300s",
                        "crossSeriesReducer": "REDUCE_SUM",
                        "groupByFields": [
                          "project",
                          "resource.label.module_id",
                          "resource.label.version_id"
                        ],
                        "perSeriesAligner": "ALIGN_DELTA"
                    }
                ],
                "denominatorFilter": "metric.type=\"appengine.googleapis.com/http/server/response_count\" AND
                                      project=\"a-gcp-project\" AND
                                      resource.type=\"gae_app\"",
                "denominatorAggregations": [
                   {
                      "alignmentPeriod": "300s",
                      "crossSeriesReducer": "REDUCE_SUM",
                      "groupByFields": [
                        "project",
                        "resource.label.module_id",
                        "resource.label.version_id"
                       ],
                      "perSeriesAligner": "ALIGN_DELTA",
                    }
                ],
                "comparison": "COMPARISON_GT",
                "thresholdValue": 0.5,
                "duration": "0s",
                "trigger": {
                    "count": 1
                }
            }
        }
    ]
}

Tipos de métrica e recurso

O tipo de métrica desta política é appengine.googleapis.com/http/server/response_count, que tem dois rótulos:

  • response_code, um inteiro de 64 bits que representa o código de status HTTP da solicitação. Essa política filtra os dados de série temporal nesse rótulo para que ele possa determinar o seguinte:
    • O número de respostas recebidas.
    • O número de respostas de erro recebidas.
    • A proporção de respostas de erro para todas as respostas.
  • loading, um valor booleano que indica se o carregamento da solicitação estava sendo realizado. O rótulo loading é irrelevante nesta política de alertas.

A política de alertas se preocupa com os dados de resposta dos apps do App Engine, ou seja, os dados provenientes do tipo de recurso monitorado gae_app. Esse recurso monitorado tem três rótulos:

  • project_id, o ID do projeto do Google Cloud.
  • module_id, o nome do serviço ou módulo no app.
  • version_id, a versão do app.

Para mais informações de referência sobre esses tipos de recursos monitorados e métricos, consulte métricas do App Engine na lista de métricas e a entrada gae_app na lista de recursos monitorados.

O que esta política faz

Essa política calcula a proporção entre respostas de erro e respostas totais. A política aciona uma notificação de alerta se a proporção ultrapassar 50% (isto é, a proporção for maior que 0,5) durante o período de alinhamento de cinco minutos.

Essa política captura o módulo e a versão do app que viola a condição, agrupando a série temporal em cada filtro pelos valores desses rótulos.

  • O filtro na condição analisa as respostas HTTP de um app do App Engine e seleciona essas respostas no intervalo de erro, 5xx. Este é o numerador na proporção.
  • O filtro de denominador na condição analisa todas as respostas HTTP de um app do App Engine.

A política aciona a notificação de alerta imediatamente. a duração permitida para a condição é de 0 segundo. Essa política usa uma contagem de acionadores de 1, que é o número de séries temporais que precisam violar a condição para acionar a notificação de alerta. Para um app do App Engine com um único serviço, um acionador de 1 é adequado. Se você tiver um app com 20 serviços e desejar acionar um alerta se três ou mais serviços violarem a condição, use uma contagem de acionadores de três.

Como configurar uma proporção

Os filtros de numerador e denominador são exatamente os mesmos, exceto pelo fato de o filtro de condição no numerador corresponder aos códigos de resposta no intervalo de erro, e o filtro de condição no denominador corresponder a todos os códigos de resposta. As cláusulas a seguir aparecem somente na condição do numerador:

      metric.label.response_code>="500" AND
      metric.label.response_code<"600"

Caso contrário, os filtros de numerador e denominador serão os mesmos.

A série temporal selecionada por cada filtro precisa ser agregada da mesma maneira para que o cálculo da proporção seja válido. Cada filtro pode coletar várias séries temporais, pois haverá uma série temporal diferente para cada combinação de valores para rótulos. Essa política agrupa esse conjunto de séries temporais por rótulos de recurso especificados, que particionam o conjunto de séries temporais em um conjunto de grupos. Algumas das séries temporais de cada grupo correspondem ao filtro do numerador. o restante corresponde ao filtro do denominador.

Para calcular uma proporção, o conjunto de séries temporais que corresponde a cada filtro precisa ser agregado a uma única série temporal cada. Isso deixa cada grupo com duas séries temporais, uma para o numerador e outra para o denominador. Em seguida, a proporção de pontos na série temporal do numerador e do denominador em cada grupo pode ser calculada.

Nessa política, as séries temporais de ambos os filtros são agregadas da seguinte maneira:

  • Cada filtro cria um número de séries temporais alinhadas em intervalos de cinco minutos, com valores representados computando ALIGN_DELTA nos valores nesse intervalo de alinhamento de cinco minutos. Esse alinhador retorna o número de respostas correspondentes nesse intervalo como um inteiro de 64 bits.

  • As séries temporais em cada filtro também são agrupadas pelos valores dos rótulos de recurso para módulo e versão, de modo que cada grupo com contém dois conjuntos de séries temporais alinhadas, aqueles que correspondem ao filtro numerador e aqueles que correspondem ao filtro de denominador.

  • A série temporal em cada grupo que corresponde ao filtro do numerador ou do denominador é agregada a uma única hora somando os valores na série temporal individual usando o redutor de série cruzada REDUCER_SUM. Isso resulta em uma série temporal para o numerador e uma para o denominador, cada uma informando o número de respostas em todas as séries temporais correspondentes no intervalo de alinhamento.

Em seguida, a política calcula, para a série temporal do numerador e do denominador que representa cada grupo, a proporção dos valores. Quando a proporção estiver disponível, essa política será uma política simples de limite de métricas.