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á.

# Criar e gerenciar recursos de alertas usando o Terraform
<a name="v9-alerting-setup-provision-terraform"></a>

****  
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
<a name="v9-alerting-setup-provision-tf-prerequisites"></a>
+ 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
<a name="v9-alerting-setup-provision-tf-apikey"></a>

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
<a name="v9-alerting-setup-provision-tf-configure"></a>

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 = <YOUR_GRAFANA_URL>
    auth = <YOUR_GRAFANA_API_KEY>
}
```

## Provisionar pontos de contato e modelos
<a name="v9-alerting-setup-provision-tf-contacts"></a>

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. *<slack-webhook-url>*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 = <slack-webhook-url>
           text = <<EOT
   {{ len .Alerts.Firing }} alerts are firing!
   
   Alert summaries:
   {{ range .Alerts.Firing }}
   {{ template "Alert Instance Template" . }}
   {{ end }}
   EOT
       }
   }
   ```

1. Insira texto para a notificação no campo de texto.

   O campo `text` é compatível com [modelos no estilo Go](https://pkg.go.dev/text/template). Isso possibilita que você gerencie os modelos de notificação do Grafana Alerting diretamente no Terraform.

1. Execute o comando `terraform apply`.

1. Acesse a interface de usuário do Grafana e verifique os detalhes do ponto de contato.

   Você não pode editar os recursos provisionados via 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 contato funciona corretamente.

**nota**  
Você pode reutilizar os mesmos modelos em vários pontos de contato. No exemplo acima, um modelo compartilhado é incorporado usando a instrução `{{ template "Alert Instance Template" . }}`.  
Esse fragmento pode então ser gerenciado separadamente no Terraform:  

```
resource "grafana_message_template" "my_alert_template" {
    name = "Alert Instance Template"

    template = <<EOT
{{ define "Alert Instance Template" }}
Firing: {{ .Labels.alertname }}
Silence: {{ .SilenceURL }}
{{ end }}
EOT
}
```

## Provisionar políticas de notificação e roteamento
<a name="v9-alerting-setup-provision-tf-notifications"></a>

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
<a name="v9-alerting-setup-provision-tf-mutetiming"></a>

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
<a name="v9-alerting-setup-provision-tf-rules"></a>

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 = <<EOT
   {"conditions":[{"evaluator":{"params":[0,0],"type":"gt"},"operator":{"type":"and"},"query":{"params":["A"]},"reducer":{"params":[],"type":"last"},"type":"avg"}],"datasource":{"name":"Expression","type":"__expr__","uid":"__expr__"},"expression":"A","hide":false,"intervalMs":1000,"maxDataPoints":43200,"reducer":"last","refId":"B","type":"reduce"}
   EOT
               ref_id = "B"
               relative_time_range {
                   from = 0
                   to = 0
               }
           }
   
           // Now, let's use a math expression as our threshold.
           // We want to alert when the value of stage "B" above exceeds 70.
           data {
               datasource_uid = "__expr__"
               ref_id = "C"
               relative_time_range {
                   from = 0
                   to = 0
               }
               model = jsonencode({
                   expression = "$B > 70"
                   type = "math"
                   refId = "C"
               })
           }
       }
   }
   ```

1. Acesse a interface de usuário do Grafana e verifique a regra de alerta.

   Você pode ver se a regra de alerta está disparando. Você também pode verificar uma visualização de cada um dos estágios de consulta da regra de alerta.

   Quando o alerta é disparado, o Grafana roteia uma notificação por meio da política que você definiu.

   Por exemplo, se você escolheu o Slack como ponto de contato, o [Alertmanager](https://github.com/prometheus/alertmanager) incorporado do Grafana publica automaticamente uma mensagem no Slack.