As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Explorar alertas
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Caso esteja iniciando ou expandindo a implementação do Grafana Alerting, saiba mais sobre os principais conceitos e os recursos disponíveis que ajudam você a criar, gerenciar e agir de acordo com os alertas e a melhorar a capacidade de sua equipe de resolver problemas rapidamente.
Em primeiro lugar, vamos analisar os diferentes tipos de regras de alerta que o Grafana Alerting oferece.
## Tipos de regras de alerta
**Regras gerenciadas pelo Grafana**
As regras gerenciadas pelo Grafana são o tipo de regra de alerta mais flexível. Elas permitem que você crie alertas que podem agir com base nos dados de qualquer uma das nossas fontes de dados compatíveis. Além de oferecer suporte a várias fontes de dados, você também pode adicionar expressões para transformar os dados e definir condições de alerta. Este é o único tipo de regra que permite alertas de várias fontes de dados em uma única definição de regra.
**Regras do Mimir e Loki**
Para criar alertas do Mimir ou Loki, você deve ter uma fonte de dados Prometheus compatível. Você pode verificar se a fonte de dados é compatível com a criação de regras via Grafana testando a fonte de dados e observando se a API Ruler é compatível.
**Regras de gravação**
As regras de gravação só estão disponíveis para fontes de dados Prometheus ou Loki compatíveis. As regras de gravação permitem que você pré-compute expressões frequentemente necessárias ou computacionalmente caras e salve seus resultados como um novo conjunto de séries temporais. Isso será útil se você quiser executar alertas em dados agregados ou se tiver dashboards que consultam expressões computacionalmente caras repetidamente.
## Recursos e conceitos-chave
A tabela a seguir inclui uma lista dos principais conceitos e recursos, e suas definições, projetados para ajudar você a aproveitar ao máximo o Grafana Alerting.
| Principal conceito ou recurso | Definição |
| --- | --- |
| Fontes de dados para alertas | Selecione as fontes de dados das quais você deseja consultar e visualizar métricas, logs e rastreamentos. |
| Provisionar para alertas | Gerencie os recursos de alertas e provisione-os no sistema do Grafana usando o provisionamento de arquivos ou o Terraform. |
| Alertmanager | Gerencia o roteamento e o agrupamento de instâncias de alertas. |
| Regra de alerta | Um conjunto de critérios de avaliação para quando uma regra de alerta deve ser acionada. Uma regra de alerta consiste em uma ou mais consultas e expressões, uma condição, a frequência da avaliação e a duração em que a condição é atendida. Uma regra de alerta pode produzir várias instâncias de alertas. |
| Instância de alerta | Uma instância de alerta é uma instância de uma regra de alerta. Uma regra de alerta unidimensional tem uma instância de alerta. Uma regra de alerta multidimensional tem uma ou mais instâncias de alertas. Uma única regra de alerta que corresponda a vários resultados, como CPU contra 10 VMs, é contabilizada como várias (neste caso, 10) instâncias de alerta. Esse número pode variar com o tempo. Por exemplo, uma regra de alerta que monitora o uso da CPU para todos VMs em um sistema tem mais instâncias de alerta à medida que VMs são adicionadas. Para obter mais informações sobre cotas de instâncias de alertas, consulte [Cota alcançada de erros](v9-alerting-managerules-grafana.md#v9-alerting-rule-quota-reached). |
| Grupo de alertas | O Alertmanager agrupa instâncias de alertas por padrão usando os rótulos da política de notificação raiz. Isso controla a desduplicação e os grupos de instâncias de alerta, que são enviadas aos pontos de contato. |
| Ponto de contato | Defina como seus contatos são notificados quando uma regra de alerta é acionada. |
| Modelos de mensagens | Crie modelos personalizados reutilizáveis e use-os em pontos de contato. |
| Política de notificação | Conjunto de regras para onde, quando e como os alertas são agrupados e roteados para os pontos de contato. |
| Rótulos e matchers de rótulos | Os rótulos identificam de forma exclusiva as regras de alertas. Eles vinculam as regras de alertas a silêncios e políticas de notificação, determinando qual política deve lidar com eles e quais regras de alerta devem ser silenciadas. |
| Silêncios | Interrompa as notificações de uma ou mais instâncias de alerta. A diferença entre um tempo de desativação de áudio e de silêncio é que um silêncio dura apenas por uma janela de tempo especificada, enquanto um tempo de desativação de áudio é recorrente em uma programação. Usa matcher de rótulos para silenciar instâncias de alertas. |
| Tempos de desativação de áudio | Especifique um intervalo de tempo em que você não deseja que novas notificações sejam geradas ou enviadas. Você também pode congelar notificações de alerta por períodos recorrentes, como durante um período de manutenção. Deve estar vinculado a uma política de notificação existente. |
# Fontes de dados
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Existem várias [fontes de dados](AMG-data-sources-builtin.md) compatíveis com o Grafana Alerting. Cada fonte de dados é compatível com um plug-in. Você pode usar uma das fontes de dados integradas listadas abaixo.
Estas são as fontes de dados compatíveis com o Amazon Managed Grafana.
+ [Conectar-se a uma fonte de dados Alertmanager](data-source-alertmanager.md)
+ [Conecte-se a uma fonte de CloudWatch dados da Amazon](using-amazon-cloudwatch-in-AMG.md)
+ [Conecte-se a uma fonte OpenSearch de dados do Amazon Service](using-Amazon-OpenSearch-in-AMG.md)
+ [Conecte-se a uma fonte AWS IoT SiteWise de dados](using-iotsitewise-in-AMG.md)
+ [Conecte-se a uma fonte AWS IoT TwinMaker de dados](AMG-iot-twinmaker.md)
+ [Conectar-se ao Amazon Managed Service for Prometheus e a fontes de dados de código aberto do Prometheus.](prometheus-data-source.md)
+ [Conectar-se a uma fonte de dados Amazon Timestream](timestream-datasource.md)
+ [Conectar-se a uma fonte de dados Amazon Athena](AWS-Athena.md)
+ [Conectar-se a uma fonte de dados do Amazon Redshift](AWS-Redshift.md)
+ [Conecte-se a uma fonte AWS X-Ray de dados](x-ray-data-source.md)
+ [Conectar-se a uma fonte de dados Azure Monitor](using-azure-monitor-in-AMG.md)
+ [Conectar-se a uma fonte de dados do Google Cloud Monitoring](using-google-cloud-monitoring-in-grafana.md)
+ [Conectar-se a uma fonte de dados Graphite](using-graphite-in-AMG.md)
+ [Conectar-se a uma fonte de dados InfluxDB](using-influxdb-in-AMG.md)
+ [Conectar-se a uma fonte de dados Loki](using-loki-in-AMG.md)
+ [Conectar-se a uma fonte de dados do Microsoft SQL Server](using-microsoft-sql-server-in-AMG.md)
+ [Conectar-se a uma fonte de dados MySQL](using-mysql-in-AMG.md)
+ [Conectar-se a uma fonte de dados OpenTSDB](using-opentsdb-in-AMG.md)
+ [Conectar-se a uma fonte de dados PostgreSQL](using-postgresql-in-AMG.md)
+ [Conectar-se a uma fonte de dados Jaeger](jaeger-data-source.md)
+ [Conectar-se a uma fonte de dados Zipkin](zipkin-data-source.md)
+ [Conectar-se a uma fonte de dados Tempo](tempo-data-source.md)
+ [Configurar uma fonte de TestData dados para testes](testdata-data-source.md)
# Sobre as regras de alerta
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Uma regra de alerta é um conjunto de critérios de avaliação que determina se uma instância de alerta será disparada. A regra consiste em uma ou mais consultas e expressões, uma condição, a frequência da avaliação e, opcionalmente, o período durante o qual a condição é atendida.
Enquanto consultas e expressões selecionam o conjunto de dados a ser avaliado, uma condição define o limite que um alerta deve atingir ou exceder para criar um alerta.
Um intervalo especifica com que frequência uma regra de alerta é avaliada. A duração, quando configurada, indica por quanto tempo uma condição deve ser atendida. As regras de alerta também podem definir o comportamento do alerta na ausência de dados.
**Topics**
+ [Tipos de regras de alerta](v9-alerting-explore-rules-types.md)
+ [Instâncias de alerta](v9-alerting-rules-instances.md)
+ [Namespaces e grupos](v9-alerting-rules-grouping.md)
+ [Modelos de notificação](v9-alerting-rules-notification-templates.md)
# Tipos de regras de alerta
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
O Grafana é compatível com vários tipos de regras de alerta. As seções a seguir explicarão suas vantagens e desvantagens e ajudarão você a escolher o tipo de alerta certo para seu caso de uso.
Regras gerenciadas pelo Grafana
As regras gerenciadas pelo Grafana são o tipo de regra de alerta mais flexível. Elas permitem que você crie alertas que podem atuar nos dados de qualquer uma das fontes de dados existentes.
Além de oferecer suporte a qualquer fonte de dados, você pode adicionar [expressões](v9-panels-query-xform-expressions.md) para transformar os dados e expressar condições de alerta.
Regras do Mimir, Loki e Cortex
Para criar alertas do Mimir, Loki ou Cortex, você deve ter uma fonte de dados Prometheus compatível. Você pode verificar se a fonte de dados é compatível testando a fonte de dados e verificando os detalhes se a API Ruler é compatível.
Regras de gravação
As regras de gravação só estão disponíveis para fontes de dados Prometheus compatíveis, como Mimir, Loki e Cortex.
Uma regra de gravação permite que você salve o resultado de uma expressão em um novo conjunto de séries temporais. Isso será útil se você quiser executar alertas em dados agregados ou se tiver dashboards que consultam a mesma expressão repetidamente.
Leia mais sobre as [regras de gravação](https://prometheus.io/docs/prometheus/latest/configuration/recording_rules/) no Prometheus.
# Instâncias de alerta
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Os alertas gerenciados pelo Grafana são compatíveis com alertas multidimensionais. Cada regra de alerta pode criar várias instâncias de alerta. Isso será eficaz se você estiver observando várias séries em uma única expressão.
Considere a seguinte expressão PromQL:
```
sum by(cpu) (
rate(node_cpu_seconds_total{mode!="idle"}[1m])
)
```
Uma regra usando essa expressão criará tantas instâncias de alerta quanto a quantidade CPUs observada durante a avaliação, permitindo que uma única regra relate o status de cada CPU.
# Namespaces e grupos
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Os alertas podem ser organizados usando pastas para regras gerenciadas pelo Grafana e namespaces para regras e nomes de grupos do Mimir, Loki ou Prometheus.
**Namespaces**
Ao criar regras gerenciadas pelo Grafana, a pasta pode ser usada para realizar o controle de acesso e conceder ou negar acesso a todas as regras em uma pasta específica.
**Groups (Grupos)**
Todas as regras em um grupo são avaliadas no mesmo **intervalo**.
As regras de alerta e as regras de gravação em um grupo sempre serão avaliadas **sequencialmente**, o que significa que nenhuma regra será avaliada ao mesmo tempo e em ordem de aparição.
**dica**
Se você quiser que as regras sejam avaliadas simultaneamente e com intervalos diferentes, considere armazená-las em grupos diferentes.
# Modelos de notificação
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
As notificações enviadas por meio de pontos de contato são criadas usando modelos de notificação. Os modelos padrão do Grafana são baseados no [sistema de modelos do Go](https://golang.org/pkg/text/template), em que alguns campos são avaliados como texto, enquanto outros são avaliados como HTML (o que pode afetar o escape).
O modelo padrão [default\$1template.go](https://github.com/grafana/alerting/blob/main/templates/default_template.go) é uma referência útil para modelos personalizados.
Como a maioria dos campos de ponto de contato pode ser modelada, você pode criar modelos personalizados reutilizáveis e usá-los em vários pontos de contato. Para saber mais sobre notificações personalizadas usando modelos, consulte[Personalizar notificações](v9-alerting-notifications.md).
**Modelos aninhados**
Você pode incorporar modelos em outros modelos.
Por exemplo, você pode definir um fragmento de modelo usando a palavra-chave `define`.
```
{{ define "mytemplate" }}
{{ len .Alerts.Firing }} firing. {{ len .Alerts.Resolved }} resolved.
{{ end }}
```
Você pode então incorporar modelos personalizados nesse fragmento usando a palavra-chave `template`. Por exemplo:
```
Alert summary:
{{ template "mytemplate" . }}
```
Você pode usar qualquer uma das opções de modelo incorporado a seguir para incorporar modelos personalizados.
| Nome | Observações |
| --- | --- |
| `default.title` | Exibe informações de status de alto nível. |
| `default.message` | Fornece um resumo formatado dos alertas disparados e resolvidos. |
| `teams.default.message` | Semelhante a `default.messsage`, formatado para o Microsoft Teams. |
**HTML em modelos de notificação**
O HTML nos modelos de notificação de alerta é de escape. Não oferecemos suporte à renderização de HTML na notificação resultante.
Alguns notificadores são compatíveis com métodos alternativos para alterar o aspecto visual da notificação resultante. Por exemplo, o Grafana instala o modelo básico para alertar e-mails para. `/public/emails/ng_alert_notification.html`. Você pode editar esse arquivo para alterar o aspecto visual de todos os e-mails de alerta.
# Alertas sobre dados numéricos
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Este tópico descreve como o Grafana lida com alertas em dados numéricos em vez de dados de séries temporais.
Entre determinadas fontes de dados, os dados numéricos que não são séries temporais podem ser notificados diretamente ou passados para as Expressões do lado do servidor (SSE). Isso permite mais processamento e eficiência resultante na fonte de dados, além de simplificar as regras de alertas. Ao alertar sobre dados numéricos em vez de dados de séries temporais, não há necessidade de reduzir cada série temporal rotulada em um único número. Em vez disso, os números rotulados são retornados para o Grafana.
**Dados tabulares**
Este recurso é compatível com fontes de dados de backend que consultam dados tabulares:
+ Fontes de dados SQL, como MySQL, Postgres, MSSQL e Oracle.
+ Os serviços baseados no Azure Kusto: Azure Monitor (Logs), Azure Monitor (Azure Resource Graph) e Azure Data Explorer.
Uma consulta com alertas gerenciados pelo Grafana ou SSE será considerada numérica com essas fontes de dados, se:
+ A opção “Formatar como” estiver definida como “Tabela” na consulta da fonte de dados.
+ A resposta da tabela retornada ao Grafana da consulta incluir apenas uma coluna numérica (por exemplo, int, double ou float) e, opcionalmente, colunas de string adicionais.
Se houver colunas de string, essas colunas se tornarão rótulos. O nome da coluna torna-se o nome do rótulo, e o valor de cada linha torna-se o valor do rótulo correspondente. Se várias linhas forem retornadas, então cada linha deverá ter seus rótulos identificados de forma exclusiva.
**Exemplo**
Para uma tabela MySQL chamada “”: DiskSpace
| Hora | Host | Disk | PercentFree |
| --- | --- | --- | --- |
| 7 de junho de 2021 | web1 | /etc | 3 |
| 7 de junho de 2021 | web2 | /var | 4 |
| 7 de junho de 2021 | web3 | /var | 8 |
| ... | ... | ... | ... |
Você pode consultar a filtragem de dados a tempo, mas sem retornar a série temporal ao Grafana. Por exemplo, um alerta que será acionado por host, disco quando houver menos de 5% de espaço livre:
```
SELECT Host , Disk , CASE WHEN PercentFree < 5.0 THEN PercentFree ELSE 0 END FROM (
SELECT
Host,
Disk,
Avg(PercentFree)
FROM DiskSpace
Group By
Host,
Disk
Where __timeFilter(Time)
```
Esta consulta retornará a seguinte resposta de tabela ao Grafana:
| Host | Disk | PercentFree |
| --- | --- | --- |
| web1 | /etc | 3 |
| web2 | /var | 4 |
| web3 | /var | 0 |
Quando esta consulta é usada como **condição** em uma regra de alerta, o que não for zero será um alerta. Como resultado, três instâncias de alerta são produzidas:
| Rótulos | Status |
| --- | --- |
| \$1Host=web1,disk=/etc\$1 | Geração de alertas |
| \$1Host=web2,disk=/var\$1 | Geração de alertas |
| \$1Host=web3,disk=/var\$1 | Normal |
# Rótulos e anotações
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Rótulos e anotações contêm informações sobre um alerta. Tanto os rótulos quanto as anotações têm a mesma estrutura: um conjunto de valores nomeados; no entanto, seus usos pretendidos são diferentes. Um exemplo de rótulo, ou anotação equivalente, pode ser `alertname="test"`.
A principal diferença entre um rótulo e uma anotação é que os rótulos são usados para diferenciar um alerta de todos os outros alertas, enquanto as anotações são usadas para adicionar informações adicionais a um alerta existente.
Por exemplo, considere dois alertas de CPU de alta performance: um para `server1` e outro para `server2`. Neste exemplo, podemos ter um rótulo denominado `server`, em que o primeiro alerta tem o rótulo `server="server1"` e o segundo alerta tem o rótulo `server="server2"`. No entanto, talvez também queiramos adicionar uma descrição a cada alerta, como `"The CPU usage for server1 is above 75%."`, em que `server1` e `75%` são substituídos pelo nome e pelo uso da CPU do servidor (consulte a documentação sobre [Modelos de rótulos e anotações](v9-alerting-explore-labels-templating.md) para saber como fazer isso). Esse tipo de descrição seria mais adequado como uma anotação.
## Rótulos
Os rótulos contêm informações que identificam um alerta. Um exemplo de rótulo pode ser `server=server1`. Cada alerta pode ter mais de um rótulo, e o conjunto completo de rótulos de um alerta é denominado seu conjunto de rótulos. É esse conjunto de rótulos que identifica o alerta.
Por exemplo, um alerta pode ter o rótulo definido como `{alertname="High CPU usage",server="server1"}`, enquanto outro alerta pode ter o rótulo definido como `{alertname="High CPU usage",server="server2"}`. Eles são dois alertas separados porque, embora seus rótulos de `alertname` sejam iguais, os rótulos de `server` são diferentes.
O rótulo definido para um alerta é uma combinação de rótulos da fonte de dados, rótulos personalizados da regra de alerta e vários rótulos reservados, como `alertname`.
**Rótulos personalizados**
Os rótulos personalizados são rótulos adicionais da regra de alerta. Assim como as anotações, os rótulos personalizados devem ter um nome, e seu valor pode conter uma combinação de texto e código de modelo que é avaliada quando um alerta é disparado. A documentação sobre como criar modelos de rótulos personalizados pode ser encontrada [aqui](v9-alerting-explore-labels-templating.md).
Ao usar rótulos personalizados com modelos, é importante garantir que o valor do rótulo não mude entre avaliações consecutivas da regra de alerta, pois isso acabará criando um grande número de diferentes alertas. No entanto, não há problema em o modelo produzir valores de rótulo diferentes para diversos alertas. Por exemplo, não coloque o valor da consulta em um rótulo personalizado, pois isso acabará criando um novo conjunto de alertas sempre que o valor for alterado. Em vez disso, use anotações.
Também é importante garantir que o rótulo definido para um alerta não tenha dois ou mais rótulos com o mesmo nome. Se um rótulo personalizado tiver o mesmo nome de um rótulo da fonte de dados, ele substituirá esse rótulo. No entanto, se um rótulo personalizado tiver o mesmo nome de um rótulo reservado, o rótulo personalizado será omitido do alerta.
## Anotações
As anotações são pares nomeados que adicionam informações extras aos alertas existentes. Há várias anotações sugeridas no Grafana, como `description`, `summary`, `runbook_url`, `dashboardUId` e `panelId`. Assim como os rótulos personalizados, as anotações devem ter um nome, e seu valor pode conter uma combinação de texto e código de modelo que é avaliada quando um alerta é disparado. Se uma anotação contiver código de modelo, o modelo será avaliado uma vez quando o alerta for disparado. Ele não será reavaliado, mesmo quando o alerta tiver sido resolvido. A documentação sobre como criar modelos de anotações pode ser encontrada [aqui](v9-alerting-explore-labels-templating.md).
# Como funciona a correspondência de rótulos
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Use rótulos e matchers de rótulos para vincular as regras de alerta aos silêncios e às políticas de notificação. Isso permite uma maneira muito flexível de gerenciar as instâncias de alerta, especificar qual política deve lidar com elas e quais alertas silenciar.
Um matcher de rótulo consiste em três partes distintas: o **rótulo**, o **valor** e o **operador**.
+ O campo **Rótulo** é o nome do rótulo correspondente. Ele deve ser exatamente igual ao nome do rótulo.
+ O campo **Valor** corresponde ao valor correspondente para o nome do **Rótulo** especificado. A correspondência depende do valor do **Operador**.
+ O campo **Operador** é o operador que corresponde ao valor do rótulo. Os operadores disponíveis são:
| Operador | Description |
| --- | --- |
| `=` | Selecione rótulos que sejam exatamente iguais ao valor. |
| `!=` | Selecione rótulos que não sejam iguais ao valor. |
| `=~` | Selecione rótulos que correspondam ao regex do valor. |
| `!~` | Selecione rótulos que não correspondam ao regex do valor. |
Se você estiver usando vários matchers de rótulos, eles serão combinados usando o operador lógico AND. Isso significa que todos os matchers devem corresponder a fim de vincular uma regra a uma política.
**Exemplo de cenário**
Se você definir o seguinte conjunto de rótulos para seu alerta:
```
{ foo=bar, baz=qux, id=12 }
```
então:
+ Um matcher de rótulo definido como `foo=bar` corresponde a essa regra de alerta.
+ Um matcher de rótulo definido como `foo!=bar` *não* corresponde a essa regra de alerta.
+ Um matcher de rótulo definido como `id=~[0-9]+` corresponde a essa regra de alerta.
+ Um matcher de rótulo definido como `baz!~[0-9]+` corresponde a essa regra de alerta.
+ Dois marcadores de rótulos definidos como `foo=bar` e `id=~[0-9]+` correspondem a essa regra de alerta.
# Rótulos no Grafana Alerting
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Este tópico explica por que os rótulos são um componente fundamental dos alertas.
+ O conjunto completo de rótulos para um alerta é o que identifica exclusivamente um alerta nos alertas do Grafana.
+ O Alertmanager usa rótulos para corresponder alertas a silêncios e grupos de alertas nas políticas de notificação.
+ A interface de usuário de alertas mostra rótulos para cada instância de alerta gerada durante a avaliação dessa regra.
+ Os pontos de contato podem acessar rótulos para gerar notificações dinamicamente que contêm informações específicas do alerta que está resultando em uma notificação.
+ Você pode adicionar rótulos a uma [regra de alerta](v9-alerting-managerules.md). Os rótulos são configuráveis manualmente, usam funções de modelo e podem fazer referência a outros rótulos. Os rótulos adicionados a uma regra de alerta têm precedência no caso de um conflito entre os rótulos (exceto no caso dos rótulos reservados do Grafana; veja abaixo para obter mais informações).
**Compatibilidade com um Alertmanager externo**
O Alertmanager integrado do Grafana é compatível com chaves e valores de rótulos Unicode. Se você estiver usando um Prometheus Alertmanager externo, as chaves de rótulos deverão ser compatíveis com o [modelo de dados](https://prometheus.io/docs/concepts/data_model/#metric-names-and-labels). Isso significa que as chaves de rótulos deverão conter apenas **letras ASCII**, **números** e **sublinhados** e corresponder ao regex `[a-zA-Z_][a-zA-Z0-9_]*`. Quaisquer caracteres inválidos serão removidos ou substituídos pelo mecanismo do Grafana Alerting antes de serem enviados ao Alertmanager externo de acordo com as seguintes regras:
+ `Whitespace` será removido.
+ `ASCII characters` serão substituídos por `_`.
+ `All other characters` serão substituídos por sua representação hexadecimal em minúsculas. Se este for o primeiro caractere, ele será prefixado com `_`.
**nota**
Se várias chaves de rótulos forem limpas com relação ao mesmo valor, as duplicatas terão um hash curto do rótulo original anexado como sufixo.
**Rótulos reservados do Grafana**
**nota**
Os rótulos prefixados com `grafana_` são reservados pelo Grafana para uso especial. Se um rótulo configurado manualmente for adicionado começando com `grafana_`, ele poderá ser substituído em caso de conflito.
Os rótulos reservados do Grafana podem ser usados da mesma forma que os rótulos configurados manualmente. A lista atual de rótulos reservados disponíveis é:
| Rótulo | Description |
| --- | --- |
| grafana\$1folder | Título da pasta que contém o alerta. |
# Modelos de rótulos e anotações
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
No Grafana, você cria modelos de rótulos e anotações da mesma forma como no Prometheus. Se você já usou o Prometheus antes, então deve estar familiarizado com as variáveis `$labels` e `$value`, que contêm os rótulos e o valor do alerta. Você pode usar as mesmas variáveis no Grafana, mesmo que o alerta não use uma fonte de dados Prometheus. Se você nunca usou o Prometheus antes, não se preocupe, pois cada uma dessas variáveis e como modelá-las serão explicadas conforme você avançar nesta página.
## Linguagem de modelos do Go
Os modelos para rótulos e anotações são escritos na linguagem de modelos do Go, [texto/modelo](https://pkg.go.dev/text/template).
**Tags de abertura e fechamento**
Em texto/modelo, os modelos começam com `{{` e terminam com `}}`, independentemente de o modelo imprimir uma variável ou executar estruturas de controle, como instruções if. Isso é diferente de outras linguagens de modelos, como Jinja, em que a impressão de uma variável usa `{{` e `}}` e as estruturas de controle usam `{%` e `%}`.
**Print (Imprimir)**
Para imprimir o valor de algo, use `{{` e `}}`. Você pode imprimir o resultado de uma função ou valor de uma variável. Por exemplo, para imprimir a variável `$labels`, você deve escrever o seguinte:
```
{{ $labels }}
```
**Iterar em rótulos**
Para iterar em cada rótulo em `$labels`, você pode usar um `range`. Aqui, `$k` refere-se ao nome e `$v` refere-se ao valor do rótulo atual. Por exemplo, se a consulta retornasse um rótulo `instance=test`, então `$k` seria `instance` e `$v`seria `test`.
```
{{ range $k, $v := $labels }}
{{ $k }}={{ $v }}
{{ end }}
```
## Os rótulos, valores e variáveis de valores
**A variável de rótulos**
A variável `$labels` contém os rótulos da consulta. Por exemplo, uma consulta que verifica se uma instância está inativa pode retornar um rótulo de instância com o nome da instância que está inativa. Por exemplo, suponha que você tenha uma regra de alerta que é disparada quando uma das instâncias fica inativa por mais de cinco minutos. Você deseja adicionar um resumo ao alerta que informa qual instância está inativa. Com a variável `$labels`, você pode criar um resumo que imprima o rótulo da instância no resumo:
```
Instance {{ $labels.instance }} has been down for more than 5 minutes
```
**Rótulos com pontos**
Se o rótulo que você deseja imprimir contiver um ponto (ponto final) em seu nome, usar o mesmo ponto no modelo não funcionará:
```
Instance {{ $labels.instance.name }} has been down for more than 5 minutes
```
Isso ocorre porque o modelo está tentando usar um campo não existente denominado `name` em `$labels.instance`. Em vez disso, você deve usar a função `index`, que imprime o rótulo `instance.name` na variável `$labels`:
```
Instance {{ index $labels "instance.name" }} has been down for more than 5 minutes
```
**O valor da variável**
A variável `$value` funciona de forma diferente do Prometheus. No `$value` do Prometheus, há um número de ponto flutuante que contém o valor da expressão, mas no Grafana é uma string que contém os rótulos e valores de todas as expressões de limite, de redução, matemáticas e de condições clássicas dessa regra de alerta. Ela não contém os resultados das consultas, pois podem retornar de 10 a 10 mil linhas ou métricas.
Se você fosse usar a variável `$value` no resumo de um alerta:
```
{{ $labels.service }} has over 5% of responses with 5xx errors: {{ $value }})
```
O resumo pode ficar como abaixo:
```
api has an over 5% of responses with 5xx errors: [ var='B' labels={service=api} value=6.789 ]
```
Aqui, `var='B'` refere-se à expressão com o RefID B. No Grafana, todas as consultas e expressões são identificadas por um RefID que identifica cada consulta e expressão em uma regra de alerta. Da mesma forma, `labels={service=api}` refere-se aos rótulos e `value=6.789` refere-se ao valor.
Você deve ter observado que não há nenhum RefID A. Isso ocorre porque, na maioria das regras de alerta, o RefID A refere-se a uma consulta, e como as consultas podem retornar muitas linhas ou séries temporais, elas não estão incluídas em `$value`.
**A variável de valores**
Se a variável `$value` contiver mais informações do que você precisa, é possível imprimir os rótulos e o valor de expressões individuais usando `$values`. Ao contrário de `$value`, a variável `$values` é uma tabela de objetos que contêm os rótulos e valores de ponto flutuante de cada expressão, indexados por seu RefID.
Se você imprimir o valor da expressão com o RefID `B` no resumo do alerta:
```
{{ $labels.service }} has over 5% of responses with 5xx errors: {{ $values.B }}%
```
O resumo conterá apenas o valor:
```
api has an over 5% of responses with 5xx errors: 6.789%
```
No entanto, enquanto `{{ $values.B }}` imprime o número 6.789, na verdade é uma string, pois você estar imprimindo o objeto que contém os rótulos e o valor do RefID B, não o valor de ponto flutuante de B. Para usar o valor de ponto flutuante do RefID B, você deve usar o campo `Value` de `$values.B`. Se você fosse humanizar o valor do ponto flutuante no resumo de um alerta:
```
{{ $labels.service }} has over 5% of responses with 5xx errors: {{ humanize $values.B.Value }}%
```
**Nenhum dado, erros de runtime e tempos limite**
Se a consulta na regra de alerta não retornar nenhum dado ou falhar devido a um erro na fonte de dados ou ao tempo limite, todas as expressões de limite, redução e matemáticas que usem essa consulta também não retornarão nenhum dado ou retornarão um erro. Quando isso acontecer, essa expressão estará ausente de `$values`. É uma boa prática verificar se um RefID está presente antes de usá-lo, caso contrário, o modelo será pausado se sua consulta não retornar nenhum dado ou retornar um erro. É possível fazer isso usando uma instrução if:
```
{{ if $values.B }}{{ $labels.service }} has over 5% of responses with 5xx errors: {{ humanizePercentage $values.B.Value }}{{ end }}
```
## Condições clássicas
Se a regra usar condições clássicas em vez das expressões de limite, redução e matemáticas, a variável `$values` será indexada pelo ID de referência e pela posição da condição na condição clássica. Por exemplo, se você tiver uma condição clássica com o RefID B que contém duas condições, então `$values` conterá duas condições `B0` e `B1`.
```
The first condition is {{ $values.B0 }}, and the second condition is {{ $values.B1 }}
```
## Funções
As seguintes funções também estão disponíveis ao expandir anotações e rótulos:
**args**
A função `args` converte uma lista de objetos em um mapa com as chaves arg0, arg1 etc. O objetivo é permitir que vários argumentos sejam transmitidos para os modelos.
**Exemplo**
```
{{define "x"}}{{.arg0}} {{.arg1}}{{end}}{{template "x" (args 1 "2")}}
```
```
1 2
```
**externalURL**
A função `externalURL` retorna o URL externo do servidor Grafana, conforme configurado nos arquivos ini.
**Exemplo**
```
{{ externalURL }}
```
```
https://example.com/grafana
```
**graphLink**
A função `graphLink` retorna o caminho para a visualização de grafo em [Explore na versão 9 do Grafana](v9-explore.md) para a expressão e a fonte de dados fornecidas.
**Exemplo**
```
{{ graphLink "{\"expr\": \"up\", \"datasource\": \"gdev-prometheus\"}" }}
```
```
/explore?left=["now-1h","now","gdev-prometheus",{"datasource":"gdev-prometheus","expr":"up","instant":false,"range":true}]
```
**humanize**
A função `humanize` humaniza os números decimais.
**Exemplo**
```
{{ humanize 1000.0 }}
```
```
1k
```
**humanize1024**
A `humanize1024` funciona de forma semelhante a `humanize`, mas usa 1024 como base em vez de 1000.
**Exemplo**
```
{{ humanize1024 1024.0 }}
```
```
1ki
```
**humanizeDuration**
A função `humanizeDuration` humaniza a duração em segundos.
**Exemplo**
```
{{ humanizeDuration 60.0 }}
```
```
1m 0s
```
**humanizePercentage**
A função `humanizePercentage` humaniza um valor de proporção para uma porcentagem.
**Exemplo**
```
{{ humanizePercentage 0.2 }}
```
```
20%
```
**humanizeTimestamp**
A `humanizeTimestamp` função humaniza um carimbo de data e hora do Unix.
**Exemplo**
```
{{ humanizeTimestamp 1577836800.0 }}
```
```
2020-01-01 00:00:00 +0000 UTC
```
**match**
A função `match` combina o texto com um padrão de expressão regular.
**Exemplo**
```
{{ match "a.*" "abc" }}
```
```
true
```
**pathPrefix**
A função `pathPrefix` retorna o caminho do servidor Grafana, conforme configurado nos arquivos ini.
**Exemplo**
```
{{ pathPrefix }}
```
```
/grafana
```
**tableLink**
A função `tableLink` retorna o caminho para a visualização tabular em [Explore na versão 9 do Grafana](v9-explore.md) para a expressão e fonte de dados fornecidas.
**Exemplo**
```
{{ tableLink "{\"expr\": \"up\", \"datasource\": \"gdev-prometheus\"}" }}
```
```
/explore?left=["now-1h","now","gdev-prometheus",{"datasource":"gdev-prometheus","expr":"up","instant":true,"range":false}]
```
**title**
A função `title` coloca em maiúscula o primeiro caractere de cada palavra.
**Exemplo**
```
{{ title "hello, world!" }}
```
```
Hello, World!
```
**toLower**
A função `toLower` retorna todo o texto em letras minúsculas.
**Exemplo**
```
{{ toLower "Hello, world!" }}
```
```
hello, world!
```
**toUpper**
A função `toUpper` retorna todo o texto em maiúsculas.
**Exemplo**
```
{{ toUpper "Hello, world!" }}
```
```
HELLO, WORLD!
```
**reReplaceAll**
A função `reReplaceAll` substitui o texto correspondente à expressão regular.
**Exemplo**
```
{{ reReplaceAll "localhost:(.*)" "example.com:$1" "localhost:8080" }}
```
```
example.com:8080
```
# Estado e integridade das regras de alertas
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
O estado e a integridade das regras de alertas ajudam você a entender vários indicadores-chave de status sobre os alertas.
Há três componentes principais: *estado da regra de alerta*, *estado da instância de alerta* e *integridade da regra de alerta*. Embora relacionado, cada componente transmite informações sutilmente diferentes.
**Estado da regra de alerta**
Uma regra de alerta de pode estar em um dos seguintes estados:
| Estado | Description |
| --- | --- |
| Normal | Nenhuma das séries temporais retornadas pelo mecanismo de avaliação está em um estado `Pending` ou `Firing`. |
| Pendente | Pelo menos uma série temporal retornada pelo mecanismo de avaliação é `Pending`. |
| Disparar | Pelo menos uma série temporal retornada pelo mecanismo de avaliação é `Firing`. |
**nota**
Os alertas mudam primeiro para `pending` e depois para `firing`, portanto, serão necessários pelo menos dois ciclos de avaliação antes que um alerta seja disparado.
**Estado da instância de alerta**
Uma instância de alerta de pode estar em um dos seguintes estados:
| Estado | Description |
| --- | --- |
| Normal | O estado de um alerta que não está sendo disparado nem está pendente, tudo está funcionando corretamente. |
| Pendente | O estado de um alerta que esteve ativo por menos tempo do que a duração do limite configurado. |
| Geração de alertas | O estado de um alerta que esteve ativo por mais tempo do que a duração do limite configurado. |
| NoData | Nenhum dado foi recebido para a janela de tempo configurada. |
| Erro | O erro que ocorreu ao tentar avaliar uma regra de alerta. |
**Integridade da regra de alerta**
Uma regra de alerta pode ter um dos seguintes status de saúde:
| Estado | Description |
| --- | --- |
| Ok | Nenhum erro ao avaliar uma regra de alerta. |
| Erro | Ocorreu um erro ao avaliar uma regra de alerta. |
| NoData | A ausência de dados em pelo menos uma série temporal retornada durante a avaliação de uma regra. |
**Alertas especiais para `NoData` e `Error`**
Quando a avaliação de uma regra de alerta produz um estado `NoData` ou `Error`, o Grafana Alerting gera instâncias de alerta com os seguintes rótulos adicionais:
| Rótulo | Description |
| --- | --- |
| alertname | `DatasourceNoData` ou `DatasourceError`, dependendo do estado. |
| datasource\$1uid | O UID da fonte de dados que causou o estado. |
Você pode lidar com esses alertas da mesma forma que os alertas regulares, adicionando um silêncio, uma rota para um ponto de contato etc.
# Pontos de contato
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Use pontos de contato para definir como seus contatos são notificados quando uma regra de alerta é disparada. Um ponto de contato pode ter um ou mais tipos de ponto de contato, por exemplo, e-mail, Slack, webhook etc. Quando uma regra de alerta é disparada, uma notificação é enviada para todos os tipos de pontos de contato listados para um ponto de contato. Os pontos de contato podem ser configurados para o Grafana Alertmanager, bem como para alertmanagers externos.
Você também pode usar modelos de notificação para personalizar mensagens de notificação para tipos de pontos de contato.
**Tipos de pontos de contato compatíveis**
A tabela a seguir lista os tipos de ponto de contato compatíveis com o Grafana.
| Nome | Tipo |
| --- | --- |
| Amazon SNS | `sns` |
| OpsGenie | `opsgenie` |
| PagerDuty | `pagerduty` |
| Slack | `slack` |
| VictorOps | `victorops` |
Para obter mais informações sobre pontos de contato, consulte [Trabalhar com pontos de contato](v9-alerting-contact-points.md) e [Personalizar notificações](v9-alerting-notifications.md).
# Notificações
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
O Grafana usa Alertmanagers para enviar notificações de alertas disparados e resolvidos. O Grafana tem seu próprio Alertmanager, indicado como “Grafana” na interface do usuário, mas também é compatível com o envio de notificações de outros Alertmanagers, como o [Prometheus Alertmanager](https://prometheus.io/docs/alerting/latest/alertmanager/). O Grafana Alertmanager usa políticas de notificação e pontos de contato para configurar como e onde uma notificação é enviada, com que frequência ela deve ser enviada e se todos os alertas devem ser enviados na mesma notificação, enviados em notificações agrupadas com base em um conjunto de rótulos ou como notificações separadas.
## Políticas de notificação
As políticas de notificação controlam quando e para onde as notificações são enviadas. Uma política de notificação pode escolher enviar todos os alertas juntos na mesma notificação, enviar alertas em notificações agrupadas com base em um conjunto de rótulos ou enviar alertas como notificações separadas. Você pode configurar cada política de notificação para controlar a frequência com que as notificações devem ser enviadas, além de ter um ou mais tempos de desativação de áudio para impedir as notificações em determinados horários do dia e em determinados dias da semana.
As políticas de notificação são organizadas em uma estrutura de árvore em que, na raiz da árvore, há uma política de notificação chamada política raiz. Só pode haver uma política raiz, e a política raiz não pode ser excluída.
Políticas de roteamento específicas são secundárias da política raiz e podem ser usadas para combinar todos os alertas ou um subconjunto de alertas com base em um conjunto de rótulos correspondentes. Uma política de notificação corresponde a um alerta quando os rótulos coincidentes correspondem aos rótulos no alerta.
Uma política de roteamento específica pode ter suas próprias políticas secundárias, chamadas de políticas aninhadas, que permitem uma correspondência adicional de alertas. Um exemplo de uma política de roteamento específica pode ser enviar alertas de infraestrutura para a equipe de operações, enquanto uma política secundária pode ser enviar alertas de alta prioridade para o PagerDuty e alertas de baixa prioridade para o Slack.
Todos os alertas, independentemente de seus rótulos, correspondem à política raiz. No entanto, quando a política raiz recebe um alerta, ela examina cada política de roteamento específica e envia o alerta para a primeira política de roteamento específica que corresponda ao alerta. Se a política de roteamento específica tiver outras políticas secundárias, ela poderá tentar corresponder o alerta com uma de suas políticas aninhadas. Se nenhuma política aninhada corresponder ao alerta, a política de roteamento específica será a política correspondente. Se não houver políticas de roteamento específicas, ou se nenhuma política de roteamento específica corresponder ao alerta, então a política raiz será a política correspondente.
## Pontos de contato
Os pontos de contato contêm a configuração para enviar notificações. Um ponto de contato é uma lista de integrações, cada uma das quais envia uma notificação para um endereço de e-mail, serviço ou URL específico. Os pontos de contato podem ter várias integrações do mesmo tipo ou uma combinação de integrações de diferentes tipos. Por exemplo, um ponto de contato pode conter uma integração com o PagerDuty; uma integração com o PagerDuty e o Slack; ou uma integração com o PagerDuty, uma integração com o Slack e duas integrações com o Amazon SNS. Você também pode configurar um ponto de contato sem integrações. Nesse caso, nenhuma notificação será enviada.
Um ponto de contato não pode enviar notificações até que tenha sido adicionado a uma política de notificação. Uma política de notificação só pode enviar alertas para um ponto de contato, mas um ponto de contato pode ser adicionado a várias políticas de notificação ao mesmo tempo. Quando um alerta corresponde a uma política de notificação, o alerta é enviado ao ponto de contato nessa política de notificação, que então envia uma notificação para cada integração em sua configuração.
**nota**
Para obter informações sobre integrações compatíveis para pontos de contato, consulte [Pontos de contato](v9-alerting-explore-contacts.md).
## Notificações com modelos
Você pode personalizar as notificações com modelos. Por exemplo, modelos podem ser usados para alterar o título e a mensagem das notificações enviadas ao Slack.
Os modelos não se limitam a uma integração individual ou ponto de contato, mas podem ser usados em várias integrações no mesmo ponto de contato, e até mesmo em integrações entre diferentes pontos de contato. Por exemplo, um usuário do Grafana pode criar um modelo denominado `custom_subject_or_title` e usá-lo para criar modelos de assuntos no PagerDuty e títulos de mensagens do Slack sem precisar criar dois modelos separados.
Todos os modelos de notificações são escritos na [linguagem de modelo do Go](https://pkg.go.dev/text/template) e estão na guia Pontos de contato na página de alertas.
## Silêncios
Você pode usar silêncios para desativar o áudio das notificações de uma ou mais regras de disparo. Os silêncios não impedem que os alertas sejam disparados ou resolvidos, nem ocultam os alertas de disparo na interface do usuário. Um silêncio dura pelo período definido, que pode ser configurado em minutos, horas, dias, meses ou anos.