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á.
# Visão geral do
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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).
Se você está apenas começando ou é um usuário mais experiente do Grafana Alerting, saiba mais sobre os conceitos básicos e os recursos disponíveis que ajudam você a criar, gerenciar e responder aos alertas, e melhore a capacidade da sua equipe de resolver problemas rapidamente.
## Princípios
Nos sistemas de alerta baseados no Prometheus, você tem um gerador de alertas que cria alertas e um receptor de alertas que recebe alertas. Por exemplo, o Prometheus é um gerador de alertas e é responsável por avaliar as regras de alerta, enquanto o Alertmanager é um receptor de alertas e é responsável por agrupar, inibir, silenciar e enviar notificações sobre alertas disparados e resolvidos.
O Grafana Alerting é baseado no modelo Prometheus de projetar sistemas de alerta. Ele tem um gerador de alertas interno responsável por programar e avaliar as regras de alerta, bem como um receptor interno de alertas responsável por agrupar, inibir, silenciar e enviar notificações. O Grafana não usa o Prometheus como seu gerador de alertas porque o Grafana Alerting precisa funcionar com muitas outras fontes de dados além do Prometheus. No entanto, ele usa o Alertmanager como seu receptor de alertas.
Os alertas são enviados ao receptor de alertas, onde são roteados, agrupados, inibidos, silenciados e notificados. Em alertas do Grafana, o receptor de alerta padrão é o Alertmanager incorporado ao Grafana, conhecido como Grafana Alertmanager. No entanto, você também pode usar outros Alertmanagers, denominados [Alertmanagers externos](v10-alerting-setup-alertmanager.md).
## Conceitos básicos
Abaixo, é apresentada uma visão geral das diferentes partes do Grafana Alerting.
### Regras de alerta
Uma regra de alerta é um conjunto de critérios que determinam quando um alerta deve ser disparado. Ele consiste em uma ou mais consultas e expressões, uma condição que precisa ser atendida, um intervalo que determina a frequência com que a regra de alerta é avaliada e um período durante o qual a condição deve ser atendida para que um alerta seja disparado.
As regras de alerta são avaliadas no seu intervalo, e cada regra de alerta pode ter zero, um ou qualquer quantidade de alertas disparados de uma vez. O estado da regra de alerta é determinado pelo alerta mais `severe`, que pode ser Normal, Pendente ou Disparado. Por exemplo, se pelo menos um dos alertas de uma regra de alerta estiver sendo disparado, a regra de alerta também será disparada. A integridade de uma regra de alerta é determinada pelo status de sua avaliação mais recente. Eles podem ser OK, Erro NoData e.
Um recurso muito importante das regras de alerta é que elas são compatíveis com anotações e rótulos personalizados. Isso permite que você instrumente alertas com metadados adicionais, como resumos e descrições, e adicione rótulos extras para rotear alertas para políticas de notificação específicas.
### Alertas
Os alertas são identificados exclusivamente por conjuntos de key/value pares chamados de rótulos. Cada chave é um nome de rótulo, e cada valor é um valor de rótulo. Por exemplo, um alerta pode ter os rótulos `foo=bar`, e outro alerta pode ter os rótulos `foo=baz`. Um alerta pode ter vários rótulos, como `foo=bar,bar=baz`, mas não pode ter o mesmo rótulo duas vezes, como `foo=bar,foo=baz`. Dois alertas também não podem ter os mesmos rótulos e, se dois alertas tiverem os mesmos rótulos, como `foo=bar,bar=baz` e `foo=bar,bar=baz`, um dos alertas será descartado. Os alertas são resolvidos quando a condição na regra de alerta não é mais atendida ou a regra de alerta foi excluída.
Nos alertas gerenciados pelo Grafana, os alertas podem estar nos estados Normal, Pendente, Alerta, Nenhum dado ou Erro. Nos alertas gerenciados da fonte de dados, como Mimir e Loki, os alertas podem estar em Normal, Pendente e Alerta, mas não NoData em Erro.
### Pontos de contato
Os pontos de contato determinam para onde as notificações são enviadas. Por exemplo, você pode ter um ponto de contato que envia notificações para um endereço de e-mail, para o Slack, para um sistema de gerenciamento de incidentes (IRM), como Grafana OnCall ou Pagerduty, ou para um webhook.
As notificações enviadas pelos pontos de contato podem ser personalizadas usando modelos de notificação. Você pode usar modelos de notificação para alterar o título, a mensagem e a estrutura da notificação. Os modelos de notificação não são específicos para integrações ou pontos de contato individuais.
### Políticas de notificação
As políticas de notificação agrupam alertas e os roteiam para os pontos de contato. Eles determinam quando as notificações são enviadas e com que frequência elas devem ser repetidas.
Os alertas são correspondidos com as políticas de notificação usando matchers de rótulos. Estes são expressões legíveis por humanos que afirmam se os rótulos do alerta correspondem exatamente, não correspondem exatamente, contêm ou não contêm algum texto esperado. Por exemplo, o matcher `foo=bar` corresponde alertas com o rótulo `foo=bar`, enquanto o matcher `foo=~[a-zA-Z]+` corresponde alertas com qualquer rótulo chamado foo com um valor que corresponde à expressão regular `[a-zA-Z]+`.
Por padrão, um alerta só pode corresponder a uma política de notificação. No entanto, com o recurso `continue`, os alertas podem ser criados para corresponder a qualquer quantidade de políticas de notificação ao mesmo tempo. Para obter mais informações sobre políticas de notificação, consulte [Políticas de notificação](v10-alerting-explore-notifications-policies-details.md).
### Tempos de desativação de áudio e silêncios
Os tempos de desativação de áudio e silêncios permitem que você pause as notificações de alertas específicos ou até mesmo de todas as políticas de notificação. Use o silêncio para pausar as notificações em uma base ad hoc, por exemplo, enquanto trabalha na correção de um alerta; e use os tempos de desativação de áudio para pausar as notificações em intervalos regulares, como durante janelas de manutenção programadas regularmente.
**Topics**
+ [Princípios](#v10-alerting-overview-principles)
+ [Conceitos básicos](#v10-alerting-overview-fundamentals)
+ [Fontes de dados e o Grafana Alerting](v10-alerting-overview-datasources.md)
+ [Alertas sobre dados numéricos](v10-alerting-overview-numeric.md)
+ [Rótulos e anotações](v10-alerting-overview-labels.md)
+ [Sobre as regras de alerta](v10-alerting-explore-rules.md)
+ [Alertmanager](v10-alerting-explore-alertmanager.md)
+ [Pontos de contato](v10-alerting-explore-contacts.md)
+ [Notificações](v10-alerting-explore-notifications.md)
+ [Alerta de alta disponibilidade](v10-alerting-explore-high-availability.md)
# Fontes de dados e o Grafana Alerting
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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 compatíveis com o Grafana Alerting. Cada fonte de dados é compatível com um plug-in. O Grafana Alerting exige que os plug-ins da fonte de dados sejam plug-ins de *backend* a fim de avaliar as regras que usam a fonte de dados, pois o mecanismo de avaliação é executado no backend. Os plug-ins também devem especificar que são compatíveis com o Grafana Alerting.
As fontes de dados são adicionadas e atualizadas ao longo do tempo. É sabido que as fontes de dados a seguir são compatíveis com o Grafana Alerting.
+ [Conecte-se a uma fonte de CloudWatch dados da Amazon](using-amazon-cloudwatch-in-AMG.md)
+ [Conectar-se a uma fonte de dados Azure Monitor](using-azure-monitor-in-AMG.md)
+ [Conecte-se a uma fonte OpenSearch de dados do Amazon Service](using-Amazon-OpenSearch-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 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 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)
Para obter informações mais detalhadas sobre fontes de dados e plug-ins de fontes de dados no Amazon Managed Grafana, consulte [Conectar-se à fonte de dados](AMG-data-sources.md).
# 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 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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 de uma 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 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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](v10-alerting-overview-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](v10-alerting-overview-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](v10-alerting-overview-labels-templating.md).
**Topics**
+ [Rótulos](#v10-alerting-overview-labels-labels)
+ [Anotações](#v10-alerting-overview-labels-annotations)
+ [Como funciona a correspondência de rótulos](v10-alerting-overview-labels-matching.md)
+ [Rótulos no Grafana Alerting](v10-alerting-overview-labels-alerting.md)
+ [Modelos de rótulos e anotações](v10-alerting-overview-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 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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ótulos 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
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.
## Excluir rótulos
Você também pode escrever matchers de rótulos para excluir rótulos.
Veja abaixo um exemplo que mostra como excluir o rótulo `team`. Você pode escolher entre qualquer um destes valores para excluir o rótulo.
+ `team=""`
+ `team!~.+`
+ `team=~^$`
# 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 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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](v10-alerting-configure.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 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 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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).
Você pode usar modelos para incluir dados de consultas e expressões em rótulos e anotações. Por exemplo, você pode querer definir o rótulo de severidade de um alerta com base no valor da consulta, ou usar o rótulo de instância da consulta em uma anotação de resumo para saber qual servidor está tendo alto uso da CPU.
Todos os modelos devem ser escritos em [texto/modelo](https://pkg.go.dev/text/template). Independentemente de você estar criando um modelo de um rótulo ou uma anotação, você deve escrever cada modelo em linha dentro do rótulo ou anotação que você está criando. Isso significa que você não pode compartilhar modelos entre rótulos e anotações e, em vez disso, precisará copiar os modelos onde quiser usá-los.
Cada modelo é avaliado sempre que a regra de alerta é avaliada, e é avaliado para cada alerta separadamente. Por exemplo, se a regra de alerta tiver uma anotação de resumo modelada, e a regra de alerta tiver dez alertas disparados, o modelo será executado dez vezes, uma vez para cada alerta. Você deve tentar evitar ao máximo realizar computações caras nos modelos.
## Exemplos
Em vez de escrever um tutorial completo, text/template, the following examples attempt to show the most common use-cases we have seen for templates. You can use these examples verbatim, or adapt them as necessary for your use case. For more information about how to write text/template consulte a documentação de [texto/modelo](https://pkg.go.dev/text/template).
**Imprimir todos os rótulos, separados por vírgula**
Para imprimir todos os rótulos, separados por vírgula, imprima a variável `$labels`:
```
{{ $labels }}
```
Por exemplo, para um alerta com os rótulos `alertname=High CPU usage`, `grafana_folder=CPU alerts` e `instance=server1`, vai imprimir:
```
alertname=High CPU usage, grafana_folder=CPU alerts, instance=server1
```
**nota**
Se você estiver usando condições clássicas, `$labels` não conterá nenhum rótulo da consulta. Consulte [a variável \$1labels](#v10-alerting-overview-labels-templating-the-labels-variable) para obter mais informações.
**Imprimir todos os rótulos, um por linha**
Para imprimir todas as etiquetas, uma por linha, use `range` a para iterar sobre cada key/value par e imprimi-las individualmente. Aqui, `$k` refere-se ao nome e `$v` refere-se ao valor do rótulo atual:
```
{{ range $k, $v := $labels -}}
{{ $k }}={{ $v }}
{{ end }}
```
Por exemplo, para um alerta com os rótulos `alertname=High CPU usage`, `grafana_folder=CPU alerts` e `instance=server1`, vai imprimir:
```
alertname=High CPU usage
grafana_folder=CPU alerts
instance=server1
```
**nota**
Se você estiver usando condições clássicas, `$labels` não conterá nenhum rótulo da consulta. Consulte [a variável \$1labels](#v10-alerting-overview-labels-templating-the-labels-variable) para obter mais informações.
**Imprimir um rótulo individual**
Para imprimir um rótulo individual, use a função `index` com a variável `$labels`:
```
The host {{ index $labels "instance" }} has exceeded 80% CPU usage for the last 5 minutes
```
Por exemplo, para um alerta com o rótulo `instance=server1`, vai imprimir:
```
The host server1 has exceeded 80% CPU usage for the last 5 minutes
```
**nota**
Se você estiver usando condições clássicas, `$labels` não conterá nenhum rótulo da consulta. Consulte [a variável \$1labels](#v10-alerting-overview-labels-templating-the-labels-variable) para obter mais informações.
**Imprimir o valor de uma consulta**
Para imprimir o valor de uma consulta instantânea, você pode imprimir seu ID de referência usando a função `index` e a variável `$values`:
```
{{ index $values "A" }}
```
Por exemplo, uma consulta instantânea específica que retorna o valor 81,2345, vai imprimir:
```
81.2345
```
Para imprimir o valor de uma consulta de intervalo, você deve primeiro reduzi-la de uma série temporal para um vetor instantâneo com uma expressão de redução. Em seguida, você pode imprimir o resultado da expressão de redução usando seu ID de referência. Por exemplo, se a expressão de redução pegar a média de A e tiver o ID de referência B, você vai escrever:
```
{{ index $values "B" }}
```
**Imprimir o valor humanizado de uma consulta**
Para imprimir o valor humanizado de uma consulta instantânea, use a função `humanize`:
```
{{ humanize (index $values "A").Value }}
```
Por exemplo, uma consulta instantânea específica que retorna o valor 81,2345, vai imprimir:
```
81.234
```
Para imprimir o valor humanizado de uma consulta de intervalo, você deve primeiro reduzi-la de uma série temporal para um vetor instantâneo com uma expressão de redução. Em seguida, você pode imprimir o resultado da expressão de redução usando seu ID de referência. Por exemplo, se a expressão de redução pegar a média de A e tiver o ID de referência B, você vai escrever:
```
{{ humanize (index $values "B").Value }}
```
**Imprimir o valor de uma consulta como uma porcentagem**
Para imprimir o valor de uma consulta instantânea como porcentagem, use a função `humanizePercentage`:
```
{{ humanizePercentage (index $values "A").Value }}
```
Essa função espera que o valor seja um número decimal entre 0 e 1. Se, em vez disso, o valor for um número decimal entre 0 e 100, você poderá dividi-lo por 100 na consulta ou usando uma expressão matemática. Se a consulta for uma consulta de intervalo, você deverá primeiro reduzi-la de uma série temporal para um vetor instantâneo com uma expressão de redução.
**Definir uma severidade do valor de uma consulta**
Para definir um rótulo de severidade do valor de uma consulta, use uma instrução if e a função de comparação maior que. Certifique-se de usar decimais (`80.0`,, `50.0``0.0`, etc) ao fazer comparações, `$values` pois não text/template suporta coerção de tipo. Você pode encontrar uma lista de todas as funções de comparação compatíveis [aqui](https://pkg.go.dev/text/template#hdr-Functions).
```
{{ if (gt $values.A.Value 80.0) -}}
high
{{ else if (gt $values.A.Value 50.0) -}}
medium
{{ else -}}
low
{{- end }}
```
**Imprimir todos os rótulos de uma condição clássica**
Você não poderá usar `$labels` para imprimir rótulos da consulta se estiver usando condições clássicas, e deverá usar `$values` em vez disso. A razão para isso é que as condições clássicas descartam esses rótulos para impor um comportamento unidimensional (no máximo um alerta por regra de alerta). Se as condições clássicas não descartassem esses rótulos, as consultas que retornassem várias séries temporais fariam com que os alertas oscilassem entre o disparo e a resolução constantemente, pois os rótulos mudariam toda vez que a regra de alerta fosse avaliada.
Em vez disso, a variável `$values` contém os valores reduzidos de todas as séries temporais para todas as condições que estão disparando. Por exemplo, se você tiver uma regra de alerta com uma consulta A que retorna duas séries temporais e uma condição B clássica com duas condições, então `$values` conterá `B0`, `B1`, `B2` e `B3`. Se a condição clássica B tiver apenas uma condição, então `$values` conterá apenas `B0` e `B1`.
Para imprimir todos os rótulos de todas as séries temporais de disparo, use o modelo a seguir (certifique-se de substituir `B` na expressão regular pelo ID de referência da condição clássica, caso seja diferente):
```
{{ range $k, $v := $values -}}
{{ if (match "B[0-9]+" $k) -}}
{{ $k }}: {{ $v.Labels }}{{ end }}
{{ end }}
```
Por exemplo, uma condição clássica para duas séries temporais que excedam uma única condição, vai imprimir:
```
B0: instance=server1
B1: instance=server2
```
Se a condição clássica tiver duas ou mais condições e uma série temporal exceder várias condições ao mesmo tempo, então os rótulos serão duplicados para cada condição excedida:
```
B0: instance=server1
B1: instance=server2
B2: instance=server1
B3: instance=server2
```
Se precisar imprimir rótulos exclusivos, considere alterar as regras de alerta de unidimensionais para multidimensionais. Você pode fazer isso substituindo a condição clássica por expressões de redução e matemáticas.
**Imprimir todos os valores de uma condição clássica**
Para imprimir todos os valores de uma condição clássica, pegue o exemplo anterior e substitua `$v.Labels` por `$v.Value`:
```
{{ range $k, $v := $values -}}
{{ if (match "B[0-9]+" $k) -}}
{{ $k }}: {{ $v.Value }}{{ end }}
{{ end }}
```
Por exemplo, uma condição clássica para duas séries temporais que excedam uma única condição, vai imprimir:
```
B0: 81.2345
B1: 84.5678
```
Se a condição clássica tiver duas ou mais condições e uma série temporal exceder várias condições ao mesmo tempo, então `$values` conterá os valores de todas as condições:
```
B0: 81.2345
B1: 92.3456
B2: 84.5678
B3: 95.6789
```
## Variáveis
As variáveis a seguir estão disponíveis para você ao criar modelos de rótulos e anotações:
### A variável de rótulos
A variável `$labels` contém todos os rótulos da consulta. Por exemplo, suponha que você tenha uma consulta que retorne o uso da CPU de todos os servidores e tenha uma regra de alerta que é disparada quando algum dos servidores excede 80% do uso da CPU nos últimos cinco minutos. Você deseja adicionar uma anotação de resumo ao alerta que informa qual servidor está enfrentando alto uso da CPU. Com a variável `$labels`, você pode escrever um modelo que imprima uma frase legível por humanos, como:
```
CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes
```
**nota**
Se você estiver usando uma condição clássica, `$labels` não conterá nenhum rótulo da consulta. As condições clássicas descartam esses rótulos para impor um comportamento unidimensional (no máximo um alerta por regra de alerta). Caso queira usar rótulos da consulta no modelo, siga o exemplo anterior de *Imprimir todos os rótulos de uma condição clássica*.
### O valor da variável
A variável `$value` é uma string que contém os rótulos e valores de todas as consultas instantâneas, expressões de limite, redução e matemáticas e condições clássicas na regra de alerta. Ela não contém os resultados das consultas de intervalo, pois estas podem retornar de 10 a 10 mil linhas ou métricas. Se isso acontecesse, para consultas especialmente grandes, um único alerta poderia usar 10s MBs de memória e o Grafana ficaria sem memória muito rapidamente.
Para imprimir a variável `$value` no resumo, você deve escrever algo assim:
```
CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes: {{ $value }}
```
E ficaria semelhante ao abaixo:
```
CPU usage for instance1 has exceeded 80% for the last 5 minutes: [ var='A' labels={instance=instance1} value=81.234 ]
```
Aqui, `var='A'` refere-se à consulta instantânea com o ID de referência A, `labels={instance=instance1}` refere-se aos rótulos e `value=81.234` refere-se ao uso médio da CPU nos últimos cinco minutos.
Se você quiser imprimir apenas parte da string em vez da string completa, use a variável `$values`. Ela contém as mesmas informações que `$value`, mas em uma tabela estruturada, e é muito mais fácil de usar do que escrever uma expressão regular para corresponder apenas ao texto desejado.
### A variável de valores
A `$values` variável é uma tabela contendo os rótulos e valores de ponto flutuante de todas as consultas e expressões instantâneas, indexadas por sua Ref. IDs
Para imprimir o valor da consulta instantânea com o ID de referência A:
```
CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes: {{ index $values "A" }}
```
Por exemplo, um alerta específico com os rótulos `instance=server1` e uma consulta instantânea com o valor `81.2345`, vai imprimir:
```
CPU usage for instance1 has exceeded 80% for the last 5 minutes: 81.2345
```
Se a consulta no ID de referência A for uma consulta de intervalo em vez de uma consulta instantânea, adicione uma expressão de redução com o ID de referência B e substitua `(index $values "A")` por `(index $values "B")`:
```
CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes: {{ index $values "B" }}
```
## Funções
As seguintes funções estão disponíveis para você ao criar modelos de rótulos e anotações:
**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.
```
{{define "x"}}{{.arg0}} {{.arg1}}{{end}}{{template "x" (args 1 "2")}}
```
```
1 2
```
**externalURL**
A função `externalURL` retorna o URL externo do servidor Grafana.
```
{{ externalURL }}
```
```
https://example.com/grafana
```
**graphLink**
A função `graphLink` retorna o caminho para a visualização de grafo em [Explore na versão 10 do Grafana](v10-explore.md) para a expressão e a fonte de dados fornecidas.
```
{{ 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.
```
{{ humanize 1000.0 }}
```
```
1k
```
**humanize1024**
A `humanize1024` funciona de forma semelhante a `humanize`, mas usa 1024 como base em vez de 1000.
```
{{ humanize1024 1024.0 }}
```
```
1ki
```
**humanizeDuration**
A função `humanizeDuration` humaniza a duração em segundos.
```
{{ humanizeDuration 60.0 }}
```
```
1m 0s
```
**humanizePercentage**
A função `humanizePercentage` humaniza um valor de proporção para uma porcentagem.
```
{{ humanizePercentage 0.2 }}
```
```
20%
```
**humanizeTimestamp**
A `humanizeTimestamp` função humaniza um carimbo de data e hora do Unix.
```
{{ 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.
```
{{ match "a.*" "abc" }}
```
```
true
```
**pathPrefix**
A função `pathPrefix` retorna o caminho do servidor Grafana.
```
{{ pathPrefix }}
```
```
/grafana
```
**tableLink**
A função `tableLink` retorna o caminho para a visualização tabular em [Explore na versão 10 do Grafana](v10-explore.md) para a expressão e fonte de dados fornecidas.
```
{{ 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.
```
{{ title "hello, world!" }}
```
```
Hello, World!
```
**toLower**
A função `toLower` retorna todo o texto em letras minúsculas.
```
{{ toLower "Hello, world!" }}
```
```
hello, world!
```
**toUpper**
A função `toUpper` retorna todo o texto em maiúsculas.
```
{{ toUpper "Hello, world!" }}
```
```
HELLO, WORLD!
```
**reReplaceAll**
A função `reReplaceAll` substitui o texto correspondente à expressão regular.
```
{{ reReplaceAll "localhost:(.*)" "example.com:$1" "localhost:8080" }}
```
```
example.com:8080
```
# 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 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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 a duração em que a condição precisa ser atendida para começar a ser disparada.
Enquanto consultas e expressões selecionam o conjunto de dados a ser avaliado, uma *condição* define o limite que os dados devem 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](v10-alerting-explore-rules-types.md)
+ [Regras de gravação](v10-alerting-explore-rule-recording.md)
+ [Consultas e condições](v10-alerting-explore-rules-queries.md)
+ [Instâncias de alerta](v10-alerting-rules-instances.md)
+ [Namespaces, pastas e grupos](v10-alerting-rules-grouping.md)
+ [Avaliação da regra de alerta](v10-alerting-rules-evaluation.md)
+ [Estado e integridade das regras de alertas](v10-alerting-explore-state.md)
+ [Modelos de notificação](v10-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 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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. Saiba mais sobre cada um dos tipos de regras de alerta, como elas funcionam e decida qual é a melhor 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 ser compatível com várias fontes de dados, você pode adicionar [expressões](v10-panels-query-xform-expressions.md) para transformar os dados e expressar condições de alerta.
Em alertas gerenciados pelo Grafana:
+ As regras de alerta são criadas no Grafana, com base em uma ou mais fontes de dados.
+ As regras de alerta são avaliadas pelo mecanismo de avaliação de regras de alerta dentro do Grafana.
+ Os alertas são entregues usando o Grafana Alertmanager interno.
**nota**
Você também pode configurar alertas para serem entregues usando um Alertmanager externo ou usar Alertmanagers internos e externos. Para obter mais informações, consulte [Adicionar um alertmanager externo](v10-alerting-setup-alertmanager.md).
## Regras gerenciadas pela fonte de dados
Para criar regras de alerta gerenciadas pela fonte de dados, você deve ter uma fonte de dados Prometheus ou Loki 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.
Nos alertas gerenciados pela fonte de dados:
+ As regras de alerta são criadas e armazenadas na própria fonte de dados.
+ As regras de alerta podem ser criadas somente com base nos dados do Prometheus.
+ A avaliação e a entrega das regras de alerta são distribuídas em vários nós para alta disponibilidade e tolerância a falhas.
## Escolha um tipo de regra de alerta
Ao escolher qual tipo de regra de alerta usar, considere a comparação a seguir entre as regras de alerta gerenciadas pelo Grafana e as regras de alerta gerenciadas pela fonte de dados.
| Recurso | Regra de alerta gerenciada pelo Grafana | Regra de alerta gerenciada pelo Loki e Mimir |
| --- | --- | --- |
| Criar regras de alerta com base nos dados de qualquer uma das nossas fontes de dados compatíveis | Sim | Não: você só pode criar regras de alerta baseadas nos dados do Prometheus. A fonte de dados deve ter a API Ruler habilitada. |
| Misturar e corresponder fontes de dados | Sim | Não |
| Inclui suporte para regras de gravação | Não | Sim |
| Adicionar expressões para transformar os dados e definir condições de alerta | Sim | Não |
| Usar imagens em notificações de alerta | Sim | Não |
| Escalabilidade | Consome mais recursos, depende do banco de dados e provavelmente sofrerá erros transitórios. Só escalam verticalmente. | Armazene as regras de alerta na própria fonte de dados e permita a escalabilidade “infinita”. Gere e envie notificações de alerta da localização dos dados. |
| Avaliação e entrega de regras de alerta | A avaliação e a entrega das regras de alerta são feitas dentro do Grafana, usando um Alertmanager externo; ou ambos. | A avaliação das regras de alerta e a entrega de alertas são distribuídas, o que significa que não há um único ponto de falha. |
# Regras de gravação
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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 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.
Consultar essa nova série temporal é mais rápida, especialmente para dashboards, pois eles consultam a mesma expressão toda vez que os dashboards são atualizados.
Leia mais sobre as [regras de gravação](https://prometheus.io/docs/prometheus/latest/configuration/recording_rules/) no Prometheus.
# Consultas e condições
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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, as consultas desempenham um papel vital na busca e transformação de dados de fontes de dados compatíveis, que incluem bancos de dados como MySQL e PostgreSQL, bancos de dados de séries temporais como Prometheus, InfluxDB e Graphite e serviços como Amazon, Azure Monitor e Google Cloud Monitoring. OpenSearch CloudWatch
Para obter mais informações sobre fontes de dados compatíveis, consulte [Fontes de dados e o Grafana Alerting](v10-alerting-overview-datasources.md).
O processo de execução de uma consulta envolve definir a fonte de dados, especificar os dados desejados a serem recuperados e aplicar filtros ou transformações relevantes. Sintaxes ou linguagens de consulta específicas para a fonte de dados escolhida são utilizadas para criar essas consultas.
Em Alertas, você define uma consulta para obter os dados que deseja avaliar e uma condição que precisa ser atendida antes que uma regra de alerta seja disparada.
Uma regra de alerta consiste em uma ou mais consultas e expressões que selecionam os dados que você deseja avaliar.
Para obter mais informações sobre expressões e consultas, consulte [Consultar e transformar de dados](v10-panels-query-xform.md).
## Consultas de fonte de dados
As consultas no Grafana podem ser aplicadas de várias maneiras, dependendo da fonte de dados e da linguagem de consulta sendo usada. Cada editor de consultas da fonte de dados fornece uma interface de usuário personalizada que ajuda você a escrever consultas que aproveitam seus recursos exclusivos.
Devido às diferenças entre as linguagens de consulta, cada editor de consultas da fonte de dados tem um formato e funciona de forma diferente. Dependendo da fonte de dados, o editor de consultas pode fornecer recursos de preenchimento automático, nomes de métricas, sugestões de variáveis ou uma interface visual de criação de consultas.
Alguns tipos comuns de componentes de consulta incluem:
**Campos de dados ou métricas**: especifique os campos de dados ou métricas específicos que você deseja recuperar, como uso da CPU, tráfego de rede ou leituras de sensores.
**Intervalo de tempo**: defina o intervalo de tempo para o qual você deseja buscar dados, como a última hora, um dia específico ou um intervalo de tempo personalizado.
**Filtros**: aplique filtros para restringir os dados com base em critérios específicos, como filtrar dados por uma tag, host ou aplicação específica.
**Agregações**: realize agregações nos dados para calcular métricas como médias, somas ou contagens em um determinado período de tempo.
**Agrupamento**: agrupe os dados por dimensões ou tags específicas para criar visualizações ou detalhamentos agregados.
**nota**
O Grafana não é compatível com consultas de alerta com variáveis de modelo. Há mais informações disponíveis [aqui](https://community.grafana.com/t/template-variables-are-not-supported-in-alert-queries-while-setting-up-alert/2514), nos fóruns da Grafana Labs.
## Consultas de expressão
No Grafana, uma expressão é usada para realizar cálculos, transformações ou agregações nos dados consultados da fonte de dados. Ela permite que você crie métricas personalizadas ou modifique métricas existentes com base em operações matemáticas, funções ou expressões lógicas.
Ao aproveitar as consultas de expressão, os usuários podem realizar tarefas como calcular a variação percentual entre dois valores, aplicar funções como funções logarítmicas ou trigonométricas, agregar dados em intervalos de tempo ou dimensões específicas e implementar lógica condicional para lidar com diferentes cenários.
Em Alertas, você só pode usar expressões para regras de alerta gerenciadas pelo Grafana. Para cada expressão, você pode escolher entre as expressões matemáticas, de redução e de reamostragem. Elas são chamadas de regras multidimensionais, porque geram um alerta separado para cada série.
Você também pode usar uma condição clássica, que cria uma regra de alerta que aciona um único alerta quando sua condição é atendida. Como resultado, o Grafana envia apenas um único alerta, mesmo quando as condições de alerta são atendidas para várias séries.
**nota**
As condições clássicas existem principalmente por motivos de compatibilidade e devem ser evitadas, se possível.
**Reduzir**
Agrega valores de séries temporais no intervalo de tempo selecionado em um único valor.
**Math**
Executa cálculos matemáticos de forma livre functions/operations em séries temporais e dados numéricos. Pode ser usado para pré-processar dados de séries temporais ou para definir uma condição de alerta para dados numéricos.
**Reamostrar**
Realinha um intervalo de tempo para um novo conjunto de carimbos de data e hora. Isso é útil ao comparar dados de séries temporais de diferentes fontes de dados, em que, de outra forma, os carimbos de data e hora não se alinhariam.
**Limite**
Verifica se algum dado de série temporal corresponde à condição de limite.
A expressão de limite permite comparar dois valores únicos. Ele retorna `0` quando a condição é false e `1` quando a condição é true. As seguintes funções de limite estão disponíveis:
+ Está acima (x > y)
+ Está abaixo (x < y)
+ Está dentro do intervalo (x > y1 E x < y2)
+ Está fora do intervalo (x < y1 E x > y2)
**Condição clássica**
Verifica se algum dado de série temporal corresponde à condição de alerta.
**nota**
As consultas clássicas de expressão de condição sempre produzem apenas uma instância de alerta, independentemente de quantas séries temporais atendam à condição. As condições clássicas existem principalmente por motivos de compatibilidade e devem ser evitadas, se possível.
## Agregações
O Grafana Alerting fornece as funções de agregação a seguir para permitir que você refine ainda mais sua consulta.
Essas funções estão disponíveis somente para expressões de **Reduzir** e **Condição clássica**.
| Função | Expressão | O que ela faz |
| --- | --- | --- |
| avg | Reduzir/Clássica | Exibe a média dos valores |
| min | Reduzir/Clássica | Exibe o valor mais baixo |
| max | Reduzir/Clássica | Exibe o valor mais alto |
| soma | Reduzir/Clássica | Exibe a soma de todos os valores |
| contagem | Reduzir/Clássica | Conta o número de valores no resultado |
| last | Reduzir/Clássica | Exibe o último valor |
| mediano | Reduzir/Clássica | Exibe o valor médio |
| diferença | Clássica | Exibe a diferença entre o valor mais recente e o mais antigo |
| diff\$1abs | Clássica | Exibe o valor absoluto da diferença |
| percent\$1diff | Clássica | Exibe o valor percentual da diferença entre o valor mais recente e o mais antigo |
| percent\$1diff\$1abs | Clássica | Exibe o valor absoluto de percent\$1diff |
| count\$1non\$1null | Clássica | Exibe uma contagem de valores no conjunto de resultados que não são null |
## Condição de alerta
Uma condição de alerta é a consulta ou expressão que determina se o alerta será disparado ou não, dependendo do valor que gerar. Só pode haver uma condição que determinará o acionamento do alerta.
Depois de definir suas and/or expressões de consulta, escolha uma delas como condição da regra de alerta.
Quando os dados consultados satisfazem a condição definida, o Grafana aciona o alerta associado, que pode ser configurado para enviar notificações por meio de vários canais, como e-mail, Slack ou. PagerDuty As notificações informam sobre a condição que está sendo atendida, permitindo que você tome as medidas apropriadas ou investigue o problema subjacente.
Por padrão, a última expressão adicionada é usada como condição de alerta.
## Limite de recuperação
Para reduzir o ruído dos alertas oscilantes, você pode definir um limite de recuperação diferente do limite de alerta.
Os alertas oscilantes ocorrem quando uma métrica gira em torno da condição limite do alerta e podem levar a mudanças de estado frequentes, resultando na geração de muitas notificações.
As regras de alerta gerenciadas pelo Grafana são avaliadas por um intervalo de tempo específico. Durante cada avaliação, o resultado da consulta é verificado em relação ao limite definido na regra de alerta. Se o valor de uma métrica estiver acima do limite, uma regra de alerta será disparada e uma notificação será enviada. Quando o valor fica abaixo do limite e há um alerta ativo para essa métrica, o alerta é resolvido e outra notificação é enviada.
Pode ser complicado criar uma regra de alerta para uma métrica ruidosa. Ou seja, quando o valor de uma métrica fica continuamente acima e abaixo de um limite. Isso é chamado de oscilação e resulta em uma série de notificações de disparado - resolvido - disparado e um histórico de estado de alerta ruidoso.
Por exemplo, se você tiver um alerta de latência com um limite de 1.000 ms e o número flutuar em torno de 1.000 (digamos, 980 -> 1.010 -> 990 -> 1.020, e assim por diante), cada um deles acionará uma notificação.
Para resolver esse problema, você pode definir um limite de recuperação (personalizado), o que basicamente significa ter dois limites em vez de um. Um alerta é acionado quando o primeiro limite é ultrapassado, e é resolvido somente quando o segundo limite é ultrapassado.
Por exemplo, você pode definir um limite de 1.000 ms e um limite de recuperação de 900 ms. Dessa forma, uma regra de alerta só vai parar de disparar quando passar de 900 ms e as oscilações forem reduzidas.
# 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 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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 de CPUs que estamos observando após a primeira avaliação, permitindo que uma única regra relate o status de cada CPU.
# Namespaces, pastas e grupos
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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 e pastas**
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.
Um namespace contém um ou mais grupos. As regras em um grupo são executadas sequencialmente em intervalos regulares. O intervalo padrão é de um minuto. Você pode renomear grupos e namespaces de regras do Grafana Mimir ou Loki e editar intervalos de avaliação de grupos.
**Groups (Grupos)**
As regras em um grupo são executadas sequencialmente em intervalos regulares, o que significa que nenhuma regra será avaliada ao mesmo tempo, e em ordem de aparecimento. O intervalo padrão é de um minuto. Você pode renomear namespaces de regras do Grafana Mimir ou Loki ou namespaces e grupos de regras do Loki e editar intervalos de avaliação de grupos.
**dica**
Se você quiser que as regras sejam avaliadas simultaneamente e com intervalos diferentes, considere armazená-las em grupos diferentes.
**nota**
As regras de alerta gerenciadas pelo Grafana são avaliadas simultaneamente, em vez de sequencialmente.
# Avaliação da regra de alerta
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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 a avaliação da regra de alerta para determinar com que frequência uma regra de alerta deve ser avaliada e com que rapidez ela deve mudar seu estado.
Para fazer isso, você precisa garantir que a regra de alerta esteja no grupo de avaliação correto e definir um período de pendência que funcione melhor para o caso de uso.
## Grupo de avaliação
Cada regra de alerta faz parte de um grupo de avaliação. Cada grupo de avaliação contém um intervalo de avaliação que determina a frequência com que a regra de alerta é verificada.
As regras de alerta **gerenciadas pela fonte de dados** dentro do mesmo grupo são avaliadas uma após a outra, enquanto as regras de alerta em grupos diferentes podem ser avaliadas simultaneamente. Esse recurso é especialmente útil quando você deseja garantir que as regras de gravação sejam avaliadas antes de qualquer regra de alerta.
As regras de alerta **gerenciadas pelo Grafana** são avaliadas ao mesmo tempo, independentemente do grupo de regras de alerta. O intervalo de avaliação padrão é definido em dez segundos, o que significa que as regras de alerta gerenciadas pelo Grafana são avaliadas a cada dez segundos até a janela de dez segundos mais próxima do relógio, por exemplo, 10:00:00, 10:00:10, 10:00:20 e assim por diante. Você também pode configurar seu próprio intervalo de avaliação, se necessário.
**nota**
Grupos de avaliação e agrupamento de alertas em políticas de notificação são duas coisas distintas. O agrupamento em políticas de notificação permite que vários alertas que compartilham os mesmos rótulos sejam enviados na mesma mensagem de tempo.
## Período de pendência
Ao definir um período de pendência, você pode evitar alertas desnecessários para problemas temporários.
No período de pendência, você seleciona o período em que uma regra de alerta pode violar a condição até ser disparada.
**Exemplo**
Imagine que você tenha um intervalo de avaliação da regra de alerta definido a cada 30 segundos e o período de pendência seja de 90 segundos.
A avaliação ocorrerá da seguinte forma:
[00:30] Primeira avaliação: condição não atendida.
[01:00] Segunda avaliação: condição violada. O contador de pendência é iniciado. **O alerta entra no estado pendente.**
[01:30] Terceira avaliação: condição violada. Contador de pendência = 30s. **Estado pendente.**
[02:00] Quarta avaliação: condição violada. Contador de pendência = 60s **Estado pendente.**
[02:30] Quinta avaliação: condição violada. Contador de pendência = 90s. **O alerta começa a disparar**
Se a regra de alerta tiver uma condição que precise ser violada por um determinado período de tempo antes de agir, seu estado mudará da seguinte forma:
+ Quando a condição é violada pela primeira vez, a regra entra em um estado “pendente”.
+ A regra permanece no estado “pendente” até que a condição seja violada pelo período de tempo necessário: período de pendência.
+ Depois de decorrido o tempo necessário, a regra entra em um estado de “disparada”.
+ Se a condição não for mais violada durante o período de pendência, a regra voltará ao estado normal.
**nota**
Se você quiser ignorar o estado pendente, basta definir o período de pendência como 0. Isso efetivamente ignora o período de pendência e a regra de alerta começará a ser disparada assim que a condição for violada.
Quando uma regra de alerta é disparada, instâncias de alerta são produzidas e, em seguida, enviadas ao Alertmanager.
# 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 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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 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 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. |
**Manter o último estado**
Uma regra de alerta pode ser configurada para manter o último estado quando o estado `NoData` ou `Error` foi encontrado. Isso evitará que os alertas sejam disparados e que sejam resolvidos e disparados novamente. Assim como na avaliação normal, a regra de alerta mudará de `Pending` para `Firing` após o término do período de pendência.
**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.
# 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 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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](v10-alerting-manage-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.
# Alertmanager
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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 Alertmanager permite que você gerencie e responda aos alertas de forma rápida e eficiente. Ele recebe alertas, lida com desativação de áudios, inibição, agrupamento e roteamento enviando notificações pelo canal de sua escolha, por exemplo, e-mail ou Slack.
No Grafana, você pode usar o Grafana Alertmanager ou um Alertmanager externo. Você também pode executar vários alertmanagers. Sua decisão depende da configuração e de onde os alertas estão sendo gerados.
**Grafana Alertmanager**
O Grafana Alertmanager é um Alertmanager interno pré-configurado e disponível para seleção por padrão.
O Grafana Alertmanager pode receber alertas do Grafana, mas não pode receber alertas externos ao Grafana, por exemplo, do Mimir ou Loki.
**nota**
As regras de inibição não são compatíveis com o Grafana Alertmanager.
**Alertmanager externo**
Se você quiser usar um único alertmanager para receber todos os alertas do Grafana, Loki, Mimir e Prometheus, você pode configurar o Grafana para usar um Alertmanager externo. Esse Alertmanager externo pode ser configurado e administrado no próprio Grafana.
Veja abaixo dois exemplos de quando você pode querer configurar seu próprio alertmanager externo e enviar os alertas para ele em vez de para o Grafana Alertmanager:
1. Você já tem alertmanagers on-premises em sua própria infraestrutura de nuvem que configurou e ainda deseja usar, porque você tem outros geradores de alertas, como o Prometheus.
1. Você deseja usar o Prometheus on-premises e o Grafana hospedado para enviar alertas para o mesmo alertmanager que é executado em sua infraestrutura de nuvem.
Os alertmanagers estão visíveis no menu suspenso nas páginas Pontos de contato de alertas e Políticas de notificação.
Se você estiver provisionando a fonte de dados, defina o sinalizador `handleGrafanaManagedAlerts` no campo `jsonData` como `true` para enviar alertas gerenciados pelo Grafana para esse Alertmanager.
# 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 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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 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 Amazon SNS 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.
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 [Configurar pontos de contato](v10-alerting-configure-contactpoints.md) e [Personalizar notificações](v10-alerting-manage-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 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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).
Escolher como, quando e para onde enviar as notificações de alerta é uma parte importante da configuração do sistema de alertas. Essas decisões terão um impacto direto na capacidade de resolver problemas rapidamente e não perder nada importante.
Como primeira etapa, defina os [pontos de contato](v10-alerting-explore-contacts.md), que definem para onde enviar as notificações de alerta. Um ponto de contato é um conjunto de uma ou mais integrações usadas para enviar notificações. Adicione modelos de notificação aos pontos de contato para reutilização e mensagens consistentes nas notificações.
Em seguida, crie uma política de notificação que é um conjunto de regras para onde, quando e como os alertas são roteados para os pontos de contato. Em uma política de notificação, você define para onde enviar as notificações de alerta escolhendo um dos pontos de contato que você criou.
## Alertmanagers
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 denominada política padrão. Só pode haver uma política padrão e ela 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 aninhada pode ter suas próprias políticas aninhadas, que permitem uma correspondência adicional de alertas. Um exemplo de política aninhada pode ser enviar alertas de infraestrutura para a equipe de operações, enquanto uma política secundária pode 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 padrão. No entanto, quando a política padrão recebe um alerta, ela examina cada política aninhada e envia o alerta para a primeira política aninhada que corresponde a ele. Se a política aninhada tiver outras políticas aninhadas, ela poderá tentar comparar o alerta com uma de suas políticas aninhadas. Se nenhuma política aninhada corresponder ao alerta, então a própria política será a política correspondente. Se não houver políticas aninhadas ou nenhuma política aninhada corresponder ao alerta, a política padrão será a política correspondente.
Para obter informações mais detalhadas sobre políticas de notificação, consulte [Políticas de notificação](v10-alerting-explore-notifications-policies-details.md).
## Modelos de notificação
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.
Para obter informações mais detalhadas sobre a personalização das notificações, consulte [Personalizar notificações](v10-alerting-manage-notifications.md).
## 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.
Para obter informações mais detalhadas sobre como usar os silêncios, consulte [Silenciar notificações de alerta](v10-alerting-silences.md).
# Políticas 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 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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 políticas de notificação fornecem uma maneira flexível de rotear alertas para vários receptores diferentes. Usando os matchers de rótulos, você pode modificar a entrega da notificação de alertas sem precisar atualizar cada regra de alerta individual.
Nesta seção, você aprenderá mais sobre como as políticas de notificação funcionam e são estruturadas, para que você possa aproveitar ao máximo a configuração das políticas de notificação.
## Árvore de políticas
As políticas de notificação *não* são uma lista. Elas são estruturadas de acordo com uma estrutura em árvore. Isso significa que cada política pode ter políticas secundárias etc. A raiz da árvore de políticas de notificação é chamada de **Política de notificação padrão**.
Cada política consiste em um conjunto de matchers de rótulos (0 ou mais) que especificam quais rótulos eles estão ou não interessados em manipular.
Para obter mais informações sobre como corresponder rótulos, consulte [Como funciona a correspondência de rótulos](v10-alerting-overview-labels-matching.md).
**nota**
Se você não configurou nenhum matcher de rótulo para sua política de notificação, ela fará a correspondência de *todas* as instâncias de alerta. Isso pode impedir que as políticas secundárias sejam avaliadas, a menos que você tenha habilitado a opção **Continuar combinando políticas irmãs** na política de notificação.
## Roteamento
Para determinar qual política de notificação lidará com quais instâncias de alerta, você precisa começar examinando o conjunto existente de políticas de notificação, começando pela política de notificação padrão.
Se nenhuma política além da política padrão estiver configurada, a política padrão tratará da instância de alerta.
Se políticas diferentes da política padrão forem definidas, ela avaliará essas políticas de notificação na ordem em que forem exibidas.
Se uma política de notificação tiver matchers de rótulos que correspondam aos rótulos da instância de alerta, ela passará para suas políticas secundárias e, se houver mais, continuará procurando por políticas secundárias que possam ter matchers que restrinjam ainda mais o conjunto de rótulos, e assim por diante, até que nenhuma outra política secundária seja encontrada.
Se nenhuma política secundária for definida em uma política de notificação, ou se nenhuma das políticas secundárias tiver matchers de rótulos que correspondam aos rótulos da instância de alerta, a política de notificação principal será usada.
Assim que uma política correspondente é encontrada, o sistema não continua procurando outras políticas correspondentes. Se você quiser continuar procurando outras políticas que possam corresponder, habilite **Continuar combinando irmãs** nessa política específica.
Por fim, se nenhuma das políticas de notificação for selecionada, a política de notificação padrão será usada.
### Exemplo de roteamento
Veja abaixo um exemplo de uma árvore de políticas de notificação relativamente simples e algumas instâncias de alerta.
![\[Uma imagem mostrando um conjunto de políticas de notificação em uma estrutura em árvore e um conjunto de instâncias de alerta com rótulos diferentes para corresponder às políticas.\]](http://docs.aws.amazon.com/pt_br/grafana/latest/userguide/images/notification-routing.png)
Veja abaixo um resumo de como essas políticas são selecionadas:
O **pod preso CrashLoop** não tem um `severity` rótulo, então nenhuma de suas políticas secundárias é compatível. Ela tem um rótulo `team=operations`, então a primeira política corresponde.
A política `team=security` não foi avaliada porque já encontramos uma correspondência, e a opção **Continuar combinando irmãs** não foi configurada para essa política.
**Uso do disco: 80%** tem um rótulo `team` e `severity` e corresponde a uma política secundária da equipe de operações.
A **entrada de log não autorizada** tem um rótulo `team`, mas não corresponde à primeira política (`team=operations`), pois os valores não são os mesmos. Portanto, ela continuará pesquisando e corresponderá à política de `team=security`. Ela não tem nenhuma política secundária, portanto, o rótulo `severity=high` adicional é ignorado.
## Herança
Além de as políticas secundárias serem um conceito útil para rotear instâncias de alerta, elas também herdam propriedades da política principal. Isso também se aplica a todas as políticas que sejam políticas secundárias da política de notificação padrão.
As seguintes propriedades são herdadas pelas políticas secundárias:
+ Ponto de contato
+ Opções de agrupamento
+ Opções de tempos
+ Tempos de desativação de áudio
Cada uma dessas propriedades pode ser substituída por uma política individual, caso você deseje substituir as propriedades herdadas.
Para herdar um ponto de contato da política principal, deixe-o em branco. Para substituir as opções de agrupamento herdadas, habilite **Substituir agrupamento**. Para substituir as opções de tempos herdadas, habilite **Substituir tempos gerais**.
### Exemplo de herança
O exemplo abaixo mostra como a árvore de políticas de notificação do nosso exemplo anterior permite que as políticas secundárias de `team=operations` herdem o ponto de contato.
Dessa forma, podemos evitar a necessidade de especificar o mesmo ponto de contato várias vezes para cada política secundária.
![\[Uma imagem mostrando um conjunto de políticas de notificação em uma estrutura de árvore, com pontos de contato atribuídos a algumas das políticas, mas com algumas políticas secundárias herdando os pontos de contato das principais, em vez de definirem os seus próprios.\]](http://docs.aws.amazon.com/pt_br/grafana/latest/userguide/images/notification-inheritance.png)
## Opções de configuração adicionais
### Agrupamento
O agrupamento é um recurso importante do Grafana Alerting, pois permite agrupar alertas relevantes para um número menor de notificações. Isso será particularmente importante se as notificações forem entregues aos primeiros respondentes, como engenheiros de plantão, em que receber muitas notificações em um curto período de tempo pode ser cansativo e, em alguns casos, pode afetar negativamente a capacidade deles de responder a um incidente. Por exemplo, considere uma grande interrupção em que muitos de seus sistemas estejam inativos. Nesse caso, o agrupamento pode ser a diferença entre receber uma chamada telefônica e cem chamadas telefônicas.
Você escolhe como os alertas serão agrupados usando a opção Agrupar por em uma política de notificação. Por padrão, as políticas de notificação no Grafana agrupam alertas por regra de alerta usando os rótulos `alertname` e `grafana_folder` (já que os nomes dos alertas não são exclusivos entre várias pastas). Se você quiser agrupar alertas por algo diferente da regra de alerta, altere o agrupamento para qualquer outra combinação de rótulos.
#### Desabilitar um agrupamento
Caso deseje receber cada alerta como uma notificação separada, você pode fazer isso agrupando por um rótulo especial denominado `...`. Isso é útil quando os alertas estão sendo enviados para um sistema automatizado em vez de para um primeiro respondente.
#### Um único grupo para todos os alertas
Caso deseje receber todos os alertas juntos em uma única notificação, você pode fazer isso deixando Agrupar por vazio.
### Opções de tempos
As opções de tempo decidem com que frequência as notificações são enviadas para cada grupo de alertas. Há três temporizadores que você precisa conhecer: Espera do grupo, Intervalo do grupo e Intervalo de repetição.
#### Espera do grupo
A espera do grupo é o período de tempo que o Grafana espera antes de enviar a primeira notificação para um novo grupo de alertas. Quanto maior for a espera do grupo, mais tempo você terá para que outros alertas cheguem. Quanto menor for a espera do grupo, mais cedo a primeira notificação será enviada, mas correndo o risco de enviar notificações incompletas. Você deve sempre escolher uma espera do grupo que seja a mais adequada para o seu caso de uso.
**Padrão** 30 segundos
#### Intervalo do grupo
Depois que a primeira notificação é enviada para um novo grupo de alertas, o Grafana inicia o temporizador de intervalo do grupo. Este é o período de tempo que o Grafana espera antes de enviar notificações sobre alterações no grupo. Por exemplo, outro alerta disparado pode ter acabado de ser adicionado ao grupo, enquanto um alerta existente pode ter sido resolvido. Se um alerta chegar tarde demais para ser incluído na primeira notificação devido à espera do grupo, ele será incluído nas notificações subsequentes após o intervalo do grupo. Depois de decorrido o intervalo do grupo, o Grafana redefine o temporizador do intervalo do grupo. Isso se repete até que não haja mais alertas no grupo, após o qual o grupo é excluído.
**Padrão** 5 minutos
#### Intervalo de repetição
O intervalo de repetição decide com que frequência as notificações serão repetidas se o grupo não tiver sido alterado desde a última notificação. Você pode pensar nisso como lembretes de que alguns alertas ainda estão sendo disparados. O intervalo de repetição está intimamente relacionado ao intervalo do grupo, o que significa que seu intervalo de repetição não deve ser apenas maior ou igual ao intervalo do grupo, mas também deve ser um múltiplo do intervalo do grupo. Se o intervalo de repetição não for um múltiplo do intervalo de grupo, ele será obrigado a formar um. Por exemplo, se o intervalo de grupo for de cinco minutos e o intervalo de repetição for de nove minutos, o intervalo de repetição será arredondado para o múltiplo de cinco mais próximo, que é de dez minutos.
**Padrão** 4 horas
# Alerta de alta disponibilidade
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 10.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.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 Amazon Managed Grafana está configurado para alta disponibilidade, incluindo a execução de várias instâncias em várias zonas de disponibilidade para cada espaço de trabalho que você cria.
O Grafana Alerting usa o modelo do Prometheus para separar a avaliação das regras de alerta da entrega de notificações. Nesse modelo, a avaliação das regras de alerta é feita no gerador de alertas, e a entrega das notificações é feita no receptor de alertas. No Grafana Alerting, o gerador de alertas é o Scheduler e o receptor é o Alertmanager.
Com configurações de alta disponibilidade, todas as regras de alerta são avaliadas em todas as instâncias. Você pode pensar na avaliação das regras de alerta como sendo duplicada. É assim que o Grafana Alerting garante que, enquanto pelo menos uma instância do Grafana estiver funcionando, as regras de alerta ainda serão avaliadas e as notificações de alertas continuarão sendo enviadas. Você verá essa duplicação no histórico do estado, e é uma boa maneira de saber se você está usando alta disponibilidade.