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á.
# Alertas no Grafana versão 10
****
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).
Com o Grafana v10, o Amazon Managed Grafana inclui acesso a um sistema de alerta atualizado, o *Grafana Alerting*, que centraliza as informações de alertas em uma única visualização pesquisável. O alerta do Grafana foi introduzido como um recurso opcional no Grafana v8 e GrafanaLabs anunciou a remoção do alerta legado na versão 11.
**nota**
Esta documentação abrange o Grafana Alerting. Para obter informações sobre alertas legados, consulte [Alertas clássicos do dashboard](old-alerts-overview.md).
O Grafana Alerting permite que você descubra os problemas nos sistemas momentos após eles ocorrerem.
Monitore os dados de métricas de entrada ou entradas de logs e configure o sistema de alertas para observar eventos ou circunstâncias específicos e, em seguida, enviar notificações quando estes forem encontrados.
Dessa forma, você elimina a necessidade de monitoramento manual e fornece uma primeira linha de defesa contra interrupções ou alterações no sistema que podem virar incidentes graves.
Ao usar o Grafana Alerting, você cria consultas e expressões de várias fontes de dados, independentemente de onde os dados estejam armazenados, dando-lhe a flexibilidade de combinar os dados e alertar sobre as métricas e os logs de maneiras novas e exclusivas. Você então pode criar, gerenciar e agir de acordo com os alertas em uma visão única e consolidada e melhorar a capacidade da sua equipe de identificar e resolver problemas rapidamente.
Com as regras de alerta do Mimir e Loki, você pode executar expressões de alerta mais perto dos dados e em grande escala, tudo isso gerenciado pela interface de usuário do Grafana com a qual você já tem familiaridade.
**nota**
Se você estiver migrando de uma versão anterior do Grafana, em que usou o Grafana Alerting legado, talvez seja útil ver as [diferenças entre os alertas legados e o novo Grafana Alerting](v10-alerting-use-grafana-alerts.md#v10-alerting-diff-old-new).
## Principais atributos e benefícios
**Uma página para todos os alertas**
Uma única página do Grafana Alerting consolida os alertas gerenciados pelo Grafana e os alertas que residem em sua fonte de dados compatível com o Prometheus em um único local.
**Alertas multidimensionais**
As regras de alerta podem criar várias instâncias de alerta individuais por regra de alerta, conhecidas como alertas multidimensionais, dando-lhe a capacidade e a flexibilidade de obter visibilidade de todo o sistema com apenas uma única regra de alerta. Você faz isso adicionando rótulos à consulta para especificar qual componente está sendo monitorado e gerar várias instâncias de alerta para uma única regra de alerta. Por exemplo, se você quiser monitorar cada servidor em um cluster, um alerta multidimensional alertará em cada CPU, enquanto um alerta padrão alertará sobre o servidor geral.
**Rotear alertas**
Roteie cada instância de alerta para um ponto de contato específico com base nos rótulos definidos por você. As políticas de notificação são o conjunto de regras para onde, quando e como os alertas são roteados para os pontos de contato.
**Silenciar alertas**
Os silêncios impedem que as notificações sejam criadas e duram apenas por uma janela de tempo especificada. Os silêncios permitem que você pare de receber notificações persistentes de uma ou mais regras de alerta. Você também pode pausar parcialmente um alerta com base em determinados critérios. Os silêncios têm sua própria seção dedicada para melhor organização e visibilidade, para que você possa verificar as regras de alerta pausadas sem desorganizar a visualização principal de alertas.
**Tempos de desativação de áudio**
O tempo de desativação de áudio é um intervalo de tempo recorrente em que nenhuma nova notificação de uma política é gerada ou enviada. Use-o para evitar que os alertas sejam disparados por um período específico e recorrente, por exemplo, um período de manutenção regular.
Assim como os silêncios, os tempos de desativação de áudio não impedem que as regras de alerta sejam avaliadas nem impedem que as instâncias de alerta sejam mostradas na interface do usuário. Eles apenas impedem que as notificações sejam criadas.
## Projetar o sistema de alertas
Monitorar sistemas de TI complexos e saber se tudo está funcionando corretamente é uma tarefa difícil. Portanto, configurar um sistema eficaz de gerenciamento de alertas é essencial para informar a você quando as coisas estiverem dando errado antes que elas comecem a afetar os resultados do seu negócio.
Projetar e definir uma configuração de gerenciamento de alertas que funcione leva tempo.
Aqui estão algumas dicas sobre como criar uma configuração eficaz de gerenciamento de alertas para a sua empresa:
**Quais são as principais métricas da sua empresa que você deseja monitorar e controlar com alertas?**
+ Encontre eventos de que sejam importantes ter conhecimento e que não sejam tão triviais ou frequentes que os destinatários os ignorem.
+ Os alertas só devem ser criados para grandes eventos que exijam atenção ou intervenção imediatas.
+ Considere a qualidade em vez da quantidade.
**Que tipo de alerta você deseja usar?**
+ Escolha entre alertas gerenciados pelo Grafana ou alertas gerenciados pelo Grafana Mimir ou Loki, ou os dois.
**Como você quer organizar os alertas e as notificações?**
+ Seja seletivo sobre quem você configura para receber alertas. Considere enviá-los para quem estiver de plantão ou para um canal específico do Slack.
+ Automatize o máximo possível usando a API de alertas ou alertas como código (Terraform).
**Como você pode reduzir a fadiga de alerta?**
+ Evite alertas ruidosos e desnecessários usando silêncios, tempos de desativação de áudio ou pausando a avaliação das regras de alerta.
+ Ajuste continuamente as regras de alerta para avaliar a eficácia. Remova as regras de alerta para evitar alertas duplicados ou ineficazes.
+ Reflita cuidadosamente sobre os níveis de prioridade e severidade.
+ Revise continuamente os limites e as regras de avaliação.
## Limitações do Grafana Alerting
+ Ao agregar regras de outros sistemas, o sistema de alertas do Grafana pode recuperar regras de todas as fontes de dados disponíveis: Amazon Managed Service for Prometheus, Prometheus, Loki e Alertmanager. Talvez não seja possível buscar regras de outras fontes de dados compatíveis.
**Topics**
+ [Principais atributos e benefícios](#v10-alerting-key-features)
+ [Projetar o sistema de alertas](#v10-alerting-design)
+ [Limitações do Grafana Alerting](#v10-alerting-limitations)
+ [Visão geral do](v10-alerting-overview.md)
+ [Configurar alertas](v10-alerting-setup.md)
+ [Configurar alertas](v10-alerting-configure.md)
+ [Gerenciar os alertas](v10-alerting-manage.md)
# 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.
# Configurar 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).
Configure os recursos e as integrações de que você precisa para criar e gerenciar os alertas.
**Pré-requisitos**
Antes de configurar alertas, você deve fazer o seguinte:
+ Configure as [fonte de dados](AMG-data-sources.md).
+ Certifique-se de que a fonte de dados escolhida seja compatível e suportada pelo [Grafana Alerting](v10-alerting-overview-datasources.md).
**Para configurar alertas**
1. Configure as [regras de alerta](v10-alerting-configure.md).
+ Crie regras de alerta e regras de gravação gerenciadas pelo Grafana ou gerenciadas pela fonte de dados.
1. Configure [pontos de contato](v10-alerting-configure-contactpoints.md).
+ Verifique o ponto de contato padrão e atualize o contato do sistema.
+ Opcionalmente, adicione novos pontos de contato e integrações.
1. Configurar [políticas de notificação](v10-alerting-explore-notifications-policies-details.md)
+ Verifique a política de notificação padrão e atualize o sistema.
+ Opcionalmente, adicione outras políticas aninhadas.
+ Opcionalmente, adicione rótulos e matchers de rótulos para controlar o roteamento de alertas.
Os tópicos a seguir fornecem mais informações sobre opções adicionais de configuração, incluindo a configuração de gerenciadores de alertas externos e o roteamento de alertas gerenciados pelo Grafana fora do Grafana.
**Topics**
+ [Migrar alertas clássicos do dashboard para o Grafana Alerting](v10-alerting-use-grafana-alerts.md)
+ [Adicionar um Alertmanager externo](v10-alerting-setup-alertmanager.md)
+ [Provisionar recursos do Grafana Alerting](v10-alerting-setup-provision.md)
# Migrar alertas clássicos do dashboard para 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).
Os espaços de trabalho que optam por não usar o Grafana Alerting usam os [Alertas clássicos do dashboard](old-alerts-overview.md). Para mudar para o novo Grafana Alerting, primeiro é necessário escolher o recurso. Para ver detalhes sobre as diferenças entre os alertas clássicos do painel e os alertas da Grafana, consulte. [Grafana Alerting versus alertas legados do dashboard](#v10-alerting-diff-old-new) GrafanaLabs anunciou que os alertas clássicos do painel serão removidos na versão 11.
Quando você usa alertas de dashboard clássicos, o Amazon Managed Grafana mostra uma pré-visualização dos alertas do Grafana, na qual você pode revisar e modificar os alertas atualizados antes de finalizar o upgrade.
## Pré-visualizar os alertas do Grafana
Você pode pré-visualizar seus alertas nos alertas do Grafana antes de migrar. Na pré-visualização, você pode fazer alterações nos alertas que mudarão a migração.
**Para pré-visualizar sua migração de alertas do Grafana**
1. Faça login no espaço de trabalho do Grafana.
1. No menu à esquerda, escolha **Alertas (legados)** para visualizar os alertas atuais.
1. No menu à esquerda, escolha **Atualização de alertas** para visualizar os alertas no Grafana Alerting.
Nessa visualização, você pode ver como ficarão os alertas após a migração.
**nota**
Nessa visualização, você também pode fazer alterações que afetarão a migração. Para desfazer as alterações feitas, escolha **Redefinir atualização** no canto superior direito da página de atualização.
Quando estiver pronto para atualizar os alertas, consulte a próxima seção.
## Migrar para o sistema do Grafana Alerting
Você pode configurar sua instância do Amazon Managed Grafana para usar alertas do Grafana usando o Console de gerenciamento da AWS, o AWS CLI ou a API Amazon Managed Grafana. Para obter detalhes sobre como configurar o Amazon Managed Grafana, incluindo ativar ou desativar o Grafana Alerting, consulte [Configurar um espaço de trabalho do Amazon Managed Grafana](AMG-configure-workspace.md).
Quando o Grafana Alerting está ativado, os alertas clássicos existentes do dashboard migram em um formato compatível com o Grafana Alerting. Na página de alertas da instância do Grafana, você pode visualizar os alertas migrados junto com os novos alertas. Com o Grafana Alerting, as regras de alerta gerenciadas pelo Grafana enviam várias notificações em vez de um único alerta quando são correspondidas.
O acesso de leitura e gravação aos alertas clássicos do dashboard e aos alertas do Grafana é regido pelas permissões das pastas que os armazenam. Durante a migração, as permissões clássicas de alerta do dashboard são correspondidas com as novas permissões de regras da seguinte forma:
+ Se o dashboard do alerta original tiver permissões, a migração criará uma pasta nomeada com este formato `Migrated {"dashboardUid": "UID", "panelId": 1, "alertId": 1}` para corresponder às permissões do dashboard original (incluindo as permissões herdadas da pasta).
+ Se não houver permissões no dashboard e ele estiver em uma pasta, a regra será vinculada a essa pasta e herdará suas permissões.
+ Se não houver permissões no dashboard e ele estiver na pasta Geral, a regra será vinculada à pasta Alertas gerais e ela herdará as permissões padrão.
**nota**
Como não há a opção de `Keep Last State` para alertas `NoData` no Grafana, essa opção passa a ser `NoData` durante a migração das regras clássicas. A opção `Keep Last State` de tratamento de `Error` é migrada para uma nova opção `Error`. Para corresponder ao comportamento do `Keep Last State`, em ambos os casos, durante a migração, o Amazon Managed Grafana cria automaticamente um silêncio para cada regra de alerta com duração de um ano.
Os canais de notificação são migrados para uma configuração do Alertmanager com as rotas e os receptores apropriados. Os canais de notificação padrão são adicionados como pontos de contato à rota padrão. Canais de notificação não associados a nenhum alerta do dashboard seguem a rota `autogen-unlinked-channel-recv`.
### Limitações
+ O sistema do Grafana Alerting pode recuperar regras de todas as fontes de dados disponíveis do Prometheus, Loki e Alertmanager. Talvez não seja possível obter regras de alerta de outras fontes de dados compatíveis.
+ A migração de ida e volta entre os alertas do Grafana e o alerta clássico do dashboard pode resultar na perda de dados dos recursos compatíveis em um sistema, mas não no outro.
**nota**
Caso migre de volta para o alerta clássico do dashboard, você perderá todas as alterações realizadas na configuração de alertas definida enquanto o Grafana Alerting estava ativado, incluindo todas as novas regras de alerta criadas.
## Grafana Alerting versus alertas legados do dashboard
Introduzido no Grafana 8, o Grafana Alerting tem vários aprimoramentos em relação aos alertas legados do dashboard.
### Alertas multidimensionais
Agora você pode criar alertas que oferecem visibilidade de todo o sistema com uma única regra de alerta. Gere várias instâncias de alerta de uma única regra de alerta. Por exemplo, você pode criar uma regra para monitorar o uso do disco de vários pontos de montagem em um único host. O mecanismo de avaliação retorna várias séries temporais de uma única consulta, com cada série temporal identificada pelo seu conjunto de rótulos.
### Criar alertas fora dos dashboards
Ao contrário dos alertas legados do dashboard, os alertas do Grafana permitem que você crie consultas e expressões que combinam dados de várias fontes de maneiras exclusivas. Você ainda pode vincular dashboards e painéis às regras de alerta usando seu ID e pode solucionar rapidamente os problemas do sistema sob observação.
Como os alertas unificados não estão mais diretamente vinculados às consultas do painel, eles não incluem imagens ou valores de consulta no e-mail de notificação. Você pode usar modelos de notificação personalizados para visualizar os valores da consulta.
### Criar regras de alertas para o Grafana Mimir e Loki
No Grafana Alerting, você pode gerenciar as regras de alertas do Loki e do Grafana Mimir usando a mesma interface e API dos alertas gerenciados pelo Grafana.
### Visualize e pesquise alertas de fontes de dados compatíveis com o Prometheus
Os alertas para fontes de dados compatíveis com o Prometheus agora estão listados na seção de alertas do Grafana. Você pode pesquisar rótulos em várias fontes de dados para encontrar rapidamente alertas relevantes.
### Alertas especiais para estado de alerta NoData e erro
O Grafana Alerting introduziu um novo conceito dos estados de alerta. Quando a avaliação de uma regra de alerta produz estado NoData ou erro, o Grafana Alerting gerará alertas especiais que terão os seguintes rótulos:
+ `alertname`com valor DatasourceNoData ou DatasourceError dependendo do estado.
+ `rulename` nome da regra de alerta à qual o alerta especial pertence.
+ `datasource_uid` terá o UID da fonte de dados que causou o estado.
+ Todos os rótulos e anotações da regra de alerta original.
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.
**nota**
Se a regra usar várias fontes de dados e uma ou várias não retornarem dados, o alerta especial será criado para cada fonte de dados que causou o estado de alerta.
# Adicionar um Alertmanager externo
****
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).
Configure o Grafana para usar um Alertmanager externo como o único Alertmanager para receber todos os alertas. Esse Alertmanager externo pode então ser configurado e administrado no próprio Grafana.
**nota**
Você não pode usar o Amazon Managed Service for Prometheus como um Alertmanager externo.
Depois de adicionar o alertmanager, você pode usar a interface de usuário do Grafana Alerting para gerenciar silêncios, pontos de contato e políticas de notificação. Uma opção suspensa nessas páginas permite que você alterne entre os alertmanagers.
Os alertmanagers externos são configurados como fontes de dados usando a configuração do Grafana no menu de navegação principal do Grafana. Isso permite que você gerencie os pontos de contato e as políticas de notificação de alertmanagers externos no Grafana e também criptografe as credenciais de autenticação básica HTTP que antes eram visíveis ao configurar alertmanagers externos por URL.
**nota**
A partir do Grafana 9.2, a configuração de URL dos alertmanagers externos na guia Admin na página Alertas está obsoleta. Ela será removida em uma versão futura.
**Para adicionar um Alertmanager externo**
1. No menu à esquerda, escolha **Conexões**.
1. Pesquise por `Alertmanager`.
1. Escolha o botão **Criar uma fonte de dados**.
1. Preencha os campos na página, conforme necessário.
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.
**nota**
As implementações do Prometheus, Grafana Mimir e Cortex do Alertmanager são compatíveis. Para o Prometheus, os pontos de contato e as políticas de notificação são somente leitura na interface de usuário do Grafana Alerting.
1. Escolha **Salvar e testar**.
# Provisionar recursos do 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).
A infraestrutura de alertas geralmente é complexa, com muitas partes do pipeline que geralmente residem em lugares diferentes. Escalar isso em várias equipes e organizações é uma tarefa especialmente desafiadora. O provisionamento do Grafana Alerting facilita esse processo, permitindo que você crie, gerencie e mantenha os dados de alerta da maneira mais adequada para a sua organização.
Existem duas opções de escolha:
1. Provisione os recursos de alerta usando a API HTTP de provisionamento de alerta.
**nota**
Normalmente, você não pode editar regras de alerta provisionadas por API na interface de usuário do Grafana.
Para ativar a edição, adicione o x-disable-provenance cabeçalho às seguintes solicitações ao criar ou editar suas regras de alerta na API:
```
POST /api/v1/provisioning/alert-rules
PUT /api/v1/provisioning/alert-rules/{UID}
```
1. Provisione os recursos de alerta usando o Terraform.
**nota**
Atualmente, o provisionamento do Grafana Alerting é compatível com regras de alerta, pontos de contato, tempos de desativação de áudio e modelos. Recursos de alerta provisionados usando o provisionamento de arquivos ou o Terraform só podem ser editados na fonte que os criou e não no Grafana ou em qualquer outra fonte. Por exemplo, se você provisionar os recursos de alerta usando arquivos do disco, não poderá editar os dados no Terraform ou no Grafana.
**Topics**
+ [Criar e gerenciar recursos de alertas usando o Terraform](v10-alerting-setup-provision-terraform.md)
+ [Visualizar recursos de alerta provisionados no Grafana](v10-alerting-setup-provision-view.md)
# Criar e gerenciar recursos de alertas usando o Terraform
****
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 o provedor do Grafana do Terraform para gerenciar os recursos de alerta e provisioná-los no sistema Grafana. A compatibilidade do provedor Terraform com o Grafana Alerting facilita a criação, o gerenciamento e a manutenção de toda a pilha do Grafana Alerting como código.
Para obter mais informações sobre como gerenciar os recursos de alerta usando o Terraform, consulte a documentação do [provedor do Grafana](https://registry.terraform.io/providers/grafana/grafana/latest/docs) na documentação do Terraform.
Conclua as tarefas a seguir para criar e gerenciar os recursos de alerta usando o Terraform.
1. Crie uma chave de API para provisionamento.
1. Configure o provedor do Terraform.
1. Defina os recursos de alerta no Terraform.
1. Execute `terraform apply` para provisionar os recursos de alerta.
## Pré-requisitos
+ Certifique-se de ter o [provedor grafana/grafana Terraform](https://registry.terraform.io/providers/grafana/grafana/1.28.0) 1.27.0 ou superior.
+ Certifique-se de usar o Grafana 9.1 ou superior. Se você criou a instância do Amazon Managed Grafana com o Grafana versão 9, isso será válido.
## Criar uma chave de API para provisionamento
Você pode [criar uma chave de API normal do Grafana](Using-Grafana-APIs.md) para autenticar o Terraform com o Grafana. A maioria das ferramentas existentes que usam chaves de API deve funcionar automaticamente com o novo suporte do Grafana Alerting. Para obter informações específicas sobre a criação de chaves para uso com o Terraform, consulte [Using Terraform for Amazon Managed Grafana automation](https://aws-observability.github.io/observability-best-practices/recipes/recipes/amg-automation-tf/).
**Para criar uma chave de API para provisionamento**
1. Crie uma nova conta de serviço para o pipeline de CI.
1. Atribua o perfil “Acessar as regras de alerta da API de provisionamento”.
1. Criar um token de conta de serviço.
1. Nomeie e salve o token para uso no Terraform.
Como alternativa, você pode usar uma autenticação básica. Para ver todos os formatos de autenticação compatíveis, consulte [Autenticação do Grafana](https://registry.terraform.io/providers/grafana/grafana/latest/docs#authentication) na documentação do Terraform.
## Configurar o provedor do Terraform
O suporte ao Grafana Alerting está incluído como parte do [provedor do Grafana do Terraform](https://registry.terraform.io/providers/grafana/grafana/latest/docs).
Veja a seguir um exemplo que você pode usar para configurar o provedor do Terraform.
```
terraform {
required_providers {
grafana = {
source = "grafana/grafana"
version = ">= 1.28.2"
}
}
}
provider "grafana" {
url =
auth =
}
```
## Provisionar pontos de contato e modelos
Os pontos de contato conectam uma pilha de alertas ao mundo exterior. Eles dizem ao Grafana como se conectar aos sistemas externos e onde entregar notificações. Há mais de quinze [integrações](https://registry.terraform.io/providers/grafana/grafana/latest/docs/resources/contact_point#optional) diferentes para você escolher. Este exemplo usa um ponto de contato do Slack.
**Para provisionar pontos de contato e modelos**
1. Copie esse bloco de código em um arquivo .tf na máquina local. **Substitua pelo URL do webhook do Slack (ou outros detalhes do ponto de contato).
Este exemplo cria um ponto de contato que envia notificações de alerta para o Slack.
```
resource "grafana_contact_point" "my_slack_contact_point" {
name = "Send to My Slack Channel"
slack {
url =
text = <
As políticas de notificação dizem ao Grafana como rotear instâncias de alerta, e não para onde. Elas conectam alertas disparados aos seus pontos de contato previamente definidos usando um sistema de rótulos e matchers.
**Para provisionar políticas de notificação e roteamento**
1. Copie esse bloco de código em um arquivo .tf na máquina local.
Neste exemplo, os alertas são agrupados por `alertname`, o que significa que todas as notificações provenientes de alertas que compartilham o mesmo nome são agrupadas na mesma mensagem do Slack.
Se quiser rotear notificações específicas de forma diferente, você pode adicionar subpolíticas. As subpolíticas permitem que você aplique o roteamento a diferentes alertas com base na correspondência de rótulos. Neste exemplo, aplicamos um tempo de desativação de áudio a todos os alertas com o rótulo a=b.
```
resource "grafana_notification_policy" "my_policy" {
group_by = ["alertname"]
contact_point = grafana_contact_point.my_slack_contact_point.name
group_wait = "45s"
group_interval = "6m"
repeat_interval = "3h"
policy {
matcher {
label = "a"
match = "="
value = "b"
}
group_by = ["..."]
contact_point = grafana_contact_point.a_different_contact_point.name
mute_timings = [grafana_mute_timing.my_mute_timing.name]
policy {
matcher {
label = "sublabel"
match = "="
value = "subvalue"
}
contact_point = grafana_contact_point.a_third_contact_point.name
group_by = ["..."]
}
}
}
```
1. No campo mute\$1timings, vincule um tempo de desativação de áudio à política de notificação.
1. Execute o comando `terraform apply`.
1. Acesse a interface de usuário do Grafana e verifique os detalhes da política de notificação.
**nota**
Você não pode editar recursos provisionados do Terraform na interface de usuário. Isso garante que a pilha de alertas esteja sempre sincronizada com o código.
1. Clique em **Testar** para verificar se o ponto de notificação está funcionando corretamente.
## Estipular tempos de desativação de áudio
Os tempos de desativação de áudio possibilitam desativar o áudio das notificações de alerta por períodos de tempo definidos.
**Para estipular tempos de desativação de áudio**
1. Copie esse bloco de código em um arquivo .tf na máquina local.
Neste exemplo, as notificações de alerta têm o áudio desativado nos finais de semana.
```
resource "grafana_mute_timing" "my_mute_timing" {
name = "My Mute Timing"
intervals {
times {
start = "04:56"
end = "14:17"
}
weekdays = ["saturday", "sunday", "tuesday:thursday"]
months = ["january:march", "12"]
years = ["2025:2027"]
}
}
```
1. Execute o comando `terraform apply`.
1. Acesse a interface de usuário do Grafana e verifique os detalhes do tempo de desativação de áudio.
1. Referencie o tempo de desativação de áudio recém-criado em uma política de notificação usando o campo `mute_timings`. Isso aplicará seu tempo de desativação de áudio a algumas ou a todas as notificações.
**nota**
Você não pode editar recursos provisionados do Terraform na interface de usuário. Isso garante que a pilha de alertas esteja sempre sincronizada com o código.
1. Clique em **Testar** para verificar se o tempo de desativação de áudio está funcionando corretamente.
## Provisionar regras de alerta
As [regras de alerta](v10-alerting-configure.md) permitem que você alerte sobre qualquer fonte de dados Grafana. Isso pode ser uma fonte de dados que você já configurou, ou você pode [definir as fontes de dados no Terraform](https://registry.terraform.io/providers/grafana/grafana/latest/docs/resources/data_source) junto com as regras de alerta.
**Para provisionar regras de alerta**
1. Crie uma fonte de dados para consultar e uma pasta para armazenar as regras.
Neste exemplo, a fonte de dados [Configurar uma fonte de TestData dados para testes](testdata-data-source.md) é usada.
Os alertas podem ser definidos em relação a qualquer fonte de dados de backend no Grafana.
```
resource "grafana_data_source" "testdata_datasource" {
name = "TestData"
type = "testdata"
}
resource "grafana_folder" "rule_folder" {
title = "My Rule Folder"
}
```
1. Defina uma regra de alerta.
Para obter mais informações sobre as regras de alerta, consulte [How to create Grafana-managed alerts](https://grafana.com/blog/2022/08/01/grafana-alerting-video-how-to-create-alerts-in-grafana-9/).
1. Crie um grupo de regras contendo uma ou mais regras.
Neste exemplo, o grupo de recursos `grafana_rule_group` é usado.
```
resource "grafana_rule_group" "my_rule_group" {
name = "My Alert Rules"
folder_uid = grafana_folder.rule_folder.uid
interval_seconds = 60
org_id = 1
rule {
name = "My Random Walk Alert"
condition = "C"
for = "0s"
// Query the datasource.
data {
ref_id = "A"
relative_time_range {
from = 600
to = 0
}
datasource_uid = grafana_data_source.testdata_datasource.uid
// `model` is a JSON blob that sends datasource-specific data.
// It's different for every datasource. The alert's query is defined here.
model = jsonencode({
intervalMs = 1000
maxDataPoints = 43200
refId = "A"
})
}
// The query was configured to obtain data from the last 60 seconds. Let's alert on the average value of that series using a Reduce stage.
data {
datasource_uid = "__expr__"
// You can also create a rule in the UI, then GET that rule to obtain the JSON.
// This can be helpful when using more complex reduce expressions.
model = <
****
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 verificar se os recursos de alerta foram criados no Grafana.
**Para visualizar os recursos provisionados no Grafana**
1. Abra a instância do Grafana.
1. Navegue até Alertas.
1. Clique em uma pasta de recursos de alerta, por exemplo, Regras de alerta.
Os recursos provisionados são rotulados como **Provisionados**, para que fique claro que eles não foram criados manualmente.
**nota**
Você não pode editar recursos provisionados do Grafana. Você só pode alterar as propriedades do recurso alterando o arquivo de provisionamento e reiniciando o Grafana ou realizando uma recarga dinâmica. Isso evita que sejam feitas alterações no recurso que seriam substituídas se um arquivo fosse provisionado novamente ou se uma recarga dinâmica fosse realizada.
# Configurar 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).
Configure os recursos e as integrações de que você precisa para criar e gerenciar os alertas.
**Topics**
+ [Configurar as regras de alertas gerenciados pelo Grafana](v10-alerting-configure-grafanamanaged.md)
+ [Configurar regras de alerta gerenciadas da fonte de dados](v10-alerting-configure-datasourcemanaged.md)
+ [Configurar regras de gravação](v10-alerting-configure-recordingrules.md)
+ [Configurar pontos de contato](v10-alerting-configure-contactpoints.md)
+ [Configurar políticas de notificação](v10-alerting-configure-notification-policies.md)
# Configurar as regras de alertas gerenciados pelo Grafana
****
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 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. O uso de imagens em notificações de alerta também é compatível. Este é o único tipo de regra que permite alertas de várias fontes de dados em uma única definição de regra.
Várias instâncias de alerta podem ser criadas como resultado de uma regra de alerta (também conhecida como alerta multidimensional).
As regras de alerta gerenciadas do Grafana só podem ser editadas ou excluídas por usuários com permissões de edição para a pasta que armazena as regras.
Caso exclua um recurso de alerta criado na interface de usuário, você não poderá mais recuperá-lo. Para fazer um backup de sua configuração e poder restaurar recursos de alerta excluídos, crie os recursos de alerta usando o Terraform ou a API de alertas.
Nos procedimentos a seguir, analisaremos o processo de criação das regras de alerta gerenciadas pelo Grafana.
Para criar uma regra de alerta gerenciada pelo Grafana, use o fluxo de criação de alertas no espaço de trabalho e siga estas etapas para ajudar.
**Definir nome da regra de alerta**
1. Escolha **Alertas** -> **Regras de alerta** -> **\$1 Nova regra de alerta**.
1. Insira um nome para identificar a regra do alerta.
Este nome é exibido na lista de regras de alerta. Também é o rótulo `alertname` de cada instância de alerta criada dessa regra.
Em seguida, defina uma consulta para obter os dados que você deseja avaliar e uma condição que precisa ser atendida antes que uma regra de alerta seja disparada.
**Para definir a consulta e condição**
1. Selecione uma fonte de dados.
1. No menu suspenso **Opções**, especifique um [intervalo de tempo](v10-dash-using-dashboards.md#v10-dash-setting-dashboard-time-range).
**nota**
O Grafana Alerting é compatível apenas com intervalos de tempo relativos fixos, por exemplo, `now-24hr: now`.
Ele não é compatível com intervalos de tempo absolutos: `2021-12-02 00:00:00 to 2021-12-05 23:59:592`, ou intervalos de tempo semirrelativos: `now/d to: now`.
1. Adicione uma consulta.
Para adicionar várias [consultas](v10-panels-query-xform.md#v10-panels-query-xform-add), escolha **Adicionar consulta**.
Todas as regras de alerta são gerenciadas pelo Grafana por padrão. Se você quiser mudar para uma regra de alerta gerenciada pela fonte de dados, clique em **Alternar para a regra de alerta gerenciada pela fonte de dados**.
1. Adicione uma ou mais [expressões](v10-panels-query-xform-expressions.md).
1. Para cada expressão, selecione a **condição Clássica** para criar uma única regra de alerta, ou escolha entre as opções **Matemática**, **Redução** e **Reamostragem** para gerar um alerta separado para cada série.
**nota**
Ao usar o Prometheus, você pode usar um vetor instantâneo e funções integradas, então não é necessário adicionar expressões extras.
1. Escolha **Pré-visualizar** para verificar se a expressão teve êxito.
1. [Opcional] Para adicionar um limite de recuperação, ative o botão de alternância **Limite de recuperação personalizado** e preencha um valor para quando a regra de alerta deve parar de disparar.
Você pode adicionar apenas um limite de recuperação em uma consulta e esta deve ser a condição de alerta.
1. Escolha **Definir como condição de alerta** na consulta ou expressão que você deseja definir como condição de alerta.
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.
**Para definir o comportamento de avaliação de alertas**
1. Selecione uma pasta ou escolha **\$1 Nova pasta**.
1. Selecione um grupo de avaliação ou clique em **\$1 Novo grupo de avaliação**.
Se você estiver criando um novo grupo de avaliação, especifique o intervalo para o grupo.
Todas as regras do mesmo grupo são avaliadas simultaneamente no mesmo intervalo de tempo.
1. Insira um período de pendência.
O período de pendência é o período em que uma regra de alerta pode violar a condição até ser disparada.
Quando uma condição é atendida, o alerta entra no estado **Pendente**. Se a condição permanecer ativa pelo período especificado, o alerta passará para o estado de **Disparado**. Caso contrário, ele retornará para o estado **Normal**.
1. Ative as notificações de alerta de pausa, se necessário.
**nota**
Pause a avaliação da regra de alerta para evitar alertas ruidosos enquanto os ajusta. A pausa interrompe a avaliação da regra de alerta e não cria nenhuma instância de alerta. Isso é diferente dos tempos de desativação de áudio, que impedem a entrega de notificações, mas ainda permitem a avaliação das regras de alerta e a criação de instâncias de alerta.
Você pode pausar a avaliação da regra de alerta para evitar alertas ruidosos enquanto os ajusta. A pausa interrompe a avaliação da regra de alerta e não cria nenhuma instância de alerta. Isso é diferente dos tempos de desativação de áudio, que impedem a entrega de notificações, mas ainda permitem a avaliação das regras de alerta e a criação de instâncias de alerta.
1. Em **Configurar tratamento de erros e ausência de dados**, configure o comportamento do alerta na ausência de dados.
Use as diretrizes mais adiante nesta seção.
Adicione rótulos às regras de alerta para definir qual política de notificação deve lidar com as instâncias de alertas disparados.
Todas as regras e instâncias de alerta, independentemente de seus rótulos, correspondem à política de notificação padrão. Se não houver políticas aninhadas ou nenhuma política aninhada corresponder aos rótulos na regra de alerta ou na instância de alerta, a política de notificação padrão será a política correspondente.
**Como configurar notificações**
1. Adicione rótulos se quiser alterar a forma como as notificações são roteadas.
Adicione rótulos personalizados selecionando pares de chave/valor existentes no menu suspenso ou adicione novos rótulos inserindo a nova chave ou valor.
1. Pré-visualize a configuração do roteamento de instâncias de alertas.
Com base nos rótulos adicionados, as instâncias de alerta são roteadas para as políticas de notificação exibidas.
Expanda cada política de notificação para ver mais detalhes.
1. Escolha **Ver detalhes** para visualizar os detalhes do roteamento de alertas e uma pré-visualização.
Adicione [anotações](v10-alerting-overview-labels.md#v10-alerting-overview-labels-annotations) para fornecer mais contexto sobre o alerta na mensagem de notificação de alerta.
As anotações adicionam metadados para fornecer mais informações sobre o alerta na mensagem de notificação de alerta. Por exemplo, adicione uma anotação de **Resumo** para informar qual valor causou o disparo do alerta ou em qual servidor ele aconteceu.
**Para adicionar anotações**
1. [Opcional] Adicione um resumo.
Breve resumo do que aconteceu e o porquê.
1. (Opcional) Adicione uma descrição.
Descrição do que a regra de alerta faz.
1. [Opcional] Adicione um URL do runbook.
Página da Web em que você guarda o runbook para o alerta
1. [Opcional] Adicionar uma anotação personalizada
1. [Opcional] Adicione um link para o painel e o dashboard.
Vincula alertas a painéis em um dashboard.
1. Selecione a apção **Salvar regra**.
**Regra única e multidimensional**
Para alertas gerenciados pelo Grafana, você pode criar uma regra com uma condição clássica ou criar uma regra multidimensional.
+ **Regra com condição clássica**
Use a expressão de condição clássica para criar uma regra que aciona um único alerta quando sua condição é atendida. Para uma consulta que retorna várias séries, o Grafana não rastreia o estado de alerta de cada série. Como resultado, o Grafana envia apenas um único alerta, mesmo quando as condições de alerta são atendidas para várias séries.
+ **Regra multidimensional**
Para gerar um alerta separado para cada série, crie uma regra multidimensional. Use as expressões `Math`, `Reduce` ou `Resample` para criar uma regra multidimensional. Por exemplo:
+ Adicione uma expressão `Reduce` para cada consulta para agregar valores no intervalo de tempo selecionado em um único valor (não é necessário para [regras que usam dados numéricos](v10-alerting-overview-numeric.md)).
+ Adicione uma expressão `Math` com a condição para a regra. Não é necessário caso uma consulta ou expressão de redução já retorne `0` se a regra não for disparada, ou um número positivo se ela for disparada. Alguns exemplos: `$B > 70` se ele deve disparar caso o valor de B query/expression seja maior que 70. `$B < $C * 100`caso deva disparar se o valor de B for menor que o valor de C multiplicado por 100. Se as consultas que estão sendo comparadas tiverem várias séries nos resultados, as séries de consultas diferentes serão correspondidas se tiverem os mesmos rótulos, ou se uma for um subconjunto da outra.
**nota**
O Grafana não é compatível com consultas de alerta com variáveis de modelo. Mais informações estão disponíveis em [https://comtemplate-variables-are-notmunity.grafana.com/t/](https://community.grafana.com/t/template-variables-are-not-supported-in-alert-queries-while-setting-up-alert/2514) - - /2514. supported-in-alert-queries while-setting-up-alert
**Configurar tratamento de erros e ausência de dados**
Configure o comportamento do alerta quando a avaliação da regra de alerta não retornar nenhum dado ou retornar um erro.
**nota**
As regras de alerta configuradas para serem disparadas quando uma avaliação não retornar dados ou retornar um erro só são disparadas quando toda a duração do período de avaliação termina. Isso significa que, em vez de disparar imediatamente quando a condição da regra de alerta é violada, a regra de alerta espera até que o tempo definido no campo **Por** termine e, em seguida, dispara, reduzindo o ruído do alerta e permitindo problemas temporários de disponibilidade de dados.
Se a avaliação da regra de alerta não retornar dados, você poderá definir o estado da regra de alerta para que apareça da seguinte forma:
| Nenhum dado | Description |
| --- | --- |
| Nenhum dado | Cria um novo alerta DatasourceNoData com o nome e o UID da regra de alerta e o UID da fonte de dados que não retornou dados como rótulos. |
| Geração de alertas | Define o estado da regra do alerta como Alerting. A regra de alerta espera até que o tempo definido no campo Por termine antes de disparar. |
| Ok | Define o estado da regra do alerta como Normal. |
Se a avaliação retornar um erro, você poderá definir o estado na regra de alerta para que apareça da seguinte forma:
| Erro | Description |
| --- | --- |
| Erro | Cria uma instância de alerta DatasourceError com o nome e o UID da regra de alerta e o UID da fonte de dados que não retornou nenhum dado como rótulo. |
| Geração de alertas | Define o estado da regra do alerta como Alerting. A regra de alerta espera até que o tempo definido no campo Por termine antes de disparar. |
| Ok | Define o estado da regra do alerta como Normal. |
**Resolver instâncias de alerta obsoletas**
Uma instância de alerta será considerada obsoleta se sua dimensão ou série tiver desaparecido completamente dos resultados da consulta em dois intervalos de avaliação.
Instâncias de alerta obsoletas que estão nos estados `Alerting`, `NoData` e `Error` são automaticamente marcadas como `Resolved`, e a anotação `grafana_state_reason` é adicionada à instância de alerta com o motivo `MissingSeries`.
**Criar alertas em painéis**
Crie alertas de qualquer tipo de painel. Isso significa que você pode reutilizar as consultas no painel e criar alertas com base nelas.
1. Navegue até um dashboard na seção **Dashboards**.
1. No canto superior direito do painel, escolha os três pontos (elipses).
1. No menu suspenso, selecione **Mais...** e escolha **Nova regra de alerta**.
Isso abrirá o formulário da regra de alerta, permitindo que você configure e crie o alerta com base na consulta do painel atual.
# Configurar regras de alerta gerenciadas da fonte de dados
****
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).
Crie regras de alerta para uma instância externa do Grafana Mimir ou Loki que tenha a API Ruler habilitada. Elas são chamadas de regras de alerta gerenciadas pela fonte de dados.
**nota**
As regras de alerta para uma instância externa do Grafana Mimir ou Loki podem ser editadas ou excluídas por usuários com perfis de editor ou administrador.
Caso exclua um recurso de alerta criado na interface de usuário, você não poderá mais recuperá-lo. Para fazer um backup de sua configuração e poder restaurar recursos de alerta excluídos, crie os recursos de alerta usando o Terraform ou a API de alertas.
**Pré-requisitos**
+ Verifique se você tem permissão de gravação na fonte de dados Prometheus ou Loki. Do contrário, você não poderá criar ou atualizar as regras de alertas gerenciados pelo Grafana Mimir.
+ Para as fontes de dados Grafana Mimir e Loki, habilite a API Ruler configurando seus respectivos serviços.
+ **Loki**: o tipo de armazenamento `local` de regras, padrão para a fonte de dados Loki, é compatível apenas com a visualização de regras. Para editar regras, configure um dos outros tipos de armazenamento de regras.
+ **Grafana Mimir**: use o prefixo `/prometheus`. A fonte de dados Prometheus é compatível com o Grafana Mimir e o Prometheus, e o Grafana espera que a [API Query](https://grafana.com/docs/mimir/latest/operators-guide/reference-http-api/#querier--query-frontend) e a [API Ruler](https://grafana.com/docs/mimir/latest/operators-guide/reference-http-api/#ruler) estejam no mesmo URL. Você não pode fornecer um URL separado para a API Ruler.
**nota**
Se você não quiser gerenciar as regras de alerta para uma fonte de dados específica Loki ou do Prometheus, acesse as configurações e desmarque a caixa de seleção **Gerenciar alertas por meio da interface de usuário de alertas**.
Nos procedimentos a seguir, orientaremos você no processo de criação das regras de alerta gerenciadas pela fonte de dados.
Para criar uma regra de alerta gerenciada pela fonte de dados, use o fluxo de criação de alertas no espaço de trabalho e siga estas etapas para ajudar.
**Para definir o nome da regra de alerta**
1. Escolha **Alertas** -> **Regras de alerta** -> **\$1 Nova regra de alerta**.
1. Insira um nome para identificar a regra do alerta.
Este nome é exibido na lista de regras de alerta. Também é o rótulo `alertname` de cada instância de alerta criada dessa regra.
Defina uma consulta para obter os dados que você deseja avaliar e uma condição que precisa ser atendida antes que uma regra de alerta seja disparada.
**Para definir a consulta e a condição**
1. Todas as regras de alerta são gerenciadas pelo Grafana por padrão. Para mudar para uma regra de alerta gerenciada pela fonte de dados, escolha **Alternar para regra de alerta gerenciada pela fonte de dados**.
1. Selecione uma fonte de dados na lista suspensa.
Você também pode escolher **Abrir seletor de fonte de dados avançado** para ver mais opções, incluindo adicionar uma fonte de dados (somente administradores).
1. Insira uma consulta PromQL ou LogQL.
1. Escolha **Pré-visualizar alertas**.
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 definir o comportamento de avaliação de alertas**
1. Selecione um namespace ou escolha **\$1 Novo namespace**.
1. Selecione um grupo de avaliação ou escolha **\$1 Novo grupo de avaliação**.
Se você estiver criando um novo grupo de avaliação, especifique o intervalo para o grupo.
Todas as regras do mesmo grupo são avaliadas sequencialmente no mesmo intervalo de tempo.
1. Insira um período de pendência.
O período de pendência é o período em que uma regra de alerta pode violar a condição até ser disparada.
Quando uma condição é atendida, o alerta entra no estado `Pending`. Se a condição permanecer ativa pelo período especificado, o alerta mudará para o estado `Firing`, do contrário, retornará para o estado `Normal`.
Adicione rótulos às regras de alerta para definir qual política de notificação deve lidar com as instâncias de alertas disparados.
Todas as regras e instâncias de alerta, independentemente de seus rótulos, correspondem à política de notificação padrão. Se não houver políticas aninhadas ou nenhuma política aninhada corresponder aos rótulos na regra de alerta ou na instância de alerta, a política de notificação padrão será a política correspondente.
**Configurar notificações do**
+ Adicione rótulos se quiser alterar a forma como as notificações são roteadas.
Adicione rótulos personalizados selecionando pares de chave/valor existentes no menu suspenso ou adicione novos rótulos inserindo a nova chave ou valor.
Adicione [anotações](v10-alerting-overview-labels.md#v10-alerting-overview-labels-annotations) para fornecer mais contexto sobre o alerta nas notificações de alerta.
As anotações adicionam metadados para fornecer mais informações sobre o alerta nas notificações de alerta. Por exemplo, adicione uma anotação de `Summary` para informar qual valor causou o disparo do alerta ou em qual servidor ele aconteceu.
**Para adicionar anotações**
1. [Opcional] Adicione um resumo.
Breve resumo do que aconteceu e o porquê.
1. (Opcional) Adicione uma descrição.
Descrição do que a regra de alerta faz.
1. [Opcional] Adicione um URL do runbook.
Página da Web em que você guarda o runbook para o alerta
1. [Opcional] Adicionar uma anotação personalizada
1. [Opcional] Adicione um link para o painel e o dashboard.
Vincula alertas a painéis em um dashboard.
1. Selecione a apção **Salvar regra**.
# Configurar 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).
Você pode criar e gerenciar regras de gravação para uma instância externa do Grafana Mimir ou Loki. As regras de gravação calculam expressões frequentemente necessárias ou computacionalmente caras e salvam os resultados como um novo conjunto de séries temporais. 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.
**nota**
As regras de gravação são executadas como regras de instância e a cada dez segundos.
**Pré-requisitos**
+ Verifique se você tem permissões de gravação na fonte de dados Prometheus ou Loki. Você criará ou atualizará as regras de alerta na fonte de dados.
+ Para as fontes de dados Grafana Mimir e Loki, habilite a API Ruler configurando seus respectivos serviços.
+ **Loki**: o tipo de armazenamento `local` de regras, padrão para a fonte de dados Loki, é compatível apenas com a visualização de regras. Para editar regras, configure um dos outros tipos de armazenamento.
+ **Grafana Mimir**: use o prefixo `/prometheus`. A fonte de dados Prometheus é compatível com o Grafana Mimir e o Prometheus, e o Grafana espera que a API Query e a API Ruler estejam no mesmo URL. Você não pode fornecer um URL separado para a API Ruler.
**nota**
Se você não quiser gerenciar as regras de alertas para uma fonte de dados Loki ou Prometheus específica, acesse as configurações e desmarque a caixa de seleção **Gerenciar alertas por meio da interface de usuário de alertas**.
**Para criar regras de gravação**
1. No console do Grafana, no menu Grafana, escolha **Alertas**, **Regras de alerta**.
1. Escolha **Nova regra de gravação**.
1. Defina o nome da regra.
O nome da regra de gravação deve ser um nome de métrica do Prometheus e não deve conter espaços em branco.
1. Definir consulta
+ Selecione a fonte de dados Loki ou Prometheus.
+ Insira uma consulta.
1. Adicione namespace e grupo.
+ No menu suspenso **Namespace**, selecione um namespace de regra existente ou adicione um novo. Os namespaces podem conter um ou mais grupos de regras e ter apenas uma finalidade organizacional.
+ No menu suspenso **Grupo**, selecione um grupo existente no namespace selecionado ou adicione um novo. As regras recém-criadas são anexadas ao final do grupo. As regras em um grupo são executadas sequencialmente em intervalos regulares, com o mesmo tempo de avaliação.
1. Adicione rótulos.
+ Adicione rótulos personalizados selecionando pares de chave/valor existentes no menu suspenso, ou adicione novos rótulos inserindo a nova chave ou valor.
1. Escolha **Salvar regra** para salvar a regra ou **Salvar regra e sair** para salvar a regra e voltar para a página de alertas.
# Configurar 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).
Use pontos de contato para definir como seus contatos são notificados quando uma regra de alerta é disparada.
**nota**
Você pode criar e editar pontos de contato para alertas gerenciados pelo Grafana. Os pontos de contato para alertas gerenciados por fontes de dados são somente para leitura.
## Trabalhar com pontos de contato
Os procedimentos a seguir mostram como adicionar, editar, excluir e testar um ponto de contato.
**Para adicionar um ponto de contato**
1. No menu à esquerda, selecione **Alertas**.
1. Escolha **Pontos de contato**.
1. No menu suspenso **Escolher Alertmanager**, selecione um Alertmanager. O Grafana Alertmanager é selecionado por padrão.
1. Na guia **Pontos de contato**, escolha **\$1 Adicionar ponto de contato**.
1. Insira um **Nome** para o ponto de contato.
1. Em **Integração**, escolha um tipo e preencha os campos obrigatórios com base nesse tipo. Por exemplo, se você escolher o Slack, insira os canais e os usuários do Slack que devem ser contatados.
1. Se disponível para o ponto de contato selecionado, escolha as ** configurações opcionais** desejadas para especificar configurações adicionais.
1. Em **Configurações de notificação**, selecione opcionalmente **Desabilitar mensagem resolvida** se não quiser ser notificado quando um alerta for resolvido.
1. Para adicionar outra integração de ponto de contato, escolha **Adicionar integração de ponto de contato** e repita as etapas para cada tipo de ponto de contato necessário.
1. Salve as alterações.
**Para editar um ponto de contato**
1. No menu à esquerda, selecione **Alertas**.
1. Escolha **Pontos de contato** para ver uma lista dos pontos de contato existentes.
1. Selecione o ponto de contato a ser editado e escolha **Editar**.
1. Atualize o ponto de contato e salve as alterações.
Você pode excluir pontos de contato que não estão sendo usados por uma política de notificação.
**Para excluir um ponto de contato**
1. No menu à esquerda, selecione **Alertas**.
1. Escolha **Pontos de contato** para abrir a lista de pontos de contato existentes.
1. Em **Pontos de contato**, selecione o ponto de contato a ser excluído e escolha **Mais**, **Excluir**.
1. Na caixa de diálogo de confirmação, escolha **Sim, excluir**.
**nota**
Se o ponto de contato estiver sendo usado por uma política de notificação, você deverá excluir ou editar a política de notificação para usar outro ponto de contato antes de excluí-lo.
Depois que seu ponto de contato for criado, você poderá enviar uma notificação de teste para verificar se ele está configurado corretamente.
**Para enviar uma notificação de teste**
1. No menu à esquerda, selecione **Alertas**.
1. Escolha **Pontos de contato** para abrir a lista de pontos de contato existentes.
1. Em **Pontos de contato**, selecione o ponto de contato a ser testado e escolha **Editar**. Se necessário, você pode criar um ponto de contato.
1. Escolha **Testar** para abrir a caixa de diálogo de teste de ponto de contato.
1. Escolha se deseja enviar uma notificação de teste predefinida ou escolha **Personalizado** para adicionar suas próprias anotações e rótulos personalizados na notificação de teste.
1. Escolha **Enviar notificação de teste** para testar o alerta com os pontos de contato fornecidos.
## Configurar integrações de pontos de contato
Configure as integrações de pontos de contato no Grafana para selecionar seu canal de comunicação preferencial para receber notificações quando suas regras de alerta estiverem sendo disparadas. Cada integração tem suas próprias opções e processo de configuração. Na maioria dos casos, isso envolve fornecer uma chave de API ou um URL do webhook.
Depois de configurado, você pode usar integrações como parte de seus pontos de contato para receber notificações sempre que o alerta mudar de estado. Nesta seção, abordaremos as etapas básicas para configurar uma integração, usando PagerDuty como exemplo, para que você possa começar a receber alertas em tempo real e ficar por dentro de seus dados de monitoramento.
**Lista de integrações 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` |
**Configurando PagerDuty para alertas**
Para configurar PagerDuty, você deve fornecer uma chave de integração. Forneça os detalhes a seguir.
| Configuração | Description |
| --- | --- |
| Chave de integração | Chave de integração para PagerDuty |
| Gravidade | Nível para notificações dinâmicas. O padrão é critical. |
| Detalhes personalizados | Detalhes adicionais sobre o evento |
O campo `CustomDetails` é um objeto contendo pares arbitrários de chave/valor. Os detalhes definidos pelo usuário são mesclados com os usados por padrão.
Os valores padrão para `CustomDetails` são:
```
{
"firing": `{{ template "__text_alert_list" .Alerts.Firing }}`,
"resolved": `{{ template "__text_alert_list" .Alerts.Resolved }}`,
"num_firing": `{{ .Alerts.Firing | len }}`,
"num_resolved": `{{ .Alerts.Resolved | len }}`,
}
```
No caso de chaves duplicadas, os detalhes definidos pelo usuário substituem os padrões.
# Configurar 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 determinam como os alertas são roteados para os pontos de contato.
As políticas têm uma estrutura em árvore, em que cada política pode ter uma ou mais políticas aninhadas. Cada política, exceto a política padrão, também pode corresponder a rótulos de alerta específicos.
Cada alerta é avaliado pela política padrão e, posteriormente, por cada política aninhada.
Se você habilitar a opção `Continue matching subsequent sibling nodes` para uma política aninhada, a avaliação continuará mesmo após uma ou mais correspondências. As configurações de uma política principal e as informações do ponto de contato controlam o comportamento de um alerta que não corresponde a nenhuma das políticas secundárias. Uma política padrão controla qualquer alerta que não corresponda a uma política aninhada.
Para obter mais informações sobre políticas de notificação, consulte [Notificações](v10-alerting-explore-notifications.md).
Os procedimentos a seguir mostram como criar e gerenciar políticas de notificação.
**Para editar a política de notificação padrão**
1. No menu à esquerda, selecione **Alertas**.
1. Escolha **Políticas de notificação**.
1. No menu suspenso **Escolher Alertmanager**, selecione o Alertmanager que você deseja editar.
1. Na seção **Política de chaves**, escolha **...**, **Editar**.
1. Em **Ponto de contato padrão**, atualize o ponto de contato para o qual as notificações devem ser enviadas para as regras quando as regras de alerta não corresponderem a nenhuma política específica.
1. Em **Agrupar por**, escolha os rótulos pelos quais agrupar alertas. Se vários alertas corresponderem a essa política, eles serão agrupados por esses rótulos. Uma notificação é enviada por grupo. Se o campo estiver vazio (o padrão), todas as notificações serão enviadas em um único grupo. Use um rótulo especial `...` para agrupar alertas por todos os rótulos (o que efetivamente desativa o agrupamento).
1. Em **Opções de tempo**, selecione uma das opções a seguir.
+ **Espera em grupo**: tempo de espera para armazenar em buffer alertas do mesmo grupo antes de enviar uma notificação inicial. O padrão é 30 segundos.
+ **Intervalo de grupo**: intervalo mínimo de tempo entre duas notificações para um grupo. O padrão é 5 minutos.
+ **Intervalo de repetição**: intervalo mínimo de tempo antes de reenviar uma notificação, caso nenhum novo alerta tenha sido adicionado ao grupo. O padrão é quatro horas.
1. Escolha **Salvar** para salvar as alterações.
Para criar uma política de notificação, você precisa seguir a estrutura em árvore. As políticas criadas no tronco da árvore (a política padrão) são os galhos da árvore. Cada filial pode ter suas próprias políticas aninhadas. É por isso que você sempre adicionará uma nova política **aninhada**, seja na política padrão, seja em uma política já aninhada.
**Para adicionar uma nova política aninhada**
1. No menu à esquerda, selecione **Alertas**.
1. Escolha **Políticas de notificação**.
1. No menu suspenso **Escolher Alertmanager**, selecione o Alertmanager que você deseja editar.
1. Para adicionar uma política específica de nível superior, vá para a seção Roteamento específico (para a política padrão ou para outra política existente em que você gostaria de adicionar uma nova política aninhada) e escolha **\$1 Nova política aninhada**.
1. Na seção rótulos correspondentes, adicione uma ou mais regras para combinar rótulos de alerta.
1. No menu suspenso **Ponto de contato**, selecione o ponto de contato para o qual enviar notificações se um alerta corresponder somente a essa política específica e não a nenhuma das políticas aninhadas.
1. Opcionalmente, habilite **Continuar correspondendo os nós irmãos subsequentes** para continuar correspondendo as políticas irmãs mesmo depois que o alerta tiver correspondido à política atual. Quando esta opção está habilitada, você pode receber mais de uma notificação para um alerta.
1. Opcionalmente, habilite **Substituir agrupamento** para especificar o mesmo agrupamento da política padrão. Se a opção não estiver habilitada, o agrupamento de políticas padrão será usado.
1. Opcionalmente, habilite **Substituir tempos gerais** para substituir as opções de tempo configuradas na política de notificação de grupo.
1. Para salvar suas alterações, selecione **Salvar política**.
**Para editar uma política aninhada**
1. No menu à esquerda, selecione **Alertas**.
1. Escolha **Políticas de notificação**.
1. Selecione a política que deseja editar e escolha **...**, **Editar**.
1. Faça qualquer alteração (como ao adicionar uma política aninhada).
1. Salve as alterações.
**Pesquisar políticas**
Você pode pesquisar na árvore de políticas por *Matchers de rótulos* ou *pontos de contato*.
+ Para pesquisar por ponto de contato, insira um nome parcial ou completo de um ponto de contato no campo **Pesquisar por ponto de contato**. As políticas que usam esse ponto de contato serão destacadas na interface do usuário.
+ Para pesquisar por rótulo, insira um matcher de rótulo válido no campo de entrada **Pesquisar por matchers**. Vários matchers podem ser inseridos, separados por uma vírgula. Por exemplo, uma entrada de matcher válida pode ser `severity=high, region=~EMEA|NA`.
**nota**
Ao pesquisar por rótulo, todas as políticas correspondentes serão exatamente iguais. Correspondências parciais e correspondências no estilo regex não são compatíveis.
# Gerenciar os 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).
Depois de configurar as regras de alerta, os pontos de contato e as políticas de notificação, você pode usar o Grafana Alerting para gerenciar os alertas na prática.
**Topics**
+ [Personalizar notificações](v10-alerting-manage-notifications.md)
+ [Gerenciar pontos de contato](v10-alerting-manage-contactpoints.md)
+ [Silenciar notificações de alerta](v10-alerting-silences.md)
+ [Visualizar e filtrar regras de alerta](v10-alerting-manage-rules-viewfilter.md)
+ [Tempos de desativação de áudio](v10-alerting-manage-muting.md)
+ [Visualize o estado e a integridade das regras de alerta](v10-alerting-manage-rulestate.md)
+ [Visualizar e filtrar por grupos de alertas](v10-alerting-manage-viewfiltergroups.md)
+ [Visualizar erros de notificação](v10-alerting-manage-viewnotificationerrors.md)
# Personalizar 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).
Personalize suas notificações com modelos de notificações.
Você pode usar modelos de notificação para alterar o título, a mensagem e o formato da mensagem em suas notificações.
Os modelos de notificação não estão vinculados a integrações específicas de pontos de contato, como o Amazon SNS ou Slack. Porém, você pode optar por criar modelos de notificação separados para diferentes integrações de pontos de contato.
Você pode usar modelos de notificação para:
+ Adicionar, remover ou reordenar informações na notificação, incluindo o resumo, a descrição, os rótulos e anotações, os valores e os links
+ Formatar texto em negrito e itálico e adicionar ou remover quebras de linha
Você não pode não usar modelos de notificação para:
+ Alterar o design das notificações em serviços de mensagens instantâneas, como o Slack e o Microsoft Teams
**Topics**
+ [Usar a linguagem de modelos do Go](v10-alerting-notifications-go-templating.md)
+ [Criar modelos de notificações](v10-alerting-create-templates.md)
+ [Usar modelos de notificações](#v10-alerting-use-notification-templates)
+ [Referência do modelo](v10-alerting-template-reference.md)
# Usar a linguagem de modelos do Go
****
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ê escreve modelos de notificação na linguagem de modelos do Go, [texto/modelo](https://pkg.go.dev/text/template).
Esta seção fornece uma visão geral da linguagem de modelos e dos modelos de escrita do Go em texto/modelo.
## Ponto
text/template Há um cursor especial chamado ponto e é escrito como`.`. Você pode pensar nesse cursor como uma variável cujo valor muda dependendo de onde ele é usado no modelo. Por exemplo, no início de um modelo de notificação, `.` refere-se ao objeto `ExtendedData`, que contém vários campos, incluindo `Alerts`, `Status`, `GroupLabels`, `CommonLabels`, `CommonAnnotations` e `ExternalURL`. No entanto, ponto pode se referir a outra coisa quando usado em um `range` em uma lista, quando usado dentro de um `with` ou ao escrever modelos de recursos para serem usados em outros modelos. Você pode ver exemplos disso em [Criar modelos de notificações](v10-alerting-create-templates.md), e todos os dados e funções na [Referência do modelo](v10-alerting-template-reference.md).
## 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 valor do ponto, um campo do ponto, o resultado de uma função e o valor de uma [variável](#v10-go-variables). Por exemplo, para imprimir o campo `Alerts` em que o ponto se refere a `ExtendedData`, você escreve o seguinte:
```
{{ .Alerts }}
```
## Iterar em alertas
Para imprimir apenas os rótulos de cada alerta, em vez de todas as informações sobre o alerta, você pode usar um `range` para iterar os alertas em`ExtendedData`:
```
{{ range .Alerts }}
{{ .Labels }}
{{ end }}
```
Dentro do intervalo, o ponto não mais se refere a `ExtendedData`, mas a um `Alert`. Você pode usar `{{ .Labels }}` para imprimir os rótulos de cada alerta. Isso funciona porque `{{ range .Alerts }}` altera o ponto para se referir ao alerta atual na lista de alertas. Quando o intervalo termina, o ponto é redefinido para o valor que tinha antes do início do intervalo, que neste exemplo é `ExtendedData`:
```
{{ range .Alerts }}
{{ .Labels }}
{{ end }}
{{/* does not work, .Labels does not exist here */}}
{{ .Labels }}
{{/* works, cursor was reset */}}
{{ .Status }}
```
## Iterar em anotações e rótulos
Vamos escrever um modelo para imprimir os rótulos de cada alerta no formato `The name of the label is $name, and the value is $value`, em que `$name` e `$value` contêm o nome e o valor de cada rótulo.
Como no exemplo anterior, use um intervalo para iterar nos alertas em `.Alerts` de forma que o ponto se refira ao alerta atual na lista de alertas e, em seguida, use um segundo intervalo nos rótulos classificados para que o ponto seja atualizado uma segunda vez para se referir ao rótulo atual. Dentro do segundo intervalo, use `.Name` e `.Value` para imprimir o nome e o valor de cada rótulo:
```
{{ range .Alerts }}
{{ range .Labels.SortedPairs }}
The name of the label is {{ .Name }}, and the value is {{ .Value }}
{{ end }}
{{ range .Annotations.SortedPairs }}
The name of the annotation is {{ .Name }}, and the value is {{ .Value }}
{{ end }}
{{ end }}
```
## As funções de índice
Para imprimir uma anotação ou rótulo específico, use a função `index`.
```
{{ range .Alerts }}
The name of the alert is {{ index .Labels "alertname" }}
{{ end }}
```
## Instruções If
Você pode usar instruções if em modelos. Por exemplo, para imprimir `There are no alerts` se não houver alertas em `.Alerts`, você escreve o seguinte:
```
{{ if .Alerts }}
There are alerts
{{ else }}
There are no alerts
{{ end }}
```
## With
With é semelhante às instruções if, porém, diferentemente das instruções if, o `with` atualiza o ponto para se referir ao valor do with:
```
{{ with .Alerts }}
There are {{ len . }} alert(s)
{{ else }}
There are no alerts
{{ end }}
```
## Variáveis
As variáveis em text/template devem ser criadas dentro do modelo. Por exemplo, para criar uma variável chamada `$variable` com o valor atual de ponto, você escreve o seguinte:
```
{{ $variable := . }}
```
Você pode usar `$variable` dentro de um intervalo ou `with` e vai se referir ao valor do ponto no momento em que a variável foi definida, não ao valor atual do ponto.
Por exemplo, você não pode escrever um modelo que use `{{ .Labels }}` no segundo intervalo porque aqui o ponto se refere ao rótulo atual, não ao alerta atual:
```
{{ range .Alerts }}
{{ range .Labels.SortedPairs }}
{{ .Name }} = {{ .Value }}
{{/* does not work because in the second range . is a label not an alert */}}
There are {{ len .Labels }}
{{ end }}
{{ end }}
```
Você pode corrigir isso definindo uma variável chamada `$alert` no primeiro intervalo e antes do segundo intervalo:
```
{{ range .Alerts }}
{{ $alert := . }}
{{ range .Labels.SortedPairs }}
{{ .Name }} = {{ .Value }}
{{/* works because $alert refers to the value of dot inside the first range */}}
There are {{ len $alert.Labels }}
{{ end }}
{{ end }}
```
## Intervalo com índice
Você pode obter o índice de cada alerta em um intervalo definindo variáveis de índice e valor no início do intervalo:
```
{{ $num_alerts := len .Alerts }}
{{ range $index, $alert := .Alerts }}
This is alert {{ $index }} out of {{ $num_alerts }}
{{ end }}
```
## Definir modelos
Você pode definir modelos que podem ser usados em outros modelos, usando `define` e o nome do modelo entre aspas duplas. Você não deve definir modelos com o mesmo nome de outros modelos, incluindo modelos padrão, como `__subject`, `__text_values_list`, `__text_alert_list`, `default.title` e `default.message`. Quando um modelo foi criado com o mesmo nome de um modelo padrão, ou um modelo em outro modelo de notificação, o Grafana pode usar qualquer um dos modelos. O Grafana não impossibilita nem mostra uma mensagem de erro quando há dois ou mais modelos com o mesmo nome.
```
{{ define "print_labels" }}
{{ end }}
```
## Executar modelos
Você pode executar um modelo definido no seu modelo usando `template`, o nome do modelo entre aspas duplas e o cursor que deve ser passado para o modelo:
```
{{ template "print_labels" . }}
```
## Passar dados para modelos
Em um modelo, o ponto refere-se ao valor que é passado para o modelo.
Por exemplo, se um modelo receber uma lista de alertas disparados, o ponto então vai se referir a essa lista de alertas disparados:
```
{{ template "print_alerts" .Alerts }}
```
Se o modelo receber os rótulos classificados para um alerta, o ponto então vai se referir à lista de rótulos classificados:
```
{{ template "print_labels" .SortedLabels }}
```
Isso é útil ao escrever modelos reutilizáveis. Por exemplo, para imprimir todos os alertas, você pode escrever o seguinte:
```
{{ template "print_alerts" .Alerts }}
```
Depois, para imprimir apenas os alertas disparados, você pode escrever o seguinte:
```
{{ template "print_alerts" .Alerts.Firing }}
```
Isso funciona porque tanto `.Alerts` como `.Alerts.Firing` são listas de alertas.
```
{{ define "print_alerts" }}
{{ range . }}
{{ template "print_labels" .SortedLabels }}
{{ end }}
{{ end }}
```
## Comentários
Você pode adicionar comentários com `{{/*` e `*/}}`:
```
{{/* This is a comment */}}
```
Para evitar que comentários adicionem quebras de linha, use:
```
{{- /* This is a comment with no leading or trailing line breaks */ -}}
```
## Recuo
Você pode usar recuo, tabs e espaços e quebras de linha para tornar os modelos mais legíveis:
```
{{ range .Alerts }}
{{ range .Labels.SortedPairs }}
{{ .Name }} = {{ .Value }}
{{ end }}
{{ end }}
```
No entanto, o recuo no modelo também estará presente no texto. A seguir, veremos como removê-lo.
## Remover espaços e quebras de linha
Em text/template uso `{{-` e `-}}` para remover espaços à esquerda e à direita e quebras de linha.
Por exemplo, ao usar recuo e quebras de linha para tornar um modelo mais legível:
```
{{ range .Alerts }}
{{ range .Labels.SortedPairs }}
{{ .Name }} = {{ .Value }}
{{ end }}
{{ end }}
```
O recuo e as quebras de linha também estarão presentes no texto:
```
alertname = "Test"
grafana_folder = "Test alerts"
```
Você pode remover o recuo e as quebras de linha do texto, alterando `}}` para `-}}` no início de cada intervalo:
```
{{ range .Alerts -}}
{{ range .Labels.SortedPairs -}}
{{ .Name }} = {{ .Value }}
{{ end }}
{{ end }}
```
O recuo e as quebras de linha no modelo agora estão ausentes do texto:
```
alertname = "Test"
grafana_folder = "Test alerts"
```
# Criar modelos de 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).
Crie modelos de notificação reutilizáveis para enviar aos pontos de contato.
Você pode adicionar um ou mais modelos ao modelo de notificação.
O nome do modelo de notificação deve ser exclusivo. Você não pode ter dois modelos com o mesmo nome no mesmo modelo de notificação ou em modelos de notificação diferentes. Evite definir modelos com o mesmo nome dos modelos padrão, como: `__subject`, `__text_values_list`, `__text_alert_list`, `default.title` e `default.message`.
Na guia Pontos de contato, você pode ver uma lista dos modelos de notificação.
## Criar modelos de notificação
**Para criar um modelo de notificação**
1. Escolha **Alertas**, **Pontos de contato**.
1. Escolha a guia **Modelos de notificação** e, em seguida, **\$1 Adicionar modelo de notificação**.
1. Escolha um nome para o modelo de notificação, como `email.subject`.
1. Escreva o conteúdo do modelo no campo de conteúdo.
Por exemplo:
```
{{ if .Alerts.Firing -}}
{{ len .Alerts.Firing }} firing alerts
{{ end }}
{{ if .Alerts.Resolved -}}
{{ len .Alerts.Resolved }} resolved alerts
{{ end }}
```
1. Salve as alterações.
`{{ define "email.subject" }}` (em que `email.subject` é o nome do seu modelo) e `{{ end }}` é automaticamente adicionado ao início e ao final do conteúdo.
**Para criar um modelo de notificação que contenha mais de um modelo**
1. Escolha **Alertas**, **Pontos de contato**.
1. Escolha a guia **Modelos de notificação** e, em seguida, **\$1 Adicionar modelo de notificação**.
1. Insira um nome para o modelo geral de notificação. Por exemplo, .`email`
1. Escreva cada modelo no campo Conteúdo, incluindo `{{ define "name-of-template" }}` e `{{ end }}` no início e no final de cada modelo. Você pode usar nomes descritivos para cada um dos modelos no modelo de notificação, por exemplo, `email.subject` ou `email.message`. Nesse caso, não reutilize o nome do modelo de notificação inserido acima.
As seções posteriores mostram exemplos detalhados de modelos que você pode criar.
1. Clique em Salvar.
## Pré-visualização dos modelos de notificações
Pré-visualize seus modelos de notificação antes de usá-los nos pontos de contato, ajudando você a entender o resultado do modelo que está criando e dando a chance de corrigir quaisquer erros antes de salvá-lo.
**nota**
As pré-visualizações de notificações estão disponíveis apenas para o Grafana Alertmanager.
**Para pré-visualizar os modelos de notificação**
1. Escolha **Alertas**, **Pontos de contato**.
1. Escolha a guia **Modelos de notificação** e, em seguida, **\$1 Adicionar modelo de notificação**, ou edite um modelo existente.
1. Adicione ou atualize o conteúdo do modelo.
Os dados padrão são fornecidos e você pode adicionar ou editar dados de alerta a eles, bem como às instâncias de alerta. Você pode adicionar dados de alerta diretamente na própria janela de dados da carga útil ou clicar em **Selecionar instâncias de alerta** ou **Adicionar alertas personalizados**.
1. [Opcional] Para adicionar dados de alerta de instâncias de alerta existentes:
1. Escolha **Selecionar instâncias de alerta**.
1. Passe o mouse sobre as instâncias de alerta para ver mais informações sobre cada instância de alerta.
1. Escolha **Confirmar** para adicionar a instância de alerta à carga útil.
1. [Opcional] Para adicionar dados de alerta usando o editor de dados de alertas, escolha **Adicionar dados personalizados**:
1. Adicione anotações, rótulos personalizados ou defina um dashboard ou painel.
1. Alterne entre Disparado ou Resolvido, dependendo se você deseja adicionar alertas disparados ou resolvidos à sua notificação.
1. Escolha **Adicionar dados de alertas**.
1. Escolha **Atualizar pré-visualização** para ver como ficará o conteúdo do seu modelo e os dados de carga útil correspondentes.
Se houver algum erro em seu modelo, ele será exibido na pré-visualização e você poderá corrigi-lo antes de salvá-lo.
1. Salve as alterações.
## Criar um modelo para o assunto da mensagem
Crie um modelo para o assunto de um e-mail que contenha o número de alertas disparados e resolvidos, como neste exemplo:
```
1 firing alerts, 0 resolved alerts
```
**Para criar um modelo para o assunto de um e-mail**
1. Crie um arquivo denominado `email.subject` com o seguinte conteúdo:
```
{{ define "email.subject" }}
{{ len .Alerts.Firing }} firing alerts, {{ len .Alerts.Resolved }} resolved alerts
{{ end }}
```
1. Use o modelo ao criar sua integração de ponto de contato, colocando-a no campo **Assunto** com a palavra-chave `template`.
```
{{ template "email.subject" . }}
```
## Criar um modelo para a mensagem de um e-mail
Crie um modelo para a mensagem de um e-mail que contenha um resumo de todos os alertas disparados e resolvidos, como neste exemplo:
```
There are 2 firing alerts, and 1 resolved alerts
Firing alerts:
- alertname=Test 1 grafana_folder=GrafanaCloud has value(s) B=1
- alertname=Test 2 grafana_folder=GrafanaCloud has value(s) B=2
Resolved alerts:
- alertname=Test 3 grafana_folder=GrafanaCloud has value(s) B=0
```
**Para criar um modelo para a mensagem de um e-mail**
1. Crie um modelo de notificação denominado `email` com dois modelos no conteúdo: `email.message_alert` e `email.message`.
O modelo `email.message_alert` é usado para imprimir os rótulos e os valores de cada alerta disparado e resolvido, enquanto o modelo `email.message` contém a estrutura do e-mail.
```
{{- define "email.message_alert" -}}
{{- range .Labels.SortedPairs }}{{ .Name }}={{ .Value }} {{ end }} has value(s)
{{- range $k, $v := .Values }} {{ $k }}={{ $v }}{{ end }}
{{- end -}}
{{ define "email.message" }}
There are {{ len .Alerts.Firing }} firing alerts, and {{ len .Alerts.Resolved }} resolved alerts
{{ if .Alerts.Firing -}}
Firing alerts:
{{- range .Alerts.Firing }}
- {{ template "email.message_alert" . }}
{{- end }}
{{- end }}
{{ if .Alerts.Resolved -}}
Resolved alerts:
{{- range .Alerts.Resolved }}
- {{ template "email.message_alert" . }}
{{- end }}
{{- end }}
{{ end }}
```
1. Use o modelo ao criar a integração de ponto de contato, colocando-a no campo **Corpo do texto** com a palavra-chave `template`.
```
{{ template "email.message" . }}
```
## Criar um modelo para o título de uma mensagem do Slack
Crie um modelo para o título de uma mensagem do Slack que contenha o número de alertas disparados e resolvidos, como no seguinte exemplo:
```
1 firing alerts, 0 resolved alerts
```
**Para criar um modelo para o título de uma mensagem do Slack**
1. Crie um arquivo denominado `slack.title` com o seguinte conteúdo:
```
{{ define "slack.title" }}
{{ len .Alerts.Firing }} firing alerts, {{ len .Alerts.Resolved }} resolved alerts
{{ end }}
```
1. Execute o modelo no campo de título na integração do ponto de contato.
```
{{ template "slack.title" . }}
```
## Criar um modelo para o conteúdo de uma mensagem do Slack
Crie um modelo para o conteúdo de uma mensagem do Slack que contenha uma descrição de todos os alertas disparados e resolvidos, incluindo seus rótulos, anotações e URL do dashboard.
**nota**
Este modelo é apenas para alertas gerenciados pelo Grafana. Para usar o modelo para alertas gerenciados pela fonte de dados, exclua as referências a DashboardURL e SilenceURL. Para obter mais informações sobre como configurar as notificações do Prometheus, consulte a [documentação do Prometheus sobre notificações](https://prometheus.io/docs/alerting/latest/notifications/).
```
1 firing alerts:
[firing] Test1
Labels:
- alertname: Test1
- grafana_folder: GrafanaCloud
Annotations:
- description: This is a test alert
Go to dashboard: https://example.com/d/dlhdLqF4z?orgId=1
1 resolved alerts:
[firing] Test2
Labels:
- alertname: Test2
- grafana_folder: GrafanaCloud
Annotations:
- description: This is another test alert
Go to dashboard: https://example.com/d/dlhdLqF4z?orgId=1
```
**Para criar um modelo para o conteúdo de uma mensagem do Slack**
1. Crie um modelo denominado `slack` com dois modelos no conteúdo: `slack.print_alert` e `slack.message`.
O modelo `slack.print_alert` é usado para imprimir os rótulos, as anotações e o DashboardURL, enquanto o modelo `slack.message` contém a estrutura da notificação.
```
{{ define "slack.print_alert" -}}
[{{.Status}}] {{ .Labels.alertname }}
Labels:
{{ range .Labels.SortedPairs -}}
- {{ .Name }}: {{ .Value }}
{{ end -}}
{{ if .Annotations -}}
Annotations:
{{ range .Annotations.SortedPairs -}}
- {{ .Name }}: {{ .Value }}
{{ end -}}
{{ end -}}
{{ if .DashboardURL -}}
Go to dashboard: {{ .DashboardURL }}
{{- end }}
{{- end }}
{{ define "slack.message" -}}
{{ if .Alerts.Firing -}}
{{ len .Alerts.Firing }} firing alerts:
{{ range .Alerts.Firing }}
{{ template "slack.print_alert" . }}
{{ end -}}
{{ end }}
{{ if .Alerts.Resolved -}}
{{ len .Alerts.Resolved }} resolved alerts:
{{ range .Alerts.Resolved }}
{{ template "slack.print_alert" .}}
{{ end -}}
{{ end }}
{{- end }}
```
1. Execute o modelo no campo do corpo do texto na integração do ponto de contato:
```
{{ template "slack.message" . }}
```
## Criar modelos para o e-mail e Slack com modelos compartilhados
Em vez de criar modelos de notificação separados para cada ponto de contato, como e-mail e Slack, você pode compartilhar o mesmo modelo.
Por exemplo, se você quiser enviar um e-mail com esse assunto e uma mensagem do Slack com este título `1 firing alerts, 0 resolved alerts`, você pode criar um modelo compartilhado.
**Para criar um modelo compartilhado**
1. Crie um arquivo denominado `common.subject_title` com o seguinte conteúdo:
```
{{ define "common.subject_title" }}
{{ len .Alerts.Firing }} firing alerts, {{ len .Alerts.Resolved }} resolved alerts
{{ end }}
```
1. Para e-mail, execute o modelo no campo de assunto na integração do ponto de contato de e-mail:
```
{{ template "common.subject_title" . }}
```
1. Para o Slack, execute o modelo no campo de título na integração do ponto de contato do Slack:
```
{{ template "common.subject_title" . }}
```
## Usar modelos de notificações
Use modelos em pontos de contato para personalizar as notificações.
**Para usar um modelo ao criar um ponto de contato**
1. No menu **Alertas**, escolha a guia **Pontos de contato** para ver uma lista dos pontos de contato existentes.
1. Escolha **Novo**. Como alternativa, você pode editar um ponto de contato existente escolhendo o ícone de **Editar**.
1. Insira os modelos que você deseja usar em um campo, como **Mensagem** ou **Assunto**. Para inserir um modelo, use o formulário`{{ template "template_name" . }}`, *template\$1name* substituindo-o pelo nome do modelo que você deseja usar.
1. Escolha **Salvar ponto de contato**.
# Referência do modelo
****
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).
Esta seção fornece informações de referência para criar os modelos.
**Alerta (tipo)**
O tipo de alerta contém os dados a seguir.
| Nome | Tipo | Description | Exemplo |
| --- | --- | --- | --- |
| Status | string | `firing` ou `resolved`. | \$1\$1 .Status \$1\$1 |
| Rótulos | KeyValue | Um conjunto de rótulos anexados ao alerta. | \$1\$1 .Labels \$1\$1 |
| Anotações | KeyValue | Um conjunto de anotações anexadas ao alerta. | \$1\$1 .Annotations \$1\$1 |
| Valores | KeyValue | Os valores de todas as expressões, incluindo as condições clássicas | \$1\$1 .Values \$1\$1 |
| StartsAt | time.Time | Hora em que o alerta começou a disparar. | \$1\$1 .StartsAt \$1\$1 |
| EndsAt | time.Time | Definido somente se a hora de término de um alerta for conhecida. Caso contrário, defina um período de tempo limite configurável a partir do momento em que o último alerta foi recebido. | \$1\$1 .EndsAt \$1\$1 |
| GeneratorURL | string | Um link de retorno para o Grafana ou para o Alertmanager externo. | \$1\$1 .GeneratorURL \$1\$1 |
| SilenceURL | string | Um link para silenciar o alerta (com rótulos para esse alerta pré-preenchidos). Somente para alertas gerenciados pelo Grafana. | \$1\$1 .SilenceURL\$1\$1 |
| DashboardURL | string | Link para o dashboard do Grafana, se a regra de alerta pertencer a um. Somente para alertas gerenciados pelo Grafana. | \$1\$1 .DashboardURL \$1\$1 |
| PanelURL | string | Link para o painel do dashboard do Grafana, se a regra de alerta pertencer a um. Somente para alertas gerenciados pelo Grafana. | \$1\$1 .PanelURL \$1\$1 |
| Impressão digital | string | Impressão digital que pode ser usada para identificar o alerta. | \$1\$1 .Fingerprint \$1\$1 |
| ValueString | string | Uma string que contém os rótulos e o valor de cada expressão reduzida no alerta. | \$1\$1 .ValueString \$1\$1 |
**ExtendedData**
O ExtendedData objeto contém as seguintes propriedades.
| Nome | Tipo | Description | Exemplo |
| --- | --- | --- | --- |
| Receptor | `string` | O nome do ponto de contato que envia a notificação. | `{{ .Receiver }}` |
| Status | `string` | O status será `firing` se pelo menos um alerta estiver sendo disparado, do contrário, `resolved`. | `{{ .Status }}` |
| Alertas | `[]Alert` | Lista de todos os alertas disparados e resolvidos nesta notificação. | `There are {{ len .Alerts }} alerts` |
| Alertas disparados | `[]Alert` | Lista de todos os alertas disparados nesta notificação. | `There are {{ len .Alerts.Firing }} firing alerts` |
| Alertas resolvidos | `[]Alert` | Lista de todos os alertas resolvidos nesta notificação. | `There are {{ len .Alerts.Resolved }} resolved alerts` |
| GroupLabels | `KeyValue` | Os rótulos que agrupam esses alertas nesta notificação. | `{{ .GroupLabels }}` |
| CommonLabels | `KeyValue` | Os rótulos comuns a todos os alertas nesta notificação. | `{{ .CommonLabels }}` |
| CommonAnnotations | `KeyValue` | As anotações comuns a todos os alertas nesta notificação. | `{{ .CommonAnnotations }}` |
| ExternalURL | `string` | Um link para o espaço de trabalho do Grafana ou para o Alertmanager que enviou esta notificação. | `{{ .ExternalURL }}` |
**KeyValue tipo**
O `KeyValue` tipo é um conjunto de pares de key/value strings que representam rótulos e anotações.
Além do acesso direto aos dados armazenados como um `KeyValue`, também existem métodos para classificar, remover e transformar os dados.
| Nome | Argumentos | Retornos | Observações | Exemplo |
| --- | --- | --- | --- | --- |
| SortedPairs | | Lista ordenada de pares de strings de chave e valor | | `{{ .Annotations.SortedPairs }}` |
| Remover | []string | KeyValue | Retorna uma cópia do Key/Value mapa sem as chaves fornecidas. | `{{ .Annotations.Remove "summary" }}` |
| Nomes | | []string | Lista de nomes | `{{ .Names }}` |
| Valores | | []string | Lista de valores | `{{ .Values }}` |
**Tempo**
A hora vem do pacote [https://pkg.go.dev/time#Time](https://pkg.go.dev/time#Time) do Go. Você pode imprimir uma hora em vários formatos diferentes. Por exemplo, para imprimir a hora em que um alerta foi disparado no formato `Monday, 1st January 2022 at 10:00AM`, você escreve o seguinte modelo:
```
{{ .StartsAt.Format "Monday, 2 January 2006 at 3:04PM" }}
```
Você pode encontrar uma referência para o formato de hora do Go [aqui](https://pkg.go.dev/time#pkg-constants).
# Gerenciar 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).
A visualização da lista **Pontos de contato** lista todos os pontos de contato e modelos de notificação existentes.
Na guia **Pontos de contato**, você pode:
+ Pesquisar nomes e tipos de pontos de contato e integrações.
+ Visualizar todos os pontos de contato e integrações existentes.
+ Visualizar para quantas políticas de notificação cada ponto de contato está sendo usado e navegar diretamente até as políticas de notificação vinculadas.
+ Visualizar o status das entregas de notificações.
+ Exportar pontos de contato individuais ou todos os pontos de contato no formato JSON, YAML ou Terraform.
+ Excluir pontos de contato que não estão sendo usados por uma política de notificação.
Na guia **Modelos de notificação**, você pode:
+ Visualizar, editar, copiar ou excluir modelos de notificações existentes.
# Silenciar notificações 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).
Você pode suprimir as notificações de alerta com um *silêncio*. Um silêncio só impede a criação de notificações: os silêncios não impedem que as regras de alerta sejam avaliadas e não impedem que as instâncias de alerta sejam mostradas na interface do usuário. Ao silenciar um alerta, você especifica uma janela de tempo para que ele seja suprimido.
**nota**
Para suprimir as notificações de alerta em intervalos regulares, por exemplo, durante períodos regulares de manutenção, use [Tempos de desativação de áudio](v10-alerting-manage-muting.md) em vez de silêncios.
**Para adicionar um silêncio**
1. No console do Grafana, no menu Grafana, escolha **Alertas**.
1. Escolha **Silêncios**.
1. Escolha um Alertmanager no menu suspenso **Alertmanager**.
1. Escolha **Criar silêncio**.
1. Selecione a data de início e de término em **Início e término do silêncio** para indicar quando o silêncio deve entrar em vigor e quando deve terminar.
1. Como alternativa à definição de um horário de término, em **Duração**, especifique por quanto tempo o silêncio será aplicado. Isso atualiza automaticamente a hora de término no campo **Início e término do silêncio**.
1. Nos campos **Rótulo** e **Valor**, insira um ou mais *Rótulos correspondentes*. Os matchers determinam a quais regras o silêncio se aplica. Todos os alertas correspondentes (no estado disparado) serão exibidos no campo **Instâncias de alertas afetadas**.
1. Opcionalmente, adicione um **Comentário** descrevendo o silêncio.
1. Selecione **Enviar**.
**Para editar um silêncio**
1. No console do Grafana, no menu Grafana, escolha **Alertas**.
1. Escolha **Silêncios** para ver a lista de silêncios existentes.
1. Encontre o silêncio que você deseja editar e escolha **Editar** (ícone da caneta).
1. Faça as alterações desejadas e, em seguida, escolha **Enviar** para salvar as alterações.
Você pode editar um silêncio existente escolhendo o ícone de **Editar** (caneta).
**Para criar um link de URL para um formulário de silêncio**
Ao vincular a um formulário de silêncio, forneça o comentário e os rótulos correspondentes padrão por meio dos parâmetros de consulta `matcher` e `comment`. O parâmetro `matcher` deve estar no formato `[label][operator][value]`, em que o parâmetro `operator` pode ser um dos seguintes: `=` (equals, not regex), `!=` (not equals, not regex), `=~` (equals, regex), `!~` (not equals, regex). O URL pode conter vários parâmetros de consulta com a chave `matcher`. Por exemplo, para criar um link para um formulário de silêncio com os rótulos `severity=critical` e `cluster!~europe-.*` e o comentário `Silence critical EU alerts` correspondentes, crie um URL `https://mygrafana/alerting/silence/new?matcher=severity%3Dcritical&matcher=cluster!~europe-*&comment=Silence%20critical%20EU%20alert`.
Para vincular a uma nova página de silêncio de um Alertmanager externo, adicione um parâmetro de consulta `alertmanager`.
**Para remover um silêncio**
1. No console do Grafana, no menu Grafana, escolha **Alertas**.
1. Escolha **Silêncios** para ver a lista de silêncios existentes.
1. Selecione o silêncio que você deseja encerrar e escolha **Cancelar silêncio**. Isso encerra a supressão do alerta.
**nota**
O cancelamento do silêncio encerra a supressão do alerta, como se o horário de término estivesse definido para o horário atual. Os silêncios que terminaram (automática ou manualmente) são retidos e listados por cinco dias. Você não pode remover um silêncio da lista manualmente.
# Visualizar e filtrar 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).
A página **Alertas** lista as regras de alerta. Por padrão, as regras são agrupadas por tipos de fontes de dados. A seção **Grafana** lista as regras gerenciadas pelo Grafana. As regras de alerta para fontes de dados Prometheus compatíveis também estão listadas aqui. Você pode visualizar as regras de alerta para fontes de dados compatíveis com o Prometheus, mas não pode editá-las.
A seção de Mimir/Cortex/Loki regras lista todas as regras para fontes de dados Mimir, Cortex ou Loki. As regras de alerta na nuvem também estão listadas nesta seção.
Ao gerenciar grandes volumes de alertas, você pode usar recursos estendidos de pesquisa de regras de alerta para filtrar pastas, grupos de avaliação e regras. Além disso, você pode filtrar as regras de alerta por suas propriedades, como rótulos, estado, tipo e integridade.
## Visualizar regras de alerta
Ao usar o Grafana Alerting, você pode visualizar todos os alertas em uma página.
**Para visualizar detalhes de alertas**
1. No console do Grafana, no menu Grafana, escolha **Alertas**, **Regras de alerta**. Por padrão, a visualização de lista é exibida.
1. Em **Visualizar como**, você pode alternar entre as visualizações Agrupado, Lista e Estado ao escolher a opção de sua preferência.
1. Expanda a linha de regras para visualizar os rótulos das regras, as anotações, as fontes de dados, as consultas de regras e uma lista de instâncias de alerta resultantes da regra.
Nessa página, você também pode fazer cópias de uma regra de alerta para ajudar a reutilizar as regras existentes.
## Exportar regras de alertas
Você pode exportar regras para YAML ou JSON na área de trabalho do Grafana.
+ Escolha o ícone de **Exportar grupo de regras** ao lado de cada grupo de regras de alerta para exportar para YAML, JSON ou Terraform.
+ Escolha **Exportar regras** para exportar todas as regras de alerta gerenciadas pelo Grafana para YAML, JSON ou Terraform.
+ Escolha **Mais**, **Modificar exportação** ao lado de cada regra de alerta individual em um grupo para editar as regras de alerta provisionadas e exportar uma versão modificada.
## Visualizar definições de consulta de alertas provisionados
Visualize definições de consulta somente leitura de alertas provisionados. Verifique rapidamente se as consultas de regras de alerta estão corretas, sem precisar recorrer ao repositório “as-code” para ver as definições de regras.
**Visualização agrupada**
A visualização agrupada mostra as regras de alerta do Grafana agrupadas por pasta e as regras de alerta do Loki ou Prometheus agrupadas por `namespace` \$1 `group`. Esta é a visualização padrão da lista de regras, destinada ao gerenciamento de regras. Você pode expandir cada grupo para ver uma lista de regras dele. Expanda ainda mais uma regra para visualizar os detalhes. Você também pode expandir os botões de ação e os alertas resultantes da regra para ver os detalhes.
**Visualização Estado**
A visualização Estado mostra as regras de alerta agrupadas por estado. Use essa visualização para ter uma visão geral de quais regras estão em qual estado. Cada regra pode ser expandida para visualizar seus detalhes. Botões de ação e quaisquer alertas gerados por essa regra, e cada alerta pode ser expandido ainda mais para exibir seus detalhes.
## Filtrar regras de alerta
Você pode filtrar as regras de alerta que aparecem na página **Alertas** de diversas formas.
**Para filtrar regras de alerta**
1. Em **Selecionar fontes de dados**, selecione uma fonte de dados. Você pode ver as regras de alerta que consultam a fonte de dados selecionada.
1. Em **Pesquisar por rótulo**, insira os critérios de pesquisa usando seletores de rótulos. Por exemplo, .`environment=production;region=~US|EU,severity!=warning`
1. Em **Filtrar alertas por estado**, selecione um estado de alerta que você deseja ver. Você pode ver as regras de alerta que correspondem a esse estado. As regras que correspondem a outros estados estão ocultas.
# Tempos de desativação de áudio
****
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 tempo de desativação de áudio é um intervalo de tempo recorrente em que nenhuma nova notificação de uma política é gerada ou enviada. Use-o para evitar que os alertas sejam disparados por um período específico e recorrente, por exemplo, um período de manutenção regular.
Assim como os silêncios, os tempos de desativação de áudio não impedem que as regras de alerta sejam avaliadas nem impedem que as instâncias de alerta sejam mostradas na interface do usuário. Eles apenas impedem que as notificações sejam criadas.
Você pode configurar os tempos de desativação de áudio gerenciados do Grafana bem como os horários de desativação de áudio para uma fonte de dados externa do Alertmanager.
## Tempos de desativação de áudio versus silêncios
A tabela a seguir destaca as diferenças entre tempos de silêncio e de desativação de áudio.
| Tempo de desativação de áudio | Silêncio |
| --- | --- |
| Usa definições de intervalo de tempo que podem ocorrer novamente. | Tem um horário de início e término fixo. |
| É criado e, em seguida, adicionado às políticas de notificação. | Usa rótulos para fazer correspondência com um alerta para determinar se deve ser silenciado ou não. |
## Adicionar um tempo de desativação de áudio
Você pode criar tempos de desativação de áudio no seu espaço de trabalho do Grafana.
**Para adicionar um tempo de desativação de áudio**
1. No console do Grafana, no menu Grafana, escolha **Alertas**.
1. Escolha **Políticas de notificação** e, em seguida, selecione a guia **Tempos de desativação de áudio**.
1. No menu suspenso do **Alertmanager**, selecione o Alertmanager que deseja editar.
1. Escolha o botão **\$1 Adicionar tempo de desativação de áudio**.
1. Preencha o formulário para criar um [intervalo de tempo](#v10-alerting-manage-muting-interval) para corresponder ao tempo de desativação de áudio.
1. Salve o tempo de desativação de áudio.
## Adicionar um tempo de desativação de áudio a uma política de notificação
Depois de definir um tempo de desativação de áudio, você o adiciona à política de notificação da qual você deseja desativar o áudio em intervalos regulares.
**Para adicionar um tempo de desativação de áudio a uma política de notificação**
1. No console do Grafana, no menu Grafana, escolha **Alertas**.
1. Escolha **Políticas de notificação** e depois selecione a guia **Políticas de notificação**.
1. Selecione a política de notificação à qual você gostaria de adicionar o tempo de desativação de áudio e escolha **...**, **Editar**.
1. No menu suspenso **Tempos de desativação de áudio**, selecione os tempos de desativação de áudio que você gostaria de adicionar à política.
1. Salve as alterações.
## Intervalos de tempo
Um intervalo de tempo é uma duração específica durante a qual os alertas são suprimidos. A duração geralmente consiste em um intervalo de tempo específico e nos dias da semana, mês ou ano.
As opções de intervalo de tempo compatíveis são:
+ **Intervalo de tempo**: o tempo incluindo a hora de início, mas não a hora de término (em UTC, se nenhum local tiver sido selecionado, será usado o horário local).
+ **Localização**: define a localização do tempo; o intervalo de tempo é exibido na hora local do local.
+ **Dias da semana**: o dia ou o intervalo de dias da semana. Por exemplo, .`monday:thursday`
+ **Dias do mês**: as datas em um mês. Os valores de podem variar de `1` a `31`. Valores negativos especificam os dias do mês na ordem inversa, então `-1` representa o último dia do mês.
+ **Meses**: os meses do ano no formato numérico ou de nome completo do mês do calendário. Por exemplo, .`1, may:august`
+ **Anos**: o ano ou os anos do intervalo. Por exemplo, .`2023:2024`
Cada um desses elementos pode ser uma lista, e pelo menos um item no elemento deve ser satisfeito para corresponder. Os campos também são compatíveis com intervalos, usando `:`. Por exemplo, .`monday:thursday`
Se um campo for deixado em branco, qualquer instante de tempo corresponderá ao campo. Para que um instante corresponda a um intervalo de tempo completo, todos os campos devem corresponder. Um tempo de desativação de áudio pode conter vários intervalos de tempo.
Se você quiser especificar uma duração exata, especifique todas as opções necessárias para essa duração. Por exemplo, se você quiser criar um intervalo de tempo para a primeira segunda-feira do mês, para março, junho, setembro e dezembro, entre 12:00 e 24:00 UTC, a especificação de intervalo de tempo poderá ser:
+ Intervalo de tempo:
+ Horário de início: `12:00`
+ Horário de término: `24:00`
+ Dia da semana: `monday`
+ Meses: `3, 6, 9, 12`
+ Dias do mês: `1:7`
# Visualize o estado e a integridade das 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 estado e a integridade das regras de alerta fornecem vários indicadores-chave de status sobre os alertas.
Existem três componentes:
+ [Estado da regra de alerta](#v10-alerting-manage-rulestate-state)
+ [Estado da instância de alerta](#v10-alerting-manage-rulestate-instance)
+ [Integridade da regra de alerta](#v10-alerting-manage-rulestate-health)
Embora relacionado, cada componente transmite informações sutilmente diferentes.
**Para visualizar o estado e a integridade das regras de alerta**
1. No console do Grafana, no menu Grafana, escolha **Alertas**.
1. Escolha **Regras de alerta** para visualizar a lista de alertas existentes.
1. Escolha uma regra de alerta para visualizar seu estado e integridade.
## 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, sã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 é nem pending nem firing. Tudo está funcionando conforme o esperado. |
| 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. |
| Nenhum dado | Nenhum dado foi recebido para a janela de tempo configurada. |
| Geração de alertas | Ocorreu um erro 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 status de integridade a seguir.
| Estado | Description |
| --- | --- |
| Ok | Nenhum erro ao avaliar a regra de alerta. |
| Erro | Ocorreu um erro ao avaliar a regra de alerta. |
| NoData | A ausência de dados em pelo menos uma série temporal retornada durante a avaliação de uma regra. |
| \$1status\$1, KeepLast | A regra recebeu outro status, mas foi configurada para manter o último estado da regra de alerta. |
## Alertas especiais para NoData erros
Quando a avaliação de uma regra de alerta produz o estado `NoData` ou `Error`, o Grafana Alerting gera instâncias de alerta com os rótulos adicionais a seguir.
| Rótulo | Description |
| --- | --- |
| alertname | DatasourceNoData ou DatasourceError, dependendo do estado. |
| datasource\$1uid | O UID da fonte de dados que causou o estado. |
**nota**
Você precisará definir o tratamento de erros e ausência de dados como `NoData` e `Error` na regra de alerta, conforme descrito no tópico [Configurar as regras de alertas gerenciados pelo Grafana](v10-alerting-configure-grafanamanaged.md), para gerar os rótulos adicionais.
Você pode lidar com esses alertas da mesma forma como os alertas regulares, incluindo a adição de silêncios, roteamento para um ponto de contato etc.
# Visualizar e filtrar por grupos 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).
Os grupos de alertas mostram alertas agrupados de uma instância do Alertmanager. Por padrão, as regras de alerta são agrupadas pelas chaves de rótulo da política padrão nas políticas de notificação. O agrupamento de regras de alerta comuns em um único grupo de alerta evita que regras de alerta duplicadas sejam disparadas.
Você pode visualizar grupos de alertas e também filtrar as regras de alerta que correspondam a critérios específicos.
**Para visualizar grupos de alertas**
1. No console do Grafana, no menu Grafana, escolha **Alertas**.
1. Escolha **Grupos** para visualizar os grupos existentes.
1. No menu suspenso **Alertmanager**, selecione um Alertmanager externo como sua fonte de dados.
1. No menu suspenso **Personalizar agrupar por**, selecione uma combinação de rótulos para visualizar um agrupamento diferente do padrão. Isso é útil para depurar e verificar o agrupamento de políticas de notificação.
Se um alerta não contiver rótulos especificados no agrupamento da política raiz ou no agrupamento personalizado, então o alerta será adicionado a um grupo universal com o cabeçalho de `No grouping`.
Você pode filtrar alertas por rótulo ou estado dos alertas.
**Para filtrar por rótulo**
+ Em **Pesquisar**, insira um rótulo existente para visualizar os alertas que correspondam ao rótulo.
Por exemplo, .`environment=production,region=~US|EU,severity!=warning`
**Para filtrar por estado**
+ Em **Estados**, selecione entre os estados Ativo, Suprimido ou Não processado para visualizar alertas que correspondam ao estado selecionado. Todos os outros alertas estão ocultos.
# Visualizar erros 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).
Visualize os erros de notificação e saiba por que eles não foram enviados ou não foram recebidos.
**nota**
Esse recurso é compatível apenas com o Grafana Alertmanager.
**Para visualizar os erros de notificação**
1. No menu à esquerda, escolha **Alertas** e depois **Pontos de contato**.
Se algum ponto de contato estiver com falha, uma mensagem no canto direito do espaço de trabalho informará que há erros e a quantidade de erros.
1. Selecione um ponto de contato para visualizar os detalhes dos erros dele.
Os detalhes do erro são exibidos se você passar o mouse sobre o ícone de erro.
Se um ponto de contato tiver mais de uma integração, você verá todos os erros de cada uma das integrações listadas.
1. Na coluna Integridade, verifique o status da notificação.
Pode estar OK, Nenhuma tentativa ou Erro.