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 9
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
O Grafana Alerting fornece alertas robustos e acionáveis que ajudam você a saber mais sobre problemas nos sistemas momentos após a ocorrência, minimizando a interrupção dos serviços.
O Amazon Managed Grafana inclui acesso a um sistema de alertas atualizado, o *Grafana Alerting*, que centraliza as informações dos alertas em uma única visualização pesquisável. Ele inclui os seguintes recursos:
+ Crie e gerencie alertas do Grafana em uma visão centralizada.
+ Crie e gerencie alertas gerenciados pelo Cortex e Loki por meio de uma única interface.
+ Veja informações de alertas do Prometheus, do Amazon Managed Service for Prometheus e de outras fontes de dados compatíveis com o Alertmanager.
Ao criar o espaço de trabalho do Amazon Managed Grafana, você tem a opção de usar o Grafana Alerting ou os [Alertas clássicos do dashboard](old-alerts-overview.md). Esta seção aborda o Grafana Alerting.
**nota**
Se você criou o espaço de trabalho com os alertas Classic ativados e deseja mudar para o Grafana Alerting, você pode [alternar entre os dois sistemas de alertas](v9-alerting-use-grafana-alerts.md).
## Limitações do Grafana Alerting
+ O sistema do Grafana Alerting pode recuperar regras de todas as fontes de dados disponíveis do Amazon Managed Service for Prometheus, Prometheus, Loki e Alertmanager. Talvez não seja possível buscar regras de outras fontes de dados compatíveis.
+ As regras de alerta definidas no Grafana, em vez de no Prometheus, enviam várias notificações ao ponto de contato. Se você estiver usando alertas nativos do Grafana, recomendamos que continue usando os alertas clássicos do dashboard e não habilite o novo recurso de alerta do Grafana. Se você quiser visualizar os alertas definidos na fonte de dados Prometheus, recomendamos que você habilite o Grafana Alerting, que envia somente uma única notificação para alertas criados no Alertmanager do Prometheus.
**nota**
Essa limitação não é mais uma limitação nos espaços de trabalho do Amazon Managed Grafana compatíveis com o Grafana v10.4 e versões posteriores.
**Topics**
+ [Limitações do Grafana Alerting](#v9-alert-limitations)
+ [Visão geral do](v9-alerting-overview.md)
+ [Explorar alertas](v9-alerting-explore.md)
+ [Configurar alertas](v9-alerting-setup.md)
+ [Migrar alertas clássicos do dashboard para o Grafana Alerting](v9-alerting-use-grafana-alerts.md)
+ [Gerenciar as regras de alertas](v9-alerting-managerules.md)
+ [Gerenciar as notificações de alerta](v9-alerting-managenotifications.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 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
A seção abaixo fornece uma visão geral de como o Grafana Alerting funciona e apresenta alguns dos principais conceitos que funcionam juntos e formam o núcleo de seu mecanismo de alerta flexível e avançado.
1. **Fonte de dados**
Conecta-se aos dados a serem usados por meio de alertas. Esses dados geralmente são dados de séries temporais, para alertas, e mostram os detalhes de um sistema a ser monitorado e analisado. Para obter mais informações, consulte [fontes de dados](AMG-data-sources-builtin.md).
1. **Regras de alerta**
Defina critérios de avaliação que determinem se uma instância de alerta será disparada. Uma regra de alerta consiste em uma ou mais consultas e expressões para extrair dados da fonte de dados, uma condição que descreve o que constitui a necessidade de um alerta, a frequência da avaliação e, opcionalmente, a duração durante a qual a condição deve ser atendida para que um alerta seja disparado.
Os alertas gerenciados pelo Grafana são compatíveis com alertas multidimensionais, o que significa que cada regra de alerta pode criar várias instâncias de alerta. Isso será excepcionalmente eficaz se você estiver observando várias séries em uma única expressão.
1. **Rótulos**
Corresponda uma regra de alerta e suas instâncias às políticas e silêncios de notificação. Eles também podem ser usados para agrupar os alertas por severidade.
1. **Políticas de notificação**
Defina onde, quando e como os alertas serão roteados para notificar sua equipe quando o alerta for disparado. Cada política de notificação especifica um conjunto de matchers para indicar por quais alertas elas são responsáveis. Uma política de notificação tem um ponto de contato atribuído a ela que consiste em um ou mais notificadores.
1. **Pontos de contato**
Defina como os contatos são notificados quando um alerta é disparado. Oferecemos suporte a uma infinidade de ChatOps ferramentas para garantir que os alertas cheguem à sua equipe.
## Recursos
**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 individuais de alerta por regra de alerta, conhecidas como alertas multidimensionais, oferecendo a capacidade e a flexibilidade de obter visibilidade de todo o sistema com apenas um único alerta.
**Alertas de roteamento**
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.
**Alertas de silenciamento**
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**
Com os tempos de desativação de áudio, você pode especificar um intervalo de tempo em que não deseja que novas notificações sejam geradas ou enviadas. Você também pode congelar notificações de alerta por períodos recorrentes, como durante um período de manutenção.
# Explorar alertas
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Caso esteja iniciando ou expandindo a implementação do Grafana Alerting, saiba mais sobre os principais conceitos e os recursos disponíveis que ajudam você a criar, gerenciar e agir de acordo com os alertas e a melhorar a capacidade de sua equipe de resolver problemas rapidamente.
Em primeiro lugar, vamos analisar os diferentes tipos de regras de alerta que o Grafana Alerting oferece.
## Tipos de regras de alerta
**Regras gerenciadas pelo Grafana**
As regras gerenciadas pelo Grafana são o tipo de regra de alerta mais flexível. Elas permitem que você crie alertas que podem agir com base nos dados de qualquer uma das nossas fontes de dados compatíveis. Além de oferecer suporte a várias fontes de dados, você também pode adicionar expressões para transformar os dados e definir condições de alerta. Este é o único tipo de regra que permite alertas de várias fontes de dados em uma única definição de regra.
**Regras do Mimir e Loki**
Para criar alertas do Mimir ou Loki, você deve ter uma fonte de dados Prometheus compatível. Você pode verificar se a fonte de dados é compatível com a criação de regras via Grafana testando a fonte de dados e observando se a API Ruler é compatível.
**Regras de gravação**
As regras de gravação só estão disponíveis para fontes de dados Prometheus ou Loki compatíveis. As regras de gravação permitem que você pré-compute expressões frequentemente necessárias ou computacionalmente caras e salve seus resultados como um novo conjunto de séries temporais. Isso será útil se você quiser executar alertas em dados agregados ou se tiver dashboards que consultam expressões computacionalmente caras repetidamente.
## Recursos e conceitos-chave
A tabela a seguir inclui uma lista dos principais conceitos e recursos, e suas definições, projetados para ajudar você a aproveitar ao máximo o Grafana Alerting.
| Principal conceito ou recurso | Definição |
| --- | --- |
| Fontes de dados para alertas | Selecione as fontes de dados das quais você deseja consultar e visualizar métricas, logs e rastreamentos. |
| Provisionar para alertas | Gerencie os recursos de alertas e provisione-os no sistema do Grafana usando o provisionamento de arquivos ou o Terraform. |
| Alertmanager | Gerencia o roteamento e o agrupamento de instâncias de alertas. |
| Regra de alerta | Um conjunto de critérios de avaliação para quando uma regra de alerta deve ser acionada. Uma regra de alerta consiste em uma ou mais consultas e expressões, uma condição, a frequência da avaliação e a duração em que a condição é atendida. Uma regra de alerta pode produzir várias instâncias de alertas. |
| Instância de alerta | Uma instância de alerta é uma instância de uma regra de alerta. Uma regra de alerta unidimensional tem uma instância de alerta. Uma regra de alerta multidimensional tem uma ou mais instâncias de alertas. Uma única regra de alerta que corresponda a vários resultados, como CPU contra 10 VMs, é contabilizada como várias (neste caso, 10) instâncias de alerta. Esse número pode variar com o tempo. Por exemplo, uma regra de alerta que monitora o uso da CPU para todos VMs em um sistema tem mais instâncias de alerta à medida que VMs são adicionadas. Para obter mais informações sobre cotas de instâncias de alertas, consulte [Cota alcançada de erros](v9-alerting-managerules-grafana.md#v9-alerting-rule-quota-reached). |
| Grupo de alertas | O Alertmanager agrupa instâncias de alertas por padrão usando os rótulos da política de notificação raiz. Isso controla a desduplicação e os grupos de instâncias de alerta, que são enviadas aos pontos de contato. |
| Ponto de contato | Defina como seus contatos são notificados quando uma regra de alerta é acionada. |
| Modelos de mensagens | Crie modelos personalizados reutilizáveis e use-os em pontos de contato. |
| Política de notificação | Conjunto de regras para onde, quando e como os alertas são agrupados e roteados para os pontos de contato. |
| Rótulos e matchers de rótulos | Os rótulos identificam de forma exclusiva as regras de alertas. Eles vinculam as regras de alertas a silêncios e políticas de notificação, determinando qual política deve lidar com eles e quais regras de alerta devem ser silenciadas. |
| Silêncios | Interrompa as notificações de uma ou mais instâncias de alerta. A diferença entre um tempo de desativação de áudio e de silêncio é que um silêncio dura apenas por uma janela de tempo especificada, enquanto um tempo de desativação de áudio é recorrente em uma programação. Usa matcher de rótulos para silenciar instâncias de alertas. |
| Tempos de desativação de áudio | Especifique um intervalo de tempo em que você não deseja que novas notificações sejam geradas ou enviadas. Você também pode congelar notificações de alerta por períodos recorrentes, como durante um período de manutenção. Deve estar vinculado a uma política de notificação existente. |
# Fontes de dados
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Existem várias [fontes de dados](AMG-data-sources-builtin.md) compatíveis com o Grafana Alerting. Cada fonte de dados é compatível com um plug-in. Você pode usar uma das fontes de dados integradas listadas abaixo.
Estas são as fontes de dados compatíveis com o Amazon Managed Grafana.
+ [Conectar-se a uma fonte de dados Alertmanager](data-source-alertmanager.md)
+ [Conecte-se a uma fonte de CloudWatch dados da Amazon](using-amazon-cloudwatch-in-AMG.md)
+ [Conecte-se a uma fonte OpenSearch de dados do Amazon Service](using-Amazon-OpenSearch-in-AMG.md)
+ [Conecte-se a uma fonte AWS IoT SiteWise de dados](using-iotsitewise-in-AMG.md)
+ [Conecte-se a uma fonte AWS IoT TwinMaker de dados](AMG-iot-twinmaker.md)
+ [Conectar-se ao Amazon Managed Service for Prometheus e a fontes de dados de código aberto do Prometheus.](prometheus-data-source.md)
+ [Conectar-se a uma fonte de dados Amazon Timestream](timestream-datasource.md)
+ [Conectar-se a uma fonte de dados Amazon Athena](AWS-Athena.md)
+ [Conectar-se a uma fonte de dados do Amazon Redshift](AWS-Redshift.md)
+ [Conecte-se a uma fonte AWS X-Ray de dados](x-ray-data-source.md)
+ [Conectar-se a uma fonte de dados Azure Monitor](using-azure-monitor-in-AMG.md)
+ [Conectar-se a uma fonte de dados do Google Cloud Monitoring](using-google-cloud-monitoring-in-grafana.md)
+ [Conectar-se a uma fonte de dados Graphite](using-graphite-in-AMG.md)
+ [Conectar-se a uma fonte de dados InfluxDB](using-influxdb-in-AMG.md)
+ [Conectar-se a uma fonte de dados Loki](using-loki-in-AMG.md)
+ [Conectar-se a uma fonte de dados do Microsoft SQL Server](using-microsoft-sql-server-in-AMG.md)
+ [Conectar-se a uma fonte de dados MySQL](using-mysql-in-AMG.md)
+ [Conectar-se a uma fonte de dados OpenTSDB](using-opentsdb-in-AMG.md)
+ [Conectar-se a uma fonte de dados PostgreSQL](using-postgresql-in-AMG.md)
+ [Conectar-se a uma fonte de dados Jaeger](jaeger-data-source.md)
+ [Conectar-se a uma fonte de dados Zipkin](zipkin-data-source.md)
+ [Conectar-se a uma fonte de dados Tempo](tempo-data-source.md)
+ [Configurar uma fonte de TestData dados para testes](testdata-data-source.md)
# Sobre as regras de alerta
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Uma regra de alerta é um conjunto de critérios de avaliação que determina se uma instância de alerta será disparada. A regra consiste em uma ou mais consultas e expressões, uma condição, a frequência da avaliação e, opcionalmente, o período durante o qual a condição é atendida.
Enquanto consultas e expressões selecionam o conjunto de dados a ser avaliado, uma condição define o limite que um alerta deve atingir ou exceder para criar um alerta.
Um intervalo especifica com que frequência uma regra de alerta é avaliada. A duração, quando configurada, indica por quanto tempo uma condição deve ser atendida. As regras de alerta também podem definir o comportamento do alerta na ausência de dados.
**Topics**
+ [Tipos de regras de alerta](v9-alerting-explore-rules-types.md)
+ [Instâncias de alerta](v9-alerting-rules-instances.md)
+ [Namespaces e grupos](v9-alerting-rules-grouping.md)
+ [Modelos de notificação](v9-alerting-rules-notification-templates.md)
# Tipos de regras de alerta
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
O Grafana é compatível com vários tipos de regras de alerta. As seções a seguir explicarão suas vantagens e desvantagens e ajudarão você a escolher o tipo de alerta certo para seu caso de uso.
Regras gerenciadas pelo Grafana
As regras gerenciadas pelo Grafana são o tipo de regra de alerta mais flexível. Elas permitem que você crie alertas que podem atuar nos dados de qualquer uma das fontes de dados existentes.
Além de oferecer suporte a qualquer fonte de dados, você pode adicionar [expressões](v9-panels-query-xform-expressions.md) para transformar os dados e expressar condições de alerta.
Regras do Mimir, Loki e Cortex
Para criar alertas do Mimir, Loki ou Cortex, você deve ter uma fonte de dados Prometheus compatível. Você pode verificar se a fonte de dados é compatível testando a fonte de dados e verificando os detalhes se a API Ruler é compatível.
Regras de gravação
As regras de gravação só estão disponíveis para fontes de dados Prometheus compatíveis, como Mimir, Loki e Cortex.
Uma regra de gravação permite que você salve o resultado de uma expressão em um novo conjunto de séries temporais. Isso será útil se você quiser executar alertas em dados agregados ou se tiver dashboards que consultam a mesma expressão repetidamente.
Leia mais sobre as [regras de gravação](https://prometheus.io/docs/prometheus/latest/configuration/recording_rules/) no Prometheus.
# Instâncias de alerta
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Os alertas gerenciados pelo Grafana são compatíveis com alertas multidimensionais. Cada regra de alerta pode criar várias instâncias de alerta. Isso será eficaz se você estiver observando várias séries em uma única expressão.
Considere a seguinte expressão PromQL:
```
sum by(cpu) (
rate(node_cpu_seconds_total{mode!="idle"}[1m])
)
```
Uma regra usando essa expressão criará tantas instâncias de alerta quanto a quantidade CPUs observada durante a avaliação, permitindo que uma única regra relate o status de cada CPU.
# Namespaces e grupos
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Os alertas podem ser organizados usando pastas para regras gerenciadas pelo Grafana e namespaces para regras e nomes de grupos do Mimir, Loki ou Prometheus.
**Namespaces**
Ao criar regras gerenciadas pelo Grafana, a pasta pode ser usada para realizar o controle de acesso e conceder ou negar acesso a todas as regras em uma pasta específica.
**Groups (Grupos)**
Todas as regras em um grupo são avaliadas no mesmo **intervalo**.
As regras de alerta e as regras de gravação em um grupo sempre serão avaliadas **sequencialmente**, o que significa que nenhuma regra será avaliada ao mesmo tempo e em ordem de aparição.
**dica**
Se você quiser que as regras sejam avaliadas simultaneamente e com intervalos diferentes, considere armazená-las em grupos diferentes.
# Modelos de notificação
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
As notificações enviadas por meio de pontos de contato são criadas usando modelos de notificação. Os modelos padrão do Grafana são baseados no [sistema de modelos do Go](https://golang.org/pkg/text/template), em que alguns campos são avaliados como texto, enquanto outros são avaliados como HTML (o que pode afetar o escape).
O modelo padrão [default\$1template.go](https://github.com/grafana/alerting/blob/main/templates/default_template.go) é uma referência útil para modelos personalizados.
Como a maioria dos campos de ponto de contato pode ser modelada, você pode criar modelos personalizados reutilizáveis e usá-los em vários pontos de contato. Para saber mais sobre notificações personalizadas usando modelos, consulte[Personalizar notificações](v9-alerting-notifications.md).
**Modelos aninhados**
Você pode incorporar modelos em outros modelos.
Por exemplo, você pode definir um fragmento de modelo usando a palavra-chave `define`.
```
{{ define "mytemplate" }}
{{ len .Alerts.Firing }} firing. {{ len .Alerts.Resolved }} resolved.
{{ end }}
```
Você pode então incorporar modelos personalizados nesse fragmento usando a palavra-chave `template`. Por exemplo:
```
Alert summary:
{{ template "mytemplate" . }}
```
Você pode usar qualquer uma das opções de modelo incorporado a seguir para incorporar modelos personalizados.
| Nome | Observações |
| --- | --- |
| `default.title` | Exibe informações de status de alto nível. |
| `default.message` | Fornece um resumo formatado dos alertas disparados e resolvidos. |
| `teams.default.message` | Semelhante a `default.messsage`, formatado para o Microsoft Teams. |
**HTML em modelos de notificação**
O HTML nos modelos de notificação de alerta é de escape. Não oferecemos suporte à renderização de HTML na notificação resultante.
Alguns notificadores são compatíveis com métodos alternativos para alterar o aspecto visual da notificação resultante. Por exemplo, o Grafana instala o modelo básico para alertar e-mails para. `/public/emails/ng_alert_notification.html`. Você pode editar esse arquivo para alterar o aspecto visual de todos os e-mails de alerta.
# Alertas sobre dados numéricos
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Este tópico descreve como o Grafana lida com alertas em dados numéricos em vez de dados de séries temporais.
Entre determinadas fontes de dados, os dados numéricos que não são séries temporais podem ser notificados diretamente ou passados para as Expressões do lado do servidor (SSE). Isso permite mais processamento e eficiência resultante na fonte de dados, além de simplificar as regras de alertas. Ao alertar sobre dados numéricos em vez de dados de séries temporais, não há necessidade de reduzir cada série temporal rotulada em um único número. Em vez disso, os números rotulados são retornados para o Grafana.
**Dados tabulares**
Este recurso é compatível com fontes de dados de backend que consultam dados tabulares:
+ Fontes de dados SQL, como MySQL, Postgres, MSSQL e Oracle.
+ Os serviços baseados no Azure Kusto: Azure Monitor (Logs), Azure Monitor (Azure Resource Graph) e Azure Data Explorer.
Uma consulta com alertas gerenciados pelo Grafana ou SSE será considerada numérica com essas fontes de dados, se:
+ A opção “Formatar como” estiver definida como “Tabela” na consulta da fonte de dados.
+ A resposta da tabela retornada ao Grafana da consulta incluir apenas uma coluna numérica (por exemplo, int, double ou float) e, opcionalmente, colunas de string adicionais.
Se houver colunas de string, essas colunas se tornarão rótulos. O nome da coluna torna-se o nome do rótulo, e o valor de cada linha torna-se o valor do rótulo correspondente. Se várias linhas forem retornadas, então cada linha deverá ter seus rótulos identificados de forma exclusiva.
**Exemplo**
Para uma tabela MySQL chamada “”: DiskSpace
| Hora | Host | Disk | PercentFree |
| --- | --- | --- | --- |
| 7 de junho de 2021 | web1 | /etc | 3 |
| 7 de junho de 2021 | web2 | /var | 4 |
| 7 de junho de 2021 | web3 | /var | 8 |
| ... | ... | ... | ... |
Você pode consultar a filtragem de dados a tempo, mas sem retornar a série temporal ao Grafana. Por exemplo, um alerta que será acionado por host, disco quando houver menos de 5% de espaço livre:
```
SELECT Host , Disk , CASE WHEN PercentFree < 5.0 THEN PercentFree ELSE 0 END FROM (
SELECT
Host,
Disk,
Avg(PercentFree)
FROM DiskSpace
Group By
Host,
Disk
Where __timeFilter(Time)
```
Esta consulta retornará a seguinte resposta de tabela ao Grafana:
| Host | Disk | PercentFree |
| --- | --- | --- |
| web1 | /etc | 3 |
| web2 | /var | 4 |
| web3 | /var | 0 |
Quando esta consulta é usada como **condição** em uma regra de alerta, o que não for zero será um alerta. Como resultado, três instâncias de alerta são produzidas:
| Rótulos | Status |
| --- | --- |
| \$1Host=web1,disk=/etc\$1 | Geração de alertas |
| \$1Host=web2,disk=/var\$1 | Geração de alertas |
| \$1Host=web3,disk=/var\$1 | Normal |
# Rótulos e anotações
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Rótulos e anotações contêm informações sobre um alerta. Tanto os rótulos quanto as anotações têm a mesma estrutura: um conjunto de valores nomeados; no entanto, seus usos pretendidos são diferentes. Um exemplo de rótulo, ou anotação equivalente, pode ser `alertname="test"`.
A principal diferença entre um rótulo e uma anotação é que os rótulos são usados para diferenciar um alerta de todos os outros alertas, enquanto as anotações são usadas para adicionar informações adicionais a um alerta existente.
Por exemplo, considere dois alertas de CPU de alta performance: um para `server1` e outro para `server2`. Neste exemplo, podemos ter um rótulo denominado `server`, em que o primeiro alerta tem o rótulo `server="server1"` e o segundo alerta tem o rótulo `server="server2"`. No entanto, talvez também queiramos adicionar uma descrição a cada alerta, como `"The CPU usage for server1 is above 75%."`, em que `server1` e `75%` são substituídos pelo nome e pelo uso da CPU do servidor (consulte a documentação sobre [Modelos de rótulos e anotações](v9-alerting-explore-labels-templating.md) para saber como fazer isso). Esse tipo de descrição seria mais adequado como uma anotação.
## Rótulos
Os rótulos contêm informações que identificam um alerta. Um exemplo de rótulo pode ser `server=server1`. Cada alerta pode ter mais de um rótulo, e o conjunto completo de rótulos de um alerta é denominado seu conjunto de rótulos. É esse conjunto de rótulos que identifica o alerta.
Por exemplo, um alerta pode ter o rótulo definido como `{alertname="High CPU usage",server="server1"}`, enquanto outro alerta pode ter o rótulo definido como `{alertname="High CPU usage",server="server2"}`. Eles são dois alertas separados porque, embora seus rótulos de `alertname` sejam iguais, os rótulos de `server` são diferentes.
O rótulo definido para um alerta é uma combinação de rótulos da fonte de dados, rótulos personalizados da regra de alerta e vários rótulos reservados, como `alertname`.
**Rótulos personalizados**
Os rótulos personalizados são rótulos adicionais da regra de alerta. Assim como as anotações, os rótulos personalizados devem ter um nome, e seu valor pode conter uma combinação de texto e código de modelo que é avaliada quando um alerta é disparado. A documentação sobre como criar modelos de rótulos personalizados pode ser encontrada [aqui](v9-alerting-explore-labels-templating.md).
Ao usar rótulos personalizados com modelos, é importante garantir que o valor do rótulo não mude entre avaliações consecutivas da regra de alerta, pois isso acabará criando um grande número de diferentes alertas. No entanto, não há problema em o modelo produzir valores de rótulo diferentes para diversos alertas. Por exemplo, não coloque o valor da consulta em um rótulo personalizado, pois isso acabará criando um novo conjunto de alertas sempre que o valor for alterado. Em vez disso, use anotações.
Também é importante garantir que o rótulo definido para um alerta não tenha dois ou mais rótulos com o mesmo nome. Se um rótulo personalizado tiver o mesmo nome de um rótulo da fonte de dados, ele substituirá esse rótulo. No entanto, se um rótulo personalizado tiver o mesmo nome de um rótulo reservado, o rótulo personalizado será omitido do alerta.
## Anotações
As anotações são pares nomeados que adicionam informações extras aos alertas existentes. Há várias anotações sugeridas no Grafana, como `description`, `summary`, `runbook_url`, `dashboardUId` e `panelId`. Assim como os rótulos personalizados, as anotações devem ter um nome, e seu valor pode conter uma combinação de texto e código de modelo que é avaliada quando um alerta é disparado. Se uma anotação contiver código de modelo, o modelo será avaliado uma vez quando o alerta for disparado. Ele não será reavaliado, mesmo quando o alerta tiver sido resolvido. A documentação sobre como criar modelos de anotações pode ser encontrada [aqui](v9-alerting-explore-labels-templating.md).
# Como funciona a correspondência de rótulos
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Use rótulos e matchers de rótulos para vincular as regras de alerta aos silêncios e às políticas de notificação. Isso permite uma maneira muito flexível de gerenciar as instâncias de alerta, especificar qual política deve lidar com elas e quais alertas silenciar.
Um matcher de rótulo consiste em três partes distintas: o **rótulo**, o **valor** e o **operador**.
+ O campo **Rótulo** é o nome do rótulo correspondente. Ele deve ser exatamente igual ao nome do rótulo.
+ O campo **Valor** corresponde ao valor correspondente para o nome do **Rótulo** especificado. A correspondência depende do valor do **Operador**.
+ O campo **Operador** é o operador que corresponde ao valor do rótulo. Os operadores disponíveis são:
| Operador | Description |
| --- | --- |
| `=` | Selecione rótulos que sejam exatamente iguais ao valor. |
| `!=` | Selecione rótulos que não sejam iguais ao valor. |
| `=~` | Selecione rótulos que correspondam ao regex do valor. |
| `!~` | Selecione rótulos que não correspondam ao regex do valor. |
Se você estiver usando vários matchers de rótulos, eles serão combinados usando o operador lógico AND. Isso significa que todos os matchers devem corresponder a fim de vincular uma regra a uma política.
**Exemplo de cenário**
Se você definir o seguinte conjunto de rótulos para seu alerta:
```
{ foo=bar, baz=qux, id=12 }
```
então:
+ Um matcher de rótulo definido como `foo=bar` corresponde a essa regra de alerta.
+ Um matcher de rótulo definido como `foo!=bar` *não* corresponde a essa regra de alerta.
+ Um matcher de rótulo definido como `id=~[0-9]+` corresponde a essa regra de alerta.
+ Um matcher de rótulo definido como `baz!~[0-9]+` corresponde a essa regra de alerta.
+ Dois marcadores de rótulos definidos como `foo=bar` e `id=~[0-9]+` correspondem a essa regra de alerta.
# Rótulos no Grafana Alerting
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Este tópico explica por que os rótulos são um componente fundamental dos alertas.
+ O conjunto completo de rótulos para um alerta é o que identifica exclusivamente um alerta nos alertas do Grafana.
+ O Alertmanager usa rótulos para corresponder alertas a silêncios e grupos de alertas nas políticas de notificação.
+ A interface de usuário de alertas mostra rótulos para cada instância de alerta gerada durante a avaliação dessa regra.
+ Os pontos de contato podem acessar rótulos para gerar notificações dinamicamente que contêm informações específicas do alerta que está resultando em uma notificação.
+ Você pode adicionar rótulos a uma [regra de alerta](v9-alerting-managerules.md). Os rótulos são configuráveis manualmente, usam funções de modelo e podem fazer referência a outros rótulos. Os rótulos adicionados a uma regra de alerta têm precedência no caso de um conflito entre os rótulos (exceto no caso dos rótulos reservados do Grafana; veja abaixo para obter mais informações).
**Compatibilidade com um Alertmanager externo**
O Alertmanager integrado do Grafana é compatível com chaves e valores de rótulos Unicode. Se você estiver usando um Prometheus Alertmanager externo, as chaves de rótulos deverão ser compatíveis com o [modelo de dados](https://prometheus.io/docs/concepts/data_model/#metric-names-and-labels). Isso significa que as chaves de rótulos deverão conter apenas **letras ASCII**, **números** e **sublinhados** e corresponder ao regex `[a-zA-Z_][a-zA-Z0-9_]*`. Quaisquer caracteres inválidos serão removidos ou substituídos pelo mecanismo do Grafana Alerting antes de serem enviados ao Alertmanager externo de acordo com as seguintes regras:
+ `Whitespace` será removido.
+ `ASCII characters` serão substituídos por `_`.
+ `All other characters` serão substituídos por sua representação hexadecimal em minúsculas. Se este for o primeiro caractere, ele será prefixado com `_`.
**nota**
Se várias chaves de rótulos forem limpas com relação ao mesmo valor, as duplicatas terão um hash curto do rótulo original anexado como sufixo.
**Rótulos reservados do Grafana**
**nota**
Os rótulos prefixados com `grafana_` são reservados pelo Grafana para uso especial. Se um rótulo configurado manualmente for adicionado começando com `grafana_`, ele poderá ser substituído em caso de conflito.
Os rótulos reservados do Grafana podem ser usados da mesma forma que os rótulos configurados manualmente. A lista atual de rótulos reservados disponíveis é:
| Rótulo | Description |
| --- | --- |
| grafana\$1folder | Título da pasta que contém o alerta. |
# Modelos de rótulos e anotações
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
No Grafana, você cria modelos de rótulos e anotações da mesma forma como no Prometheus. Se você já usou o Prometheus antes, então deve estar familiarizado com as variáveis `$labels` e `$value`, que contêm os rótulos e o valor do alerta. Você pode usar as mesmas variáveis no Grafana, mesmo que o alerta não use uma fonte de dados Prometheus. Se você nunca usou o Prometheus antes, não se preocupe, pois cada uma dessas variáveis e como modelá-las serão explicadas conforme você avançar nesta página.
## Linguagem de modelos do Go
Os modelos para rótulos e anotações são escritos na linguagem de modelos do Go, [texto/modelo](https://pkg.go.dev/text/template).
**Tags de abertura e fechamento**
Em texto/modelo, os modelos começam com `{{` e terminam com `}}`, independentemente de o modelo imprimir uma variável ou executar estruturas de controle, como instruções if. Isso é diferente de outras linguagens de modelos, como Jinja, em que a impressão de uma variável usa `{{` e `}}` e as estruturas de controle usam `{%` e `%}`.
**Print (Imprimir)**
Para imprimir o valor de algo, use `{{` e `}}`. Você pode imprimir o resultado de uma função ou valor de uma variável. Por exemplo, para imprimir a variável `$labels`, você deve escrever o seguinte:
```
{{ $labels }}
```
**Iterar em rótulos**
Para iterar em cada rótulo em `$labels`, você pode usar um `range`. Aqui, `$k` refere-se ao nome e `$v` refere-se ao valor do rótulo atual. Por exemplo, se a consulta retornasse um rótulo `instance=test`, então `$k` seria `instance` e `$v`seria `test`.
```
{{ range $k, $v := $labels }}
{{ $k }}={{ $v }}
{{ end }}
```
## Os rótulos, valores e variáveis de valores
**A variável de rótulos**
A variável `$labels` contém os rótulos da consulta. Por exemplo, uma consulta que verifica se uma instância está inativa pode retornar um rótulo de instância com o nome da instância que está inativa. Por exemplo, suponha que você tenha uma regra de alerta que é disparada quando uma das instâncias fica inativa por mais de cinco minutos. Você deseja adicionar um resumo ao alerta que informa qual instância está inativa. Com a variável `$labels`, você pode criar um resumo que imprima o rótulo da instância no resumo:
```
Instance {{ $labels.instance }} has been down for more than 5 minutes
```
**Rótulos com pontos**
Se o rótulo que você deseja imprimir contiver um ponto (ponto final) em seu nome, usar o mesmo ponto no modelo não funcionará:
```
Instance {{ $labels.instance.name }} has been down for more than 5 minutes
```
Isso ocorre porque o modelo está tentando usar um campo não existente denominado `name` em `$labels.instance`. Em vez disso, você deve usar a função `index`, que imprime o rótulo `instance.name` na variável `$labels`:
```
Instance {{ index $labels "instance.name" }} has been down for more than 5 minutes
```
**O valor da variável**
A variável `$value` funciona de forma diferente do Prometheus. No `$value` do Prometheus, há um número de ponto flutuante que contém o valor da expressão, mas no Grafana é uma string que contém os rótulos e valores de todas as expressões de limite, de redução, matemáticas e de condições clássicas dessa regra de alerta. Ela não contém os resultados das consultas, pois podem retornar de 10 a 10 mil linhas ou métricas.
Se você fosse usar a variável `$value` no resumo de um alerta:
```
{{ $labels.service }} has over 5% of responses with 5xx errors: {{ $value }})
```
O resumo pode ficar como abaixo:
```
api has an over 5% of responses with 5xx errors: [ var='B' labels={service=api} value=6.789 ]
```
Aqui, `var='B'` refere-se à expressão com o RefID B. No Grafana, todas as consultas e expressões são identificadas por um RefID que identifica cada consulta e expressão em uma regra de alerta. Da mesma forma, `labels={service=api}` refere-se aos rótulos e `value=6.789` refere-se ao valor.
Você deve ter observado que não há nenhum RefID A. Isso ocorre porque, na maioria das regras de alerta, o RefID A refere-se a uma consulta, e como as consultas podem retornar muitas linhas ou séries temporais, elas não estão incluídas em `$value`.
**A variável de valores**
Se a variável `$value` contiver mais informações do que você precisa, é possível imprimir os rótulos e o valor de expressões individuais usando `$values`. Ao contrário de `$value`, a variável `$values` é uma tabela de objetos que contêm os rótulos e valores de ponto flutuante de cada expressão, indexados por seu RefID.
Se você imprimir o valor da expressão com o RefID `B` no resumo do alerta:
```
{{ $labels.service }} has over 5% of responses with 5xx errors: {{ $values.B }}%
```
O resumo conterá apenas o valor:
```
api has an over 5% of responses with 5xx errors: 6.789%
```
No entanto, enquanto `{{ $values.B }}` imprime o número 6.789, na verdade é uma string, pois você estar imprimindo o objeto que contém os rótulos e o valor do RefID B, não o valor de ponto flutuante de B. Para usar o valor de ponto flutuante do RefID B, você deve usar o campo `Value` de `$values.B`. Se você fosse humanizar o valor do ponto flutuante no resumo de um alerta:
```
{{ $labels.service }} has over 5% of responses with 5xx errors: {{ humanize $values.B.Value }}%
```
**Nenhum dado, erros de runtime e tempos limite**
Se a consulta na regra de alerta não retornar nenhum dado ou falhar devido a um erro na fonte de dados ou ao tempo limite, todas as expressões de limite, redução e matemáticas que usem essa consulta também não retornarão nenhum dado ou retornarão um erro. Quando isso acontecer, essa expressão estará ausente de `$values`. É uma boa prática verificar se um RefID está presente antes de usá-lo, caso contrário, o modelo será pausado se sua consulta não retornar nenhum dado ou retornar um erro. É possível fazer isso usando uma instrução if:
```
{{ if $values.B }}{{ $labels.service }} has over 5% of responses with 5xx errors: {{ humanizePercentage $values.B.Value }}{{ end }}
```
## Condições clássicas
Se a regra usar condições clássicas em vez das expressões de limite, redução e matemáticas, a variável `$values` será indexada pelo ID de referência e pela posição da condição na condição clássica. Por exemplo, se você tiver uma condição clássica com o RefID B que contém duas condições, então `$values` conterá duas condições `B0` e `B1`.
```
The first condition is {{ $values.B0 }}, and the second condition is {{ $values.B1 }}
```
## Funções
As seguintes funções também estão disponíveis ao expandir anotações e rótulos:
**args**
A função `args` converte uma lista de objetos em um mapa com as chaves arg0, arg1 etc. O objetivo é permitir que vários argumentos sejam transmitidos para os modelos.
**Exemplo**
```
{{define "x"}}{{.arg0}} {{.arg1}}{{end}}{{template "x" (args 1 "2")}}
```
```
1 2
```
**externalURL**
A função `externalURL` retorna o URL externo do servidor Grafana, conforme configurado nos arquivos ini.
**Exemplo**
```
{{ externalURL }}
```
```
https://example.com/grafana
```
**graphLink**
A função `graphLink` retorna o caminho para a visualização de grafo em [Explore na versão 9 do Grafana](v9-explore.md) para a expressão e a fonte de dados fornecidas.
**Exemplo**
```
{{ graphLink "{\"expr\": \"up\", \"datasource\": \"gdev-prometheus\"}" }}
```
```
/explore?left=["now-1h","now","gdev-prometheus",{"datasource":"gdev-prometheus","expr":"up","instant":false,"range":true}]
```
**humanize**
A função `humanize` humaniza os números decimais.
**Exemplo**
```
{{ humanize 1000.0 }}
```
```
1k
```
**humanize1024**
A `humanize1024` funciona de forma semelhante a `humanize`, mas usa 1024 como base em vez de 1000.
**Exemplo**
```
{{ humanize1024 1024.0 }}
```
```
1ki
```
**humanizeDuration**
A função `humanizeDuration` humaniza a duração em segundos.
**Exemplo**
```
{{ humanizeDuration 60.0 }}
```
```
1m 0s
```
**humanizePercentage**
A função `humanizePercentage` humaniza um valor de proporção para uma porcentagem.
**Exemplo**
```
{{ humanizePercentage 0.2 }}
```
```
20%
```
**humanizeTimestamp**
A `humanizeTimestamp` função humaniza um carimbo de data e hora do Unix.
**Exemplo**
```
{{ humanizeTimestamp 1577836800.0 }}
```
```
2020-01-01 00:00:00 +0000 UTC
```
**match**
A função `match` combina o texto com um padrão de expressão regular.
**Exemplo**
```
{{ match "a.*" "abc" }}
```
```
true
```
**pathPrefix**
A função `pathPrefix` retorna o caminho do servidor Grafana, conforme configurado nos arquivos ini.
**Exemplo**
```
{{ pathPrefix }}
```
```
/grafana
```
**tableLink**
A função `tableLink` retorna o caminho para a visualização tabular em [Explore na versão 9 do Grafana](v9-explore.md) para a expressão e fonte de dados fornecidas.
**Exemplo**
```
{{ tableLink "{\"expr\": \"up\", \"datasource\": \"gdev-prometheus\"}" }}
```
```
/explore?left=["now-1h","now","gdev-prometheus",{"datasource":"gdev-prometheus","expr":"up","instant":true,"range":false}]
```
**title**
A função `title` coloca em maiúscula o primeiro caractere de cada palavra.
**Exemplo**
```
{{ title "hello, world!" }}
```
```
Hello, World!
```
**toLower**
A função `toLower` retorna todo o texto em letras minúsculas.
**Exemplo**
```
{{ toLower "Hello, world!" }}
```
```
hello, world!
```
**toUpper**
A função `toUpper` retorna todo o texto em maiúsculas.
**Exemplo**
```
{{ toUpper "Hello, world!" }}
```
```
HELLO, WORLD!
```
**reReplaceAll**
A função `reReplaceAll` substitui o texto correspondente à expressão regular.
**Exemplo**
```
{{ reReplaceAll "localhost:(.*)" "example.com:$1" "localhost:8080" }}
```
```
example.com:8080
```
# Estado e integridade das regras de alertas
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
O estado e a integridade das regras de alertas ajudam você a entender vários indicadores-chave de status sobre os alertas.
Há três componentes principais: *estado da regra de alerta*, *estado da instância de alerta* e *integridade da regra de alerta*. Embora relacionado, cada componente transmite informações sutilmente diferentes.
**Estado da regra de alerta**
Uma regra de alerta de pode estar em um dos seguintes estados:
| Estado | Description |
| --- | --- |
| Normal | Nenhuma das séries temporais retornadas pelo mecanismo de avaliação está em um estado `Pending` ou `Firing`. |
| Pendente | Pelo menos uma série temporal retornada pelo mecanismo de avaliação é `Pending`. |
| Disparar | Pelo menos uma série temporal retornada pelo mecanismo de avaliação é `Firing`. |
**nota**
Os alertas mudam primeiro para `pending` e depois para `firing`, portanto, serão necessários pelo menos dois ciclos de avaliação antes que um alerta seja disparado.
**Estado da instância de alerta**
Uma instância de alerta de pode estar em um dos seguintes estados:
| Estado | Description |
| --- | --- |
| Normal | O estado de um alerta que não está sendo disparado nem está pendente, tudo está funcionando corretamente. |
| Pendente | O estado de um alerta que esteve ativo por menos tempo do que a duração do limite configurado. |
| Geração de alertas | O estado de um alerta que esteve ativo por mais tempo do que a duração do limite configurado. |
| NoData | Nenhum dado foi recebido para a janela de tempo configurada. |
| Erro | O erro que ocorreu ao tentar avaliar uma regra de alerta. |
**Integridade da regra de alerta**
Uma regra de alerta pode ter um dos seguintes status de saúde:
| Estado | Description |
| --- | --- |
| Ok | Nenhum erro ao avaliar uma regra de alerta. |
| Erro | Ocorreu um erro ao avaliar uma regra de alerta. |
| NoData | A ausência de dados em pelo menos uma série temporal retornada durante a avaliação de uma regra. |
**Alertas especiais para `NoData` e `Error`**
Quando a avaliação de uma regra de alerta produz um estado `NoData` ou `Error`, o Grafana Alerting gera instâncias de alerta com os seguintes rótulos adicionais:
| Rótulo | Description |
| --- | --- |
| alertname | `DatasourceNoData` ou `DatasourceError`, dependendo do estado. |
| datasource\$1uid | O UID da fonte de dados que causou o estado. |
Você pode lidar com esses alertas da mesma forma que os alertas regulares, adicionando um silêncio, uma rota para um ponto de contato etc.
# Pontos de contato
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Use pontos de contato para definir como seus contatos são notificados quando uma regra de alerta é disparada. Um ponto de contato pode ter um ou mais tipos de ponto de contato, por exemplo, e-mail, Slack, webhook etc. Quando uma regra de alerta é disparada, uma notificação é enviada para todos os tipos de pontos de contato listados para um ponto de contato. Os pontos de contato podem ser configurados para o Grafana Alertmanager, bem como para alertmanagers externos.
Você também pode usar modelos de notificação para personalizar mensagens de notificação para tipos de pontos de contato.
**Tipos de pontos de contato compatíveis**
A tabela a seguir lista os tipos de ponto de contato compatíveis com o Grafana.
| Nome | Tipo |
| --- | --- |
| Amazon SNS | `sns` |
| OpsGenie | `opsgenie` |
| PagerDuty | `pagerduty` |
| Slack | `slack` |
| VictorOps | `victorops` |
Para obter mais informações sobre pontos de contato, consulte [Trabalhar com pontos de contato](v9-alerting-contact-points.md) e [Personalizar notificações](v9-alerting-notifications.md).
# Notificações
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
O Grafana usa Alertmanagers para enviar notificações de alertas disparados e resolvidos. O Grafana tem seu próprio Alertmanager, indicado como “Grafana” na interface do usuário, mas também é compatível com o envio de notificações de outros Alertmanagers, como o [Prometheus Alertmanager](https://prometheus.io/docs/alerting/latest/alertmanager/). O Grafana Alertmanager usa políticas de notificação e pontos de contato para configurar como e onde uma notificação é enviada, com que frequência ela deve ser enviada e se todos os alertas devem ser enviados na mesma notificação, enviados em notificações agrupadas com base em um conjunto de rótulos ou como notificações separadas.
## Políticas de notificação
As políticas de notificação controlam quando e para onde as notificações são enviadas. Uma política de notificação pode escolher enviar todos os alertas juntos na mesma notificação, enviar alertas em notificações agrupadas com base em um conjunto de rótulos ou enviar alertas como notificações separadas. Você pode configurar cada política de notificação para controlar a frequência com que as notificações devem ser enviadas, além de ter um ou mais tempos de desativação de áudio para impedir as notificações em determinados horários do dia e em determinados dias da semana.
As políticas de notificação são organizadas em uma estrutura de árvore em que, na raiz da árvore, há uma política de notificação chamada política raiz. Só pode haver uma política raiz, e a política raiz não pode ser excluída.
Políticas de roteamento específicas são secundárias da política raiz e podem ser usadas para combinar todos os alertas ou um subconjunto de alertas com base em um conjunto de rótulos correspondentes. Uma política de notificação corresponde a um alerta quando os rótulos coincidentes correspondem aos rótulos no alerta.
Uma política de roteamento específica pode ter suas próprias políticas secundárias, chamadas de políticas aninhadas, que permitem uma correspondência adicional de alertas. Um exemplo de uma política de roteamento específica pode ser enviar alertas de infraestrutura para a equipe de operações, enquanto uma política secundária pode ser enviar alertas de alta prioridade para o PagerDuty e alertas de baixa prioridade para o Slack.
Todos os alertas, independentemente de seus rótulos, correspondem à política raiz. No entanto, quando a política raiz recebe um alerta, ela examina cada política de roteamento específica e envia o alerta para a primeira política de roteamento específica que corresponda ao alerta. Se a política de roteamento específica tiver outras políticas secundárias, ela poderá tentar corresponder o alerta com uma de suas políticas aninhadas. Se nenhuma política aninhada corresponder ao alerta, a política de roteamento específica será a política correspondente. Se não houver políticas de roteamento específicas, ou se nenhuma política de roteamento específica corresponder ao alerta, então a política raiz será a política correspondente.
## Pontos de contato
Os pontos de contato contêm a configuração para enviar notificações. Um ponto de contato é uma lista de integrações, cada uma das quais envia uma notificação para um endereço de e-mail, serviço ou URL específico. Os pontos de contato podem ter várias integrações do mesmo tipo ou uma combinação de integrações de diferentes tipos. Por exemplo, um ponto de contato pode conter uma integração com o PagerDuty; uma integração com o PagerDuty e o Slack; ou uma integração com o PagerDuty, uma integração com o Slack e duas integrações com o Amazon SNS. Você também pode configurar um ponto de contato sem integrações. Nesse caso, nenhuma notificação será enviada.
Um ponto de contato não pode enviar notificações até que tenha sido adicionado a uma política de notificação. Uma política de notificação só pode enviar alertas para um ponto de contato, mas um ponto de contato pode ser adicionado a várias políticas de notificação ao mesmo tempo. Quando um alerta corresponde a uma política de notificação, o alerta é enviado ao ponto de contato nessa política de notificação, que então envia uma notificação para cada integração em sua configuração.
**nota**
Para obter informações sobre integrações compatíveis para pontos de contato, consulte [Pontos de contato](v9-alerting-explore-contacts.md).
## Notificações com modelos
Você pode personalizar as notificações com modelos. Por exemplo, modelos podem ser usados para alterar o título e a mensagem das notificações enviadas ao Slack.
Os modelos não se limitam a uma integração individual ou ponto de contato, mas podem ser usados em várias integrações no mesmo ponto de contato, e até mesmo em integrações entre diferentes pontos de contato. Por exemplo, um usuário do Grafana pode criar um modelo denominado `custom_subject_or_title` e usá-lo para criar modelos de assuntos no PagerDuty e títulos de mensagens do Slack sem precisar criar dois modelos separados.
Todos os modelos de notificações são escritos na [linguagem de modelo do Go](https://pkg.go.dev/text/template) e estão na guia Pontos de contato na página de alertas.
## Silêncios
Você pode usar silêncios para desativar o áudio das notificações de uma ou mais regras de disparo. Os silêncios não impedem que os alertas sejam disparados ou resolvidos, nem ocultam os alertas de disparo na interface do usuário. Um silêncio dura pelo período definido, que pode ser configurado em minutos, horas, dias, meses ou anos.
# Configurar alertas
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Configure os recursos e as integrações de que você precisa para criar e gerenciar os alertas.
**Topics**
+ [Adicionar um Alertmanager externo](v9-alerting-setup-alertmanager.md)
+ [Provisionar recursos do Grafana Alerting](v9-alerting-setup-provision.md)
# 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 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
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.
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.
**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.
Os alertmanagers externos agora devem ser 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.
Para adicionar um Alertmanager externo, siga as etapas a seguir.
1. Clique em Configuração e depois em Fontes de dados.
1. Procure por Alertmanager.
1. Escolha sua implementação e 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. Clique em 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 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
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](v9-alerting-setup-provision-terraform.md)
+ [Visualizar recursos de alerta provisionados no Grafana](v9-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 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Use 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 outro 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](v9-alerting-managerules.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 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
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.
# 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 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Os espaços de trabalho que optam por não usar o Grafana Alerting usam o alerta clássico do dashboard. Para mudar para o novo Grafana Alerting, primeiro é necessário escolher o recurso.
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).
**nota**
Ao usar o Grafana Alerting, as regras de alerta definidas no Grafana, em vez de no Prometheus, enviam várias notificações para o seu ponto de contato. Se você estiver usando alertas nativos do Grafana, recomendamos que continue usando os alertas clássicos do dashboard e não habilite o novo recurso de alerta do Grafana. Se você quiser visualizar os alertas definidos na fonte de dados Prometheus, recomendamos que você habilite o Grafana Alerting, que envia somente uma única notificação para alertas criados no Alertmanager do Prometheus.
Essa limitação foi removida nos espaços de trabalho do Amazon Managed Grafana que são compatíveis com o Grafana v10.4 e versões posteriores.
## Migrar para o sistema do Grafana Alerting
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.
# Gerenciar as regras de alertas
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Uma regra de alerta é um conjunto de critérios de avaliação que determina se um alerta será disparado. A regra de alerta consiste em uma ou mais consultas e expressões, uma condição, a frequência da avaliação e, opcionalmente, a duração durante a qual a condição é atendida.
Enquanto consultas e expressões selecionam o conjunto de dados a ser avaliado, uma condição define o limite que um alerta deve atingir ou exceder para criar um alerta. Um intervalo especifica com que frequência uma regra de alerta é avaliada. A duração, quando configurada, indica por quanto tempo uma condição deve ser atendida. As regras de alerta também podem definir o comportamento dos alertas na ausência de dados.
**nota**
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.
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.
**Topics**
+ [Criar regras de alertas gerenciadas pelo Grafana](v9-alerting-managerules-grafana.md)
+ [Criar regras de alerta gerenciadas do Grafana Mimir ou Loki](v9-alerting-managerules-mimir-loki.md)
+ [Criar regras de gravação gerenciadas pelo Grafana Mimir ou Loki](v9-alerting-managerules-mimir-loki-recording.md)
+ [Namespaces e grupos de regras do Grafana Mimir ou Loki](v9-alerting-managerules-mimir-loki-groups.md)
+ [Visualizar e editar regras de alertas](v9-alerting-managerules-view-edit.md)
# Criar regras de alertas gerenciadas pelo Grafana
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
O Grafana permite criar regras de alerta que consultam uma ou mais fontes de dados, reduzem ou transformam os resultados e os comparam entre si ou com limites fixos. Quando elas são executadas, o Grafana envia notificações para o ponto de contato.
**Para adicionar uma regra gerenciada do Grafana**
1. No console do Grafana, no menu Grafana, escolha o ícone de **Alertas** (sino) para abrir a página **Alertas** listando os existentes.
1. Escolha **Nova regra de alerta**.
1. Na **Etapa 1**, adicione o nome, o tipo e o local de armazenamento da regra, da seguinte forma:
+ Em **Nome da regra**, adicione um nome descritivo. Esse nome é exibido na lista de regras de alerta. Também é o rótulo `alertname` de cada instância de alerta criada dessa regra.
+ No menu suspenso **Tipo de regra**, selecione **Alerta gerenciado pelo Grafana**.
+ No menu suspenso **Pasta**, selecione a pasta em que você deseja armazenar a regra. Se você não selecionar uma pasta, a regra será armazenada na pasta `General`. Para criar uma pasta, selecione a lista suspensa e insira um nome para a pasta.
1. Na **Etapa 2**, adicione as consultas e expressões a serem avaliadas.
+ Mantenha o nome padrão ou passe o mouse sobre ele e escolha o ícone de edição para alterar o nome.
+ Para consultas, selecione uma fonte de dados no menu suspenso.
+ Adicione uma ou mais [consultas ou expressões](v9-panels-query-xform-expressions.md).
+ 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 alertas separados para cada série. Para obter detalhes sobre essas opções, consulte [Regras únicas e multidimensionais](#v9-alerting-single-multi-rule).
+ Escolha **Executar consultas** para verificar se a consulta teve êxito.
1. Na **Etapa 3**, adicione as condições.
+ No menu suspenso **Condição**, selecione a consulta ou a expressão para iniciar a regra de alerta.
+ Em **Avaliar a cada**, especifique a frequência da avaliação. Deve ser um múltiplo de dez segundos. Por exemplo, `1m`, `30s`.
+ Em **Avaliar por**, especifique por quanto tempo a condição deve ser true antes que um alerta seja iniciado.
**nota**
Depois que uma condição é violada, o alerta entra no estado `Pending`. Se a condição permanecer violada pelo período especificado, o alerta mudará para o estado `Firing`. Se não for mais satisfeito, ele reverterá para o estado `Normal`.
+ Em **Configurar tratamento de erros e ausência de dados**, configure o comportamento dos alertas na ausência de dados. Use as diretrizes em [Lidar com casos de erro e ausência de dados](#v9-alerting-rule-no-data-error).
+ Escolha **Pré-visualizar alertas** para verificar o resultado da execução da consulta no momento. A pré-visualização exclui as condições de tratamento de erros e ausência de dados.
1. Na **Etapa 4**, adicione outros metadados associados à regra.
+ Adicione uma descrição e um resumo para personalizar as mensagens de alerta. Use as diretrizes em [Rótulos e anotações](v9-alerting-explore-labels.md).
+ Adicione URL, painel, painel e alerta IDs do Runbook.
+ Adicione rótulos personalizados.
1. Escolha **Salvar** para salvar a regra, ou **Salvar e sair** para salvar a regra e voltar para a página **Alertas**.
Depois de criar sua regra, você pode criar uma notificação para a regra. Para obter mais informações sobre notificações, consulte [Gerenciar as notificações de alerta](v9-alerting-managenotifications.md).
## Regras únicas e multidimensionais
Para as regras de alerta gerenciadas pelo Grafana, você pode criar uma regra com uma condição clássica ou uma regra multidimensional.
**Regra unidimensional (condição clássica)**
Use uma expressão de condição clássica para criar uma regra que inicia 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.
Para obter mais informações sobre como formatar expressões, consulte [Expressões](https://grafana.com/docs/grafana/next/panels/query-a-data-source/) na *documentação do Grafana*.
**Regra multidimensional**
Para gerar uma instância de alerta separada para cada série retornada na consulta, crie uma regra multidimensional.
**nota**
Cada instância de alerta gerada por uma regra multidimensional conta para sua cota total de alertas. As regras não são avaliadas quando você atinge sua cota de alertas. Para obter mais informações sobre cotas para regras multidimensionais, consulte [Cota alcançada de erros](#v9-alerting-rule-quota-reached).
Para criar várias instâncias de uma única regra, use as expressões `Math`, `Reduce` ou `Resample` para criar uma regra multidimensional. Por exemplo, você pode:
+ 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](v9-alerting-explore-numeric.md)).
+ Adicione uma expressão `Math` com a condição para a regra. Isso não é necessário no caso de uma consulta ou uma expressão de redução já retornar 0 se a regra não iniciar um alerta, ou um número positivo se ela precisar iniciar um alerta.
Alguns exemplos:
+ `$B > 70`se ele deve iniciar um alerta caso o valor de B query/expression seja maior que 70.
+ `$B < $C * 100` caso deva iniciar um alerta 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 em seus 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 na página [Template variables are not supported in alert queries while setting up Alert](https://community.grafana.com/t/template-variables-are-not-supported-in-alert-queries-while-setting-up-alert/2514) da comunidade.
**Considerações de performance para regras multidimensionais**
Cada instância de alerta conta para a cota de alertas. As regras multidimensionais que criam mais instâncias do que as que podem ser acomodadas na cota de alertas não são avaliadas e retornam um erro de cota. Para obter mais informações, consulte [Cota alcançada de erros](#v9-alerting-rule-quota-reached).
Os alertas multidimensionais podem ter um alto impacto na performance do espaço de trabalho do Grafana, bem como na performance das fontes de dados, pois o Grafana os consulta para avaliar as regras de alertas. As considerações a seguir podem ser úteis quando você está tentando otimizar a performance do sistema de monitoramento.
+ **Frequência da avaliação da regra**: a propriedade **Avaliar a cada** de uma regra de alerta controla a frequência da avaliação da regra. Recomendamos usar a menor frequência de avaliação aceitável.
+ **Cardinalidade do conjunto de resultados**: o número de instâncias de alerta que você cria com uma regra afeta a performance. Suponha que você esteja monitorando os erros de resposta da API para cada caminho de API, em cada VM na sua frota. Esse conjunto tem uma cardinalidade do número de caminhos multiplicado pelo número de. VMs Você pode reduzir a cardinalidade do conjunto de resultados, por exemplo, monitorando o total de erros por VM em vez de por caminho por VM.
+ **Complexidade da consulta**: consultas que as fontes de dados podem processar e responder rapidamente consomem menos recursos. Embora essa consideração seja menos importante do que as outras listadas acima, se você as reduziu ao máximo, observar a performance de consultas individuais pode fazer a diferença. Você também deve estar ciente do impacto na performance que a avaliação dessas regras tem nas fontes de dados. As consultas de alerta geralmente são a grande maioria das consultas tratadas pelos bancos de dados de monitoramento, portanto, os mesmos fatores de carga que afetam a instância do Grafana também as afetam.
## Cota alcançada de erros
Há uma cota para o número de instâncias de alerta que você pode ter em um único espaço de trabalho. Ao atingir esse número, você não poderá mais criar regras de alerta nesse espaço de trabalho. Com alertas multidimensionais, o número de instâncias de alerta pode variar com o tempo.
É importante lembrar os aspectos a seguir ao trabalhar com instâncias de alerta.
+ Se você criar somente regras unidimensionais, cada regra será uma única instância de alerta. Você pode criar, no máximo, o mesmo número de regras em um único espaço de trabalho que sua cota de instâncias de alerta.
+ Regras multidimensionais criam várias instâncias de alerta, no entanto, o número não é conhecido até que sejam avaliadas. Por exemplo, se você criar uma regra de alerta que rastreia o uso da CPU de suas instâncias do Amazon EC2, poderá haver 50 instâncias do EC2 quando você a criar (e, portanto, 50 instâncias de alerta), mas se você adicionar mais 10 instâncias do EC2 uma semana depois, a próxima avaliação terá 60 instâncias de alerta.
O número de instâncias de alerta é avaliado quando você cria um alerta multidimensional, e você não pode criar um que coloque você logo acima da cota de instâncias de alerta. Como o número de instâncias de alerta pode mudar, sua cota é verificada sempre que as regras são avaliadas.
+ No momento da avaliação da regra, se uma regra fizer com que você ultrapasse sua cota para instâncias de alerta, essa regra não será avaliada até que uma atualização seja feita na regra de alerta que coloque a contagem total de instâncias de alerta abaixo da cota de serviço. Quando isso acontece, você recebe uma notificação de alerta informando que sua cota foi atingida (a notificação usa a política de notificação da regra que está sendo avaliada). A notificação inclui uma anotação de `Error` com o valor `QuotaReachedError`.
+ Uma regra que faz com que um `QuotaReachedError` pare de ser avaliado. A avaliação só é retomada quando uma atualização é feita e a avaliação após a atualização não causa, por si só, um `QuotaReachedError`. Uma regra que não está sendo avaliada mostra o erro de **Cota atingida** no console do Grafana.
+ Você pode reduzir o número de instâncias de alerta removendo as regras de alerta ou editando alertas multidimensionais para ter menos instâncias de alerta (por exemplo, ter um alerta sobre erros por VM, em vez de um alerta sobre erros por API em uma VM).
+ Para retomar as avaliações, atualize o alerta e salve-o. Você pode atualizá-lo para diminuir o número de instâncias de alerta ou, se tiver feito outras alterações para diminuir o número de instâncias de alerta, poderá salvá-lo sem alterações. Se puder ser retomado, ele será. Se isso causar outro `QuotaReachedError`, você não poderá salvá-lo.
+ Quando um alerta é salvo e retoma a avaliação sem ultrapassar a cota de alertas, o erro **Cota atingida** pode continuar sendo exibido no console do Grafana por algum tempo (até o intervalo de avaliação). No entanto, a avaliação da regra de alerta é iniciada e os alertas serão enviados se o limite da regra for atingido.
+ Para obter detalhes sobre a cota de alertas, bem como outras cotas, consulte [Cotas de serviço do Amazon Managed Grafana](AMG_quotas.md).
## Lidar com casos de erro e ausência de dados
Escolha opções de como lidar com o comportamento de alertas na ausência de dados ou quando há erros.
As opções para lidar com a ausência de dados são listadas na tabela a seguir.
| Opção de ausência de dados | Comportamento |
| --- | --- |
| Nenhum dado | Crie um 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 | Defina o estado da regra do alerta como `Alerting`. |
| OK | Defina o estado da regra do alerta como `Normal`. |
As opções para lidar com casos de erro são listadas na tabela a seguir.
| Opção de erro ou tempo limite | Comportamento |
| --- | --- |
| Geração de alertas | Defina o estado da regra do alerta como `Alerting` |
| OK | Defina o estado da regra do alerta como `Normal` |
| Erro | Crie um alerta `DatasourceError` 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. |
# Criar regras de alerta gerenciadas do Grafana Mimir ou Loki
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Usando o Grafana, você pode criar regras de alerta para uma instância externa do Grafana Mimir ou Loki.
**nota**
O Grafana Mimir pode se conectar ao Amazon Managed Service for Prometheus e às fontes de dados Prometheus.
**Pré-requisitos**
+ Verifique se você tem permissões de escrita na fonte de dados Prometheus. Do contrário, você não poderá criar ou atualizar as regras de alerta gerenciadas do Cortex.
+ 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 `/api/prom` legado, não o `/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 alerta 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 adicionar uma regra de alerta gerenciada do Grafana Mimir ou Loki**
1. No console do Grafana, no menu Grafana, escolha o ícone de **Alertas** (sino) para abrir a página **Alertas** listando os existentes.
1. Escolha **Criar regra de alerta**.
1. Na **Etapa 1**, escolha o tipo de regra e os detalhes, da seguinte forma:
+ Escolha **Alerta Mimir ou Loki**.
+ Em **Nome da regra**, adicione um nome descritivo. Esse nome é exibido na lista de regras de alerta. Também é o rótulo `alertname` de cada instância de alerta criada dessa regra.
+ No menu suspenso **Selecionar fonte de dados**, selecione uma fonte de dados Prometheus ou Loki.
+ No menu suspenso **Namespace**, selecione um namespace de regra existente. Do contrário, escolha **Adicionar novo** e insira um nome para criar um. Os namespaces podem conter um ou mais grupos de regras e ter apenas uma finalidade organizacional. Para obter mais informações, consulte [Namespaces e grupos de regras do Cortex ou Loki](alert-rules.md#alert-rule-groups).
+ No menu suspenso **Grupo**, selecione um grupo existente no namespace selecionado. Do contrário, escolha **Adicionar novo** e insira um nome para criar um. 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. Na **Etapa 2**, adicione a consulta a ser avaliada.
O valor pode ser uma expressão PromQL ou LogQL. A regra iniciará um alerta se o resultado da avaliação tiver pelo menos uma série com um valor maior que 0. Um alerta é criado para cada série.
1. Na **Etapa 3**, especifique o intervalo de avaliação do alerta.
Na caixa de texto **Por** da condição, especifique por quanto tempo a condição deve ser true antes que o alerta seja iniciado. Se você especificar `5m`, as condições deverão ser true por cinco minutos antes que o alerta seja iniciado.
**nota**
Depois que 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`. Se não for mais satisfeito, ele reverterá para o estado `Normal`.
1. Na **Etapa 4**, adicione outros metadados associados à regra.
+ Adicione uma descrição e um resumo para personalizar as mensagens de alerta. Use as diretrizes em [Rótulos e anotações](v9-alerting-explore-labels.md).
+ Adicione URL, painel, painel e alerta IDs do Runbook.
+ Adicione rótulos personalizados.
1. Escolha **Pré-visualizar alertas** para avaliar a regra e ver quais alertas ela vai produzir. Essa opção vai exibir uma lista de alertas com o estado e o valor de cada um.
1. Escolha **Salvar** para salvar a regra, ou **Salvar e sair** para salvar a regra e voltar para a página **Alertas**.
Depois de criar sua regra, você pode criar uma notificação para a regra. Para obter mais informações sobre notificações, consulte [Gerenciar as notificações de alerta](v9-alerting-managenotifications.md).
# Criar regras de gravação gerenciadas pelo Grafana Mimir ou Loki
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
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.
**Pré-requisitos**
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**: ao configurar uma fonte de dados para apontar para o Grafana Mimir, use o prefixo `/api/prom` legado, não `/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 adicionar uma regra de gravação gerenciada pelo Grafana Mimir ou Loki**
1. No console do Grafana, no menu Grafana, escolha o ícone de **Alertas** (sino) para abrir a página **Alertas** listando os existentes.
1. Escolha **Criar regra de alerta**.
1. Na **Etapa 1**, adicione o tipo de regra, o nome da regra e o local de armazenamento, conforme a seguir.
+ Selecione a opção de **regra de gravação do Mimir ou Loki**.
+ Em **Nome da regra**, adicione um nome descritivo. Esse nome é exibido na lista de regras de alerta. Também é o rótulo `alertname` de cada instância de alerta criada dessa regra.
+ No menu suspenso **Selecionar fonte de dados**, selecione uma fonte de dados Prometheus ou Loki.
+ No menu suspenso **Namespace**, selecione um namespace de regra existente. Do contrário, escolha **Adicionar novo** e insira um nome para criar um. Os namespaces podem conter um ou mais grupos de regras e ter apenas uma finalidade organizacional. Para obter mais informações, consulte [Namespaces e grupos de regras do Cortex ou Loki](alert-rules.md#alert-rule-groups).
+ No menu suspenso **Grupo**, selecione um grupo existente no namespace selecionado. Do contrário, escolha **Adicionar novo** e insira um nome para criar um. 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. Na **Etapa 2**, adicione a consulta a ser avaliada.
O valor pode ser uma expressão PromQL ou LogQL. A regra iniciará um alerta se o resultado da avaliação tiver pelo menos uma série com um valor maior que 0. Um alerta é criado para cada série.
1. Na **Etapa 3**, adicione outros metadados associados à regra.
+ Adicione uma descrição e um resumo para personalizar as mensagens de alerta. Use as diretrizes em [Anotações e rótulos para regras de alerta](alert-rules.md#alert-rule-labels).
+ Adicione URL, painel, painel e alerta IDs do Runbook.
+ Adicione rótulos personalizados.
1. Escolha **Salvar** para salvar a regra, ou **Salvar e sair** para salvar a regra e voltar para a página **Alertas**.
# Namespaces e grupos de regras do Grafana Mimir ou Loki
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Você pode organizar as regras. As regras são criadas dentro de grupos de regras, e os grupos de regras são organizados em namespaces. As regras dentro de um grupo de regras são executadas sequencialmente em intervalos regulares. O intervalo padrão é de um minuto. Você pode renomear namespaces e grupos de regras do Grafana Mimir ou Loki e editar intervalos de avaliação de grupos de regras.
**Para editar um namespace ou grupo de regras**
1. No console do Grafana, no menu do Grafana, escolha o ícone de **Alertas** (sino) para abrir a página **Alertas**.
1. Navegue até uma regra no namespace ou no grupo de regras que você deseja editar.
1. Selecione o ícone de **Editar** (caneta).
1. Faça alterações no grupo de regras ou no namespace.
**nota**
Para namespaces, você só pode editar o nome. Para grupos de regras, você altera o nome ou o intervalo de avaliação das regras no grupo. Por exemplo, você pode escolher `1m` para avaliar as regras a cada minuto ou `30s` para avaliar a cada 30 segundos.
1. Escolha **Salvar alterações**.
# Visualizar e editar regras de alertas
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
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, e a seção **Cortex/Loki** lista as regras para fontes de dados compatíveis com o Prometheus. 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.
**nota**
Você pode visualizar as definições de consulta para alertas provisionados, mas não pode editá-las. Poder visualizá-las permite que você verifique se as consultas e definições de regras estão corretas sem precisar voltar ao repositório de provisionamento para ver as definições de regras.
## Visualizar regras de alertas
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 do Grafana, escolha o ícone de **Alertas** (sino) para abrir a página **Alertas**. Por padrão, as regras são exibidas em grupos por tipo de fonte de dados. Você também pode visualizar pelo estado atual de cada alerta (eles são descritos com mais detalhes no texto a seguir).
1. Em **Visualizar como**, você pode alternar entre as visualizações de grupo e estado escolhendo a opção de sua preferência.
1. Escolha a seta ao lado de uma linha para exibir mais detalhes dessa linha. Os detalhes de uma regra incluem anotações, fontes de dados, consultas e rótulos de regras, bem como uma lista de instâncias de alerta resultantes da regra.
**nota**
Para obter mais informações sobre como entender os detalhes de seus alertas, consulte [Estado e integridade das regras de alertas](v9-alerting-explore-state.md).
**Visualização Grupo**
A visualização Grupo 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.
+ Você pode filtrar para exibir as regras que consultam uma fonte de dados específica escolhendo **Selecionar fontes de dados** e selecionando uma fonte de dados para a qual filtrar.
+ Você pode filtrar por rótulos escolhendo os critérios de pesquisa em **Pesquisar por rótulo**. Por exemplo, você pode digitar `environment=production,region=~US|EU,severity!=warning` para filtrar os avisos de produção nos EUA e na UE.
+ Você pode filtrar para exibir as regras em um estado específico escolhendo **Filtrar alertas por estado**, e depois selecionando o estado que deseja visualizar.
## Editar ou excluir regras de alerta
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. As regras de alerta para uma instância externa do Mimir ou Loki podem ser editadas ou excluídas por usuários com perfis de editor ou administrador.
**Para editar ou excluir uma regra**
1. Expanda uma regra até ver os controles de regra para **Visualizar**, **Editar** e **Excluir**.
1. Escolha **Editar** para abrir a página de criação de regras. Faça atualizações da mesma forma como ao criar uma regra. Para obter detalhes, consulte as instruções em [Criar regras de alertas gerenciadas pelo Grafana](v9-alerting-managerules-grafana.md) ou [Criar regras de alerta gerenciadas do Grafana Mimir ou Loki](v9-alerting-managerules-mimir-loki.md).
1. Opcionalmente, escolha **Excluir** para excluir uma regra.
## Exportar regras de alertas
Você pode exportar regras para YAML ou JSON no espaço de trabalho do Grafana, escolhendo **Exportar**. Isso lhe dará a opção de definir uma nova regra e depois exportá-la. Você pode criar uma regra usando a interface de usuário e depois exportá-la para uso na API de provisionamento ou nos scripts do Terraform.
**nota**
Isso é compatível tanto no espaço de trabalho do Grafana quanto na interface de provisionamento.
# Gerenciar as 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 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
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 uma primeira etapa, defina os *pontos de contato*, para onde enviar suas notificações de alerta. Um ponto de contato pode ser um conjunto de destinos para notificações correspondentes. 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 seus 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. Adicione tempos de desativação de áudio à política de notificação. O *tempo de desativação de áudio* é um intervalo de tempo recorrente durante o qual você não deseja que nenhuma notificação seja enviada.
Quando uma regra de alerta é avaliada, a régua de alerta envia instâncias de alerta para o Alertmanager. Uma regra de alerta pode acionar várias *instâncias de alerta* individuais.
O Alertmanager recebe essas instâncias de alerta e, em seguida, gerencia os tempos de desativação de áudio, agrupa os alertas e envia as notificações aos seus pontos de contato, conforme definido na política de notificação.
**Topics**
+ [Alertmanager](v9-alerting-managenotifications-alertmanager.md)
+ [Trabalhar com pontos de contato](v9-alerting-contact-points.md)
+ [Trabalhar com políticas de notificação](v9-alerting-notification-policies.md)
+ [Personalizar notificações](v9-alerting-notifications.md)
+ [Silenciar notificações de alerta de fontes de dados do Prometheus](v9-alerting-silences.md)
+ [Tempos de desativação de áudio](v9-alerting-notification-muting.md)
+ [Visualizar e filtrar por grupos de alertas](v9-alerting-viewfiltergroups.md)
+ [Visualizar erros de notificação](v9-alerting-viewnotificationerrors.md)
# Alertmanager
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
O 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 caso execute o Grafana on-premises ou de código aberto.
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.
# Trabalhar com pontos de contato
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Use pontos de contato para definir como os contatos serão notificados quando um alerta for iniciado. Um ponto de contato pode ter uma ou mais integrações de pontos de contato, por exemplo, Amazon Simple Notification Service ou Slack. Quando um alerta é iniciado, uma notificação é enviada para todas as integrações de pontos de contato listadas para um ponto de contato. Opcionalmente, use [modelos de notificação](v9-alerting-create-templates.md) para personalizar as mensagens de notificação para os tipos de pontos de contato.
**nota**
Você pode criar e editar pontos de contato para alertas gerenciados pelo Grafana. Os pontos de contato dos alertas do Alertmanager são somente leitura.
## Trabalhar com pontos de contato
Os procedimentos a seguir detalham como adicionar, editar, testar e excluir pontos de contato.
**Para adicionar um ponto de contato**
1. No console do Grafana, no menu do Grafana, escolha o ícone de **Alertas** (sino) para abrir a página **Alertas**.
1. Escolha **Pontos de contato** e, em seguida, **Adicionar ponto de contato**.
1. No menu suspenso do **Alertmanager**, selecione um Alertmanager. O Grafana Alertmanager é selecionado por padrão.
1. Insira um **Nome** para o ponto de contato.
1. Em **Integração de ponto de contato**, escolha um tipo e 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. Se o ponto de contato precisar de mais tipos de pontos de contato, você pode escolher **Adicionar integração de ponto de contato** e repetir as etapas para cada tipo de ponto de contato necessário.
1. Escolha **Salvar ponto de contato** para salvar as alterações.
**Para editar um ponto de contato**
1. Escolha **Pontos de contato** para ver uma lista dos pontos de contato existentes.
1. Selecione o ponto de contato a ser editado e, em seguida, escolha o ícone de **Editar** (caneta).
1. Faça as alterações necessárias e escolha **Salvar ponto de contato** para salvar as alterações.
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. Escolha **Pontos de contato** para abrir a lista de pontos de contato existentes.
1. Selecione o ponto de contato a ser testado e, em seguida, escolha o ícone de **Editar** (caneta).
1. Selecione o ícone de **Teste** (avião de papel).
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.
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. Escolha **Pontos de contato** para abrir a lista de pontos de contato existentes.
1. Selecione o ponto de contato a ser excluído e escolha o ícone de **Excluir** (lixeira).
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.
## Lista de notificadores compatíveis
| Nome | Tipo |
| --- | --- |
| Amazon SNS | sns |
| OpsGenie | opsgenie |
| PagerDuty | pagerduty |
| Slack | slack |
| VictorOps | victorops |
# Trabalhar com 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 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
As 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 secundárias. Cada política, exceto a política raiz, também pode corresponder a rótulos de alerta específicos. Cada alerta é avaliado pela política raiz e depois por cada política secundária. Se você habilitar a opção `Continue matching subsequent sibling nodes` para uma política específica, 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 raiz controla qualquer alerta que não corresponda a uma política específica.
**nota**
Você pode criar e editar políticas de notificação para alertas gerenciados pelo Grafana. As políticas de notificação para alertas do Alertmanager são somente leitura.
**Notificações de agrupamento**
O agrupamento categoriza as notificações de alerta de natureza semelhante em um único funil. Isso permite que você controle as notificações de alerta durante interrupções maiores, quando muitas partes de um sistema falham ao mesmo tempo, fazendo com que um grande número de alertas seja iniciado simultaneamente.
**Exemplo de agrupamento**
Suponha que você tenha cem serviços conectados a um banco de dados em diferentes ambientes. Esses serviços são diferenciados pelo rótulo `env=environmentname`. Existe uma regra de alerta para monitorar se os serviços podem acessar o banco de dados. A regra de alerta cria alertas denominados `alertname=DatabaseUnreachable`.
Se ocorrer uma partição de rede, em que metade dos serviços não consiga mais acessar o banco de dados, 50 alertas diferentes serão iniciados. Para essa situação, você deseja receber uma notificação de uma única página (em vez de 50) com uma lista dos ambientes afetados.
Você pode configurar o agrupamento para ser `group_by: [alertname]` (sem usar o rótulo `env`, que é diferente para cada serviço). Com essa configuração em vigor, o Grafana envia uma única notificação compacta que contém todos os ambientes afetados por essa regra de alerta.
**Grupos especiais**
O Grafana tem dois grupos especiais. O grupo padrão, `group_by: null` agrupa *todos* os alertas em um único grupo. Você também pode usar um rótulo especial denominado `...` para agrupar alertas por todos os rótulos, desabilitando efetivamente o agrupamento e enviando cada alerta para seu próprio grupo.
## Trabalhar com notificações
Os procedimentos a seguir mostram como criar e gerenciar políticas de notificação.
**Para editar a política de notificação raiz**
1. No console do Grafana, no menu do Grafana, escolha o ícone de **Alertas** (sino) para abrir a página **Alertas**.
1. Escolha **Políticas de notificação**.
1. No menu suspenso do **Alertmanager**, selecione o Alertmanager que deseja editar.
1. Na seção **Política raiz**, escolha o ícone de **Editar** (caneta).
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 (ou grupos especiais) pelos quais agrupar os alertas.
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 adicionar uma nova política específica de alto nível**
1. No console do Grafana, no menu do Grafana, escolha o ícone de **Alertas** (sino) para abrir a página **Alertas**.
1. Escolha **Políticas de notificação**.
1. No menu suspenso do **Alertmanager**, selecione o Alertmanager que deseja editar.
1. Na seção **Roteamento específico**, escolha **Nova política específica**.
1. Na seção **Rótulos correspondentes**, adicione um ou mais rótulos de alerta correspondentes. Veja outras informações sobre correspondência de rótulos mais adiante neste tópico.
1. Em **Ponto de contato**, adicione o ponto de contato para o qual enviar notificações se o alerta corresponder a essa política específica. As políticas aninhadas substituem esse ponto de contato.
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 essa política está habilitada, você pode receber mais de uma notificação para o mesmo alerta.
1. Opcionalmente, selecione **Substituir agrupamento** para especificar um agrupamento diferente da política raiz.
1. Opcionalmente, selecione **Substituir tempos gerais** para substituir as opções de tempo na política de notificação de grupo.
1. Para salvar suas alterações, selecione **Salvar política**.
**Para adicionar uma política aninhada**
1. Expanda a política específica na qual você deseja criar uma política aninhada.
1. Escolha **Adicionar política aninhada** e, em seguida, adicione os detalhes (como ao adicionar uma política específica de nível superior).
1. Para salvar suas alterações, selecione **Salvar política**.
**Para editar uma política específica**
1. Na página **Alertas**, escolha **Políticas de notificação** para abrir a página que lista as políticas existentes.
1. Selecione a política que deseja editar e depois escolha o ícone de **Editar** (caneta).
1. Faça qualquer alteração (como ao adicionar uma política específica de nível superior).
1. Escolha **Salvar política**.
**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**.
+ Para pesquisar por rótulo, insira um matcher de rótulos válido no campo **Pesquisar por rótulo**. 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.
**Como funciona a correspondência de rótulos**
Uma política corresponderá a um alerta se os rótulos do alerta corresponderem a todos os *rótulos correspondentes* especificados na política.
+ **Rótulo**: o nome do rótulo correspondente. Ele deve corresponder exatamente ao nome do rótulo do alerta.
+ **Operador**: o operador usado para comparar o valor do rótulo com o valor do rótulo correspondente. Os operadores disponíveis são:
+ `=` Selecione rótulos cujo valor corresponda exatamente à string fornecida.
+ `!=` Selecione rótulos cujo valor não corresponda à string fornecida.
+ `=~` Selecione rótulos cujo valor corresponda ao valor interpretado pelo regex da string fornecida (a string fornecida é interpretada como uma expressão regular).
+ `!=` Selecione rótulos que não correspondam à expressão regular fornecida.
+ **Valor**: o valor ao qual corresponder ao valor do rótulo. Pode corresponder como uma string ou como uma expressão regular, dependendo do operador escolhido.
# 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 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
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 e-mail 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](v9-alerting-notifications-go-templating.md)
+ [Criar modelos de notificações](v9-alerting-create-templates.md)
+ [Referência do modelo](v9-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 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
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](v9-alerting-create-templates.md), e todos os dados e funções na [Referência do modelo](v9-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](#v9-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 }}
```
## 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 }}
```
## Incorporar modelos
Você pode incorporar um modelo definido em 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 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
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. Clique em **Adicionar modelo**.
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. Clique em Salvar.
`{{ 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. Clique em **Adicionar modelo**.
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 a seguir mostram exemplos detalhados de modelos que você pode criar.
1. Clique em Salvar.
## Criar um modelo para o assunto de um e-mail
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. Use o modelo ao criar a integração de ponto de contato, colocando-a no campo **Título** com a palavra-chave `template`.
```
{{ 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 os rótulos, as anotações e o URL do dashboard:
```
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. 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 "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 **Pontos de contato** para ver uma lista dos pontos de contato existentes.
1. Escolha **Adicionar ponto de contato**. Como alternativa, você pode editar um ponto de contato existente escolhendo o ícone de **Editar** (caneta) ao lado do ponto de contato que você deseja editar.
1. Insira os modelos que você deseja usar em um ou mais campos, 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. Clique em **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 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Esta seção fornece informações de referência para criar os modelos.
## Dados do modelo
Os dados a seguir são passados para os modelos de mensagem.
| Nome | Tipo | Observações |
| --- | --- | --- |
| `Receiver` | string | Nome do ponto de contato para o qual a notificação está sendo enviada. |
| `Status` | string | disparado se pelo menos um alerta estiver sendo disparado, caso contrário, resolvido. |
| `Alerts` | Alerta | Lista de objetos de alerta incluídos nessa notificação (veja abaixo). |
| `GroupLabels` | KeyValue | Rótulos pelos quais esses alertas foram agrupados. |
| `CommonLabels` | KeyValue | Rótulos comuns a todos os alertas incluídos nessa notificação. |
| `CommonAnnotations` | KeyValue | Anotações comuns a todos os alertas incluídos nessa notificação. |
| `ExternalURL` | string | Link de retorno para o Grafana que enviou a notificação. Se estiver usando o Alertmanager externo, volte para ele. |
O tipo `Alerts` expõe duas funções para filtrar os alertas retornados.
+ `Alerts.Firing`: retorna uma lista de alertas disparados.
+ `Alerts.Resolved`: retorna uma lista de alertas resolvidos.
**Alerta (tipo)**
O tipo de alerta contém os dados a seguir.
| Nome | Tipo | Observações |
| --- | --- | --- |
| Status | string | `firing` ou `resolved`. |
| Rótulos | KeyValue | Um conjunto de rótulos anexados ao alerta. |
| Anotações | KeyValue | Um conjunto de anotações anexadas ao alerta. |
| Valores | KeyValue | Os valores de todas as expressões, incluindo as condições clássicas |
| StartsAt | time.Time | Hora em que o alerta começou a disparar. |
| 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. |
| GeneratorURL | string | Um link de retorno para o Grafana ou para o Alertmanager externo. |
| SilenceURL | string | Um link para silenciar o alerta (com rótulos para esse alerta pré-preenchidos). Somente para alertas gerenciados pelo Grafana. |
| DashboardURL | string | Link para o dashboard do Grafana, se a regra de alerta pertencer a um. Somente para alertas gerenciados pelo Grafana. |
| PanelURL | string | Link para o painel do dashboard do Grafana, se a regra de alerta pertencer a um. Somente para alertas gerenciados pelo Grafana. |
| Impressão digital | string | Impressão digital que pode ser usada para identificar o alerta. |
| ValueString | string | Uma string que contém os rótulos e o valor de cada expressão reduzida no alerta. |
**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 é `firing if at least one alert is firing, otherwise 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 de rótulos | `{{ .Names }}` |
| Valores | | []string | Lista de valores de rótulos | `{{ .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).
## Funções de modelo
Ao usar funções de modelo, você pode processar rótulos e anotações para gerar notificações dinâmicas. As funções a seguir estão disponíveis.
| Nome | Tipo de argumento | Tipo de retorno | Description |
| --- | --- | --- | --- |
| `humanize` | número ou string | string | Converte um número em um formato mais legível, usando prefixos de métricas. |
| `humanize1024` | número ou string | string | Como o humanize, mas usa 1024 como base em vez de 1000. |
| `humanizeDuration` | número ou string | string | Converte uma duração em segundos em um formato mais legível. |
| `humanizePercentage` | número ou string | string | Converte um valor de proporção em uma fração de 100. |
| `humanizeTimestamp` | número ou string | string | Converte um carimbo de data e hora do Unix em segundos em um formato mais legível. |
| `title` | string | string | strings.Title, coloca em maiúscula o primeiro caractere de cada palavra. |
| `toUpper` | string | string | cordas. ToUpper, converte todos os caracteres em maiúsculas. |
| `toLower` | string | string | cordas. ToLower, converte todos os caracteres em minúsculas. |
| `match` | padrão, texto | Booleano | regexp. MatchString Testes para uma correspondência de expressão regular não ancorada. |
| `reReplaceAll` | padrão, substituição, texto | string | Regexp. ReplaceAllString Substituição Regexp, não ancorada. |
| `graphLink` | string: objeto JSON com os campos `expr` e `datasource` | string | Retorna o caminho para a visualização gráfica no Explore para a expressão e a fonte de dados fornecidas. |
| `tableLink` | string: objeto JSON com os campos `expr` e `datasource` | string | Retorna o caminho para a visualização tabular no Explore para a expressão e a fonte de dados fornecidas. |
| `args` | []interface\$1\$1 | map[string]interface\$1\$1 | Converte uma lista de objetos em um mapa com chaves, por exemplo, arg0, arg1. Use essa função para passar vários argumentos para modelos. |
| `externalURL` | nothing | string | Retorna uma string representando o URL externo. |
| `pathPrefix` | nothing | string | Retorna o caminho do URL externo. |
A tabela a seguir mostra exemplos do uso de cada função.
| Função | TemplateString | Input | Esperados |
| --- | --- | --- | --- |
| humanize | \$1 humanize \$1value \$1 | 1234567,0 | 1,235M |
| humanize1024 | \$1 humanize1024 \$1value \$1 | 1048576,0 | 1Mi |
| humanizeDuration | \$1 humanizeDuration \$1value \$1 | 899,99 | 14m 59s |
| humanizePercentage | \$1 humanizePercentage \$1value \$1 | 0,1234567 | 12,35% |
| humanizeTimestamp | \$1 humanizeTimestamp \$1value \$1 | 1435065584.128 | 2015-06-23 13:19:44.128 \$10000 UTC |
| título | \$1 \$1value \$1 title \$1 | aa bB CC | Aa Bb Cc |
| toUpper | \$1 \$1value \$1 toUpper \$1 | aa bB CC | AA BB CC |
| toLower | \$1 \$1value \$1 toLower \$1 | aa bB CC | aa bb cc |
| match | \$1 match "a\$1" \$1labels.instance \$1 | aa | true |
| reReplaceAll | \$1\$1 reReplaceAll “localhost :( .\$1)” “meu.domínio: \$11" \$1labels.instance\$1\$1 | localhost:3000 | my.domain:3000 |
| graphLink | \$1\$1 graphLink "\$1\$1"expr\$1": \$1"up\$1", \$1"datasource\$1": \$1"gdev-prometheus\$1"\$1" \$1\$1 | | /explore?left=["now-1h","now","gdev-prometheus",\$1"datasource":"gdev-prometheus","expr":"up","instant":false,"range":true\$1] |
| tableLink | \$1\$1 tableLink "\$1\$1"expr\$1":\$1"up\$1", \$1"datasource\$1":\$1"gdev-prometheus\$1"\$1" \$1\$1 | | /explore?left=["now-1h","now","gdev-prometheus",\$1"datasource":"gdev-prometheus","expr":"up","instant":true,"range":false\$1] |
| args | \$1\$1define "x"\$1\$1\$1\$1.arg0\$1\$1 \$1\$1.arg1\$1\$1\$1\$1end\$1\$1\$1\$1template "x" (args 1 "2")\$1\$1 | | 1 2 |
| externalURL | \$1 externalURL \$1 | | http://localhost/path/prefix |
| pathPrefix | \$1 pathPrefix \$1 | | /path/prefix |
# Silenciar notificações de alerta de fontes de dados do Prometheus
****
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Para fontes de dados externas do Alertmanager (incluindo o Amazon Managed Service for Prometheus), 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.
Você pode configurar silêncios para uma fonte de dados externa do Alertmanager.
**nota**
Para suprimir as notificações de alerta em intervalos regulares ou para outras fontes de dados (por exemplo, durante períodos regulares de manutenção), use [Tempos de desativação de áudio](v9-alerting-notification-muting.md) em vez de silêncios.
**Para adicionar um silêncio**
1. No console do Grafana, no menu do Grafana, escolha o ícone de **Alertas** (sino) para abrir a página **Alertas**.
1. Escolha **Silêncios** para abrir uma página que lista os [Trabalhar com pontos de contato](v9-alerting-contact-points.md) existentes.
1. Escolha o Alertmanager externo no menu suspenso **Alertmanager**.
1. Selecione **Adicionar 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.
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 **Nome** e **Valor**, insira um ou mais *rótulos correspondentes*. Os matchers determinam a quais regras o silêncio se aplica. A correspondência do rótulo é discutida em mais detalhes após este procedimento.
1. Opcionalmente, adicione um **comentário** ou modifique o **Criador** para definir o proprietário do silêncio.
1. Escolha **Criar** para criar o silêncio.
Você pode editar um silêncio existente escolhendo o ícone de **Editar** (caneta).
**Correspondência de rótulos para supressão de alertas**
Ao criar um silêncio, você cria um conjunto de *rótulos correspondentes* como parte do silêncio. Esse é um conjunto de regras sobre rótulos que devem corresponder para que o alerta seja suprimido. Os rótulos correspondentes consistem em três partes:
+ **Rótulo**: o nome do rótulo correspondente. Ele deve corresponder exatamente ao nome do rótulo do alerta.
+ **Operador**: o operador usado para comparar o valor do rótulo com o valor do rótulo correspondente. Os operadores disponíveis são:
+ `=` Selecione rótulos cujo valor corresponda exatamente à string fornecida.
+ `!=` Selecione rótulos cujo valor não corresponda à string fornecida.
+ `=~` Selecione rótulos cujo valor corresponda ao valor interpretado pelo regex da string fornecida (a string fornecida é interpretada como uma expressão regular).
+ `!=` Selecione rótulos que não correspondam à expressão regular fornecida.
+ **Valor**: o valor ao qual corresponder ao valor do rótulo. Pode corresponder como uma string ou como uma expressão regular, dependendo do operador escolhido.
O silêncio termina na data de término indicada, mas você pode encerrar manualmente a supressão a qualquer momento.
**Para finalizar um silêncio manualmente**
1. Na página **Alertas**, 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.
**Criar um link para o formulário de criação de silêncio**
Você pode criar uma URL para o formulário de criação de silêncio com os detalhes já preenchidos. Os operadores podem usar isso para suprimir rapidamente um alarme durante um evento operacional.
Ao criar um link para um formulário de silêncio, use um parâmetro de consulta `matchers` para especificar os rótulos correspondentes e um parâmetro de consulta `comment` para especificar um comentário. O parâmetro `matchers` requer um ou mais valores no formulário `[label][operator][value]`, separados por vírgulas.
**Exemplo de URL**
Para criar um link para um formulário de silêncio, com os rótulos correspondentes `severity=critical` e`cluster!~europe-.*`, com um comentário que diga `Silencing critical EU alerts`, use um URL como a seguir. *mygrafana*Substitua pelo nome do host da sua instância Grafana.
```
https://mygrafana/alerting/silence/new?matchers=severity%3Dcritical%2Ccluster!~europe-*&comment=Silence%20critical%20EU%20alert
```
Para vincular a uma nova página de silêncio para um Alertmanager externo, adicione um parâmetro de consulta `alertmanager` com o nome da fonte de dados Alertmanager, como `alertmanager=myAlertmanagerdatasource`.
# 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 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
O 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 em comparação com 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. |
| Funciona com o Grafana Alerting e Alertmanagers externos. | Funciona somente com Alertmanagers externos. |
**Para criar um tempo de desativação de áudio**
1. No console do Grafana, no menu do Grafana, escolha o ícone de **Alertas** (sino) para abrir a página **Alertas**.
1. Escolha **Políticas de notificação**.
1. No menu suspenso do **Alertmanager**, selecione o Alertmanager que deseja editar.
1. Na seção **Tempos de desativação de áudio**, escolha o botão **Adicionar tempo de desativação de áudio**.
1. Escolha o intervalo de tempo ao qual você deseja aplicar o tempo de desativação de áudio.
1. Escolha **Enviar** para criar um tempo de desativação de áudio.
**Para adicionar um tempo de desativação de áudio a uma política 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 o botão **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.
Escolha o botão **Salvar política**.
**Intervalos de tempo**
Um intervalo de tempo é uma definição para um período de tempo. Se um alerta for iniciado durante esse intervalo, ele será suprimido. Os períodos são compatíveis usando `:` (por exemplo, `monday:thursday`). Um tempo de desativação de áudio pode conter vários intervalos de tempo. Um intervalo de tempo consiste em vários campos (detalhes na lista a seguir), todos os quais devem coincidir para suprimir os alertas. Por exemplo, se você especificar os dias da semana `monday:friday` e o intervalo de tempo das 8h às 9h, os alertas serão suprimidos das 8h às 9h, de segunda a sexta-feira, mas não, por exemplo, das 8h às 9h no sábado.
+ **Intervalo de tempo**: a hora do dia para suprimir as notificações. Consiste em dois subcampos, **Hora de início** e **Hora de término**. Um tempo de exemplo é `14:30`. A hora está em notação de 24 horas, em UTC.
+ **Dias da semana**: os dias da semana. Pode ser um único dia, como `monday`, um período, como `monday:friday`, ou uma lista de dias separada por vírgula, como `monday, tuesday, wednesday`.
+ **Meses**: os meses a serem selecionados. Você pode especificar os meses com designações numéricas ou com o nome completo do mês, por exemplo, `1` ou `january`, ambos especificam janeiro. Você pode especificar um único mês, um intervalo de meses ou uma lista de meses separada por vírgula.
+ **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. Os dias do mês podem ser especificados como um único dia, um intervalo de dias ou uma lista de dias separada por vírgula.
+ **Anos**: o ano ou os anos do intervalo. Por exemplo, .`2023:2025`
Cada um desses elementos pode ser uma lista, e pelo menos um item no elemento deve ser satisfeito para corresponder. Portanto, se você definir anos como `2023:2025, 2027`, isso seria verdade em 2023, 2024, 2025 e 2027 (mas não em 2026).
Se um campo for deixado em branco, qualquer instante de tempo corresponderá ao campo. Um instante de tempo deve corresponder a todos os campos para corresponder a um intervalo de tempo completo.
Se você quiser especificar uma duração exata, especifique todas as opções necessárias para essa duração. Por exemplo, caso queira criar um intervalo de tempo para a primeira segunda-feira do mês, para março, junho, setembro e dezembro, entre 12h e 24h UTC, sua especificação de intervalo de tempo pode 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`
# 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 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
Os 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 raiz 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 menu do Grafana, clique no ícone de **Alertas** (sino) para abrir a página Alertas que lista os alertas existentes.
1. Clique em **Grupos de alertas** para abrir a página que lista os grupos existentes.
1. No menu suspenso **Alertmanager**, selecione um Alertmanager externo como sua fonte de dados.
1. No menu suspenso **Agrupar por personalizado**, 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`.
**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 9.x**.
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 10.x, consulte [Trabalhar no Grafana versão 10](using-grafana-v10.md).
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).
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 do Grafana, clique no ícone de **Alertas** (sino) para abrir a página Alertas que lista os alertas existentes.
1. Escolha **Pontos de contato** para ver uma lista dos pontos de contato existentes.
Se algum ponto de contato estiver falhando, uma mensagem no canto direito da tela alertará o usuário sobre o fato de que há erros e a quantidade.
1. Clique em um ponto de contato para ver 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.