

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

# Personalizar notificações
<a name="v10-alerting-manage-notifications"></a>

****  
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 10.x**.  
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.md).  
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).

Personalize suas notificações com modelos de notificações.

Você pode usar modelos de notificação para alterar o título, a mensagem e o formato da mensagem em suas notificações.

Os modelos de notificação não estão vinculados a integrações específicas de pontos de contato, como o Amazon SNS ou Slack. Porém, você pode optar por criar modelos de notificação separados para diferentes integrações de pontos de contato.

Você pode usar modelos de notificação para:
+ Adicionar, remover ou reordenar informações na notificação, incluindo o resumo, a descrição, os rótulos e anotações, os valores e os links
+ Formatar texto em negrito e itálico e adicionar ou remover quebras de linha

Você não pode não usar modelos de notificação para:
+ Alterar o design das notificações em serviços de mensagens instantâneas, como o Slack e o Microsoft Teams

**Topics**
+ [Usar a linguagem de modelos do Go](v10-alerting-notifications-go-templating.md)
+ [Criar modelos de notificações](v10-alerting-create-templates.md)
+ [Usar modelos de notificações](#v10-alerting-use-notification-templates)
+ [Referência do modelo](v10-alerting-template-reference.md)

# Usar a linguagem de modelos do Go
<a name="v10-alerting-notifications-go-templating"></a>

****  
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 10.x**.  
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.md).  
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).

Você escreve modelos de notificação na linguagem de modelos do Go, [texto/modelo](https://pkg.go.dev/text/template).

Esta seção fornece uma visão geral da linguagem de modelos e dos modelos de escrita do Go em texto/modelo.

## Ponto
<a name="v10-go-dot"></a>

 text/template Há um cursor especial chamado ponto e é escrito como`.`. Você pode pensar nesse cursor como uma variável cujo valor muda dependendo de onde ele é usado no modelo. Por exemplo, no início de um modelo de notificação, `.` refere-se ao objeto `ExtendedData`, que contém vários campos, incluindo `Alerts`, `Status`, `GroupLabels`, `CommonLabels`, `CommonAnnotations` e `ExternalURL`. No entanto, ponto pode se referir a outra coisa quando usado em um `range` em uma lista, quando usado dentro de um `with` ou ao escrever modelos de recursos para serem usados em outros modelos. Você pode ver exemplos disso em [Criar modelos de notificações](v10-alerting-create-templates.md), e todos os dados e funções na [Referência do modelo](v10-alerting-template-reference.md).

## Tags de abertura e fechamento
<a name="v10-go-openclosetags"></a>

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)
<a name="v10-go-print"></a>

Para imprimir o valor de algo, use `{{` e `}}`. Você pode imprimir o valor do ponto, um campo do ponto, o resultado de uma função e o valor de uma [variável](#v10-go-variables). Por exemplo, para imprimir o campo `Alerts` em que o ponto se refere a `ExtendedData`, você escreve o seguinte:

```
{{ .Alerts }}
```

## Iterar em alertas
<a name="v10-go-iterate-alerts"></a>

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
<a name="v10-go-iterate-labels"></a>

Vamos escrever um modelo para imprimir os rótulos de cada alerta no formato `The name of the label is $name, and the value is $value`, em que `$name` e `$value` contêm o nome e o valor de cada rótulo.

Como no exemplo anterior, use um intervalo para iterar nos alertas em `.Alerts` de forma que o ponto se refira ao alerta atual na lista de alertas e, em seguida, use um segundo intervalo nos rótulos classificados para que o ponto seja atualizado uma segunda vez para se referir ao rótulo atual. Dentro do segundo intervalo, use `.Name` e `.Value` para imprimir o nome e o valor de cada rótulo:

```
{{ range .Alerts }}
{{ range .Labels.SortedPairs }}
The name of the label is {{ .Name }}, and the value is {{ .Value }}
{{ end }}
{{ range .Annotations.SortedPairs }}
The name of the annotation is {{ .Name }}, and the value is {{ .Value }}
{{ end }}
{{ end }}
```

## As funções de índice
<a name="v10-go-index"></a>

Para imprimir uma anotação ou rótulo específico, use a função `index`.

```
{{ range .Alerts }}
The name of the alert is {{ index .Labels "alertname" }}
{{ end }}
```

## Instruções If
<a name="v10-go-if"></a>

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
<a name="v10-go-with"></a>

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
<a name="v10-go-variables"></a>

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
<a name="v10-go-rangeindex"></a>

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
<a name="v10-go-define"></a>

Você pode definir modelos que podem ser usados em outros modelos, usando `define` e o nome do modelo entre aspas duplas. Você não deve definir modelos com o mesmo nome de outros modelos, incluindo modelos padrão, como `__subject`, `__text_values_list`, `__text_alert_list`, `default.title` e `default.message`. Quando um modelo foi criado com o mesmo nome de um modelo padrão, ou um modelo em outro modelo de notificação, o Grafana pode usar qualquer um dos modelos. O Grafana não impossibilita nem mostra uma mensagem de erro quando há dois ou mais modelos com o mesmo nome.

```
{{ define "print_labels" }}
{{ end }}
```

## Executar modelos
<a name="v10-go-execute"></a>

Você pode executar um modelo definido no seu modelo usando `template`, o nome do modelo entre aspas duplas e o cursor que deve ser passado para o modelo:

```
{{ template "print_labels" . }}
```

## Passar dados para modelos
<a name="v10-go-passdata"></a>

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
<a name="v10-go-comments"></a>

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
<a name="v10-go-indentation"></a>

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
<a name="v10-go-removespace"></a>

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
<a name="v10-alerting-create-templates"></a>

****  
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 10.x**.  
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.md).  
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).

Crie modelos de notificação reutilizáveis para enviar aos pontos de contato.

Você pode adicionar um ou mais modelos ao modelo de notificação.

O nome do modelo de notificação deve ser exclusivo. Você não pode ter dois modelos com o mesmo nome no mesmo modelo de notificação ou em modelos de notificação diferentes. Evite definir modelos com o mesmo nome dos modelos padrão, como: `__subject`, `__text_values_list`, `__text_alert_list`, `default.title` e `default.message`.

Na guia Pontos de contato, você pode ver uma lista dos modelos de notificação.

## Criar modelos de notificação
<a name="v10-alerting-creating-templates"></a>

**Para criar um modelo de notificação**

1. Escolha **Alertas**, **Pontos de contato**.

1. Escolha a guia **Modelos de notificação** e, em seguida, **\$1 Adicionar modelo de notificação**.

1. Escolha um nome para o modelo de notificação, como `email.subject`.

1. Escreva o conteúdo do modelo no campo de conteúdo.

   Por exemplo:

   ```
   {{ if .Alerts.Firing -}}
      {{ len .Alerts.Firing }} firing alerts
      {{ end }}
      {{ if .Alerts.Resolved -}}
      {{ len .Alerts.Resolved }} resolved alerts
      {{ end }}
   ```

1. Salve as alterações.

   `{{ define "email.subject" }}` (em que `email.subject` é o nome do seu modelo) e `{{ end }}` é automaticamente adicionado ao início e ao final do conteúdo.

**Para criar um modelo de notificação que contenha mais de um modelo**

1. Escolha **Alertas**, **Pontos de contato**.

1. Escolha a guia **Modelos de notificação** e, em seguida, **\$1 Adicionar modelo de notificação**.

1. Insira um nome para o modelo geral de notificação. Por exemplo, .`email`

1. Escreva cada modelo no campo Conteúdo, incluindo `{{ define "name-of-template" }}` e `{{ end }}` no início e no final de cada modelo. Você pode usar nomes descritivos para cada um dos modelos no modelo de notificação, por exemplo, `email.subject` ou `email.message`. Nesse caso, não reutilize o nome do modelo de notificação inserido acima.

   As seções posteriores mostram exemplos detalhados de modelos que você pode criar.

1. Clique em Salvar.

## Pré-visualização dos modelos de notificações
<a name="v10-alerting-preview-templates"></a>

Pré-visualize seus modelos de notificação antes de usá-los nos pontos de contato, ajudando você a entender o resultado do modelo que está criando e dando a chance de corrigir quaisquer erros antes de salvá-lo.

**nota**  
As pré-visualizações de notificações estão disponíveis apenas para o Grafana Alertmanager.

**Para pré-visualizar os modelos de notificação**

1. Escolha **Alertas**, **Pontos de contato**.

1. Escolha a guia **Modelos de notificação** e, em seguida, **\$1 Adicionar modelo de notificação**, ou edite um modelo existente.

1. Adicione ou atualize o conteúdo do modelo.

   Os dados padrão são fornecidos e você pode adicionar ou editar dados de alerta a eles, bem como às instâncias de alerta. Você pode adicionar dados de alerta diretamente na própria janela de dados da carga útil ou clicar em **Selecionar instâncias de alerta** ou **Adicionar alertas personalizados**.

1. [Opcional] Para adicionar dados de alerta de instâncias de alerta existentes:

   1. Escolha **Selecionar instâncias de alerta**.

   1. Passe o mouse sobre as instâncias de alerta para ver mais informações sobre cada instância de alerta.

   1. Escolha **Confirmar** para adicionar a instância de alerta à carga útil.

1. [Opcional] Para adicionar dados de alerta usando o editor de dados de alertas, escolha **Adicionar dados personalizados**:

   1. Adicione anotações, rótulos personalizados ou defina um dashboard ou painel.

   1. Alterne entre Disparado ou Resolvido, dependendo se você deseja adicionar alertas disparados ou resolvidos à sua notificação.

   1. Escolha **Adicionar dados de alertas**.

   1. Escolha **Atualizar pré-visualização** para ver como ficará o conteúdo do seu modelo e os dados de carga útil correspondentes.

   Se houver algum erro em seu modelo, ele será exibido na pré-visualização e você poderá corrigi-lo antes de salvá-lo.

1. Salve as alterações.

## Criar um modelo para o assunto da mensagem
<a name="v10-alerting-create-template-subject"></a>

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
<a name="v10-alerting-create-template-message"></a>

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
<a name="v10-alerting-create-template-slack-title"></a>

Crie um modelo para o título de uma mensagem do Slack que contenha o número de alertas disparados e resolvidos, como no seguinte exemplo:

```
1 firing alerts, 0 resolved alerts
```

**Para criar um modelo para o título de uma mensagem do Slack**

1. Crie um arquivo denominado `slack.title` com o seguinte conteúdo:

   ```
   {{ define "slack.title" }}
   {{ len .Alerts.Firing }} firing alerts, {{ len .Alerts.Resolved }} resolved alerts
   {{ end }}
   ```

1. Execute o modelo no campo de título na integração do ponto de contato.

   ```
   {{ template "slack.title" . }}
   ```

## Criar um modelo para o conteúdo de uma mensagem do Slack
<a name="v10-alerting-create-template-slack-message"></a>

Crie um modelo para o conteúdo de uma mensagem do Slack que contenha uma descrição de todos os alertas disparados e resolvidos, incluindo seus rótulos, anotações e URL do dashboard.

**nota**  
Este modelo é apenas para alertas gerenciados pelo Grafana. Para usar o modelo para alertas gerenciados pela fonte de dados, exclua as referências a DashboardURL e SilenceURL. Para obter mais informações sobre como configurar as notificações do Prometheus, consulte a [documentação do Prometheus sobre notificações](https://prometheus.io/docs/alerting/latest/notifications/).

```
1 firing alerts:

[firing] Test1
Labels:
- alertname: Test1
- grafana_folder: GrafanaCloud
Annotations:
- description: This is a test alert
Go to dashboard: https://example.com/d/dlhdLqF4z?orgId=1

1 resolved alerts:

[firing] Test2
Labels:
- alertname: Test2
- grafana_folder: GrafanaCloud
Annotations:
- description: This is another test alert
Go to dashboard: https://example.com/d/dlhdLqF4z?orgId=1
```

**Para criar um modelo para o conteúdo de uma mensagem do Slack**

1. Crie um modelo denominado `slack` com dois modelos no conteúdo: `slack.print_alert` e `slack.message`.

   O modelo `slack.print_alert` é usado para imprimir os rótulos, as anotações e o DashboardURL, enquanto o modelo `slack.message` contém a estrutura da notificação.

   ```
   {{ define "slack.print_alert" -}}
   [{{.Status}}] {{ .Labels.alertname }}
   Labels:
   {{ range .Labels.SortedPairs -}}
   - {{ .Name }}: {{ .Value }}
   {{ end -}}
   {{ if .Annotations -}}
   Annotations:
   {{ range .Annotations.SortedPairs -}}
   - {{ .Name }}: {{ .Value }}
   {{ end -}}
   {{ end -}}
   {{ if .DashboardURL -}}
     Go to dashboard: {{ .DashboardURL }}
   {{- end }}
   {{- end }}
   
   {{ define "slack.message" -}}
   {{ if .Alerts.Firing -}}
   {{ len .Alerts.Firing }} firing alerts:
   {{ range .Alerts.Firing }}
   {{ template "slack.print_alert" . }}
   {{ end -}}
   {{ end }}
   {{ if .Alerts.Resolved -}}
   {{ len .Alerts.Resolved }} resolved alerts:
   {{ range .Alerts.Resolved }}
   {{ template "slack.print_alert" .}}
   {{ end -}}
   {{ end }}
   {{- end }}
   ```

1. Execute o modelo no campo do corpo do texto na integração do ponto de contato:

   ```
   {{ template "slack.message" . }}
   ```

## Criar modelos para o e-mail e Slack com modelos compartilhados
<a name="v10-alerting-create-shared-templates"></a>

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
<a name="v10-alerting-use-notification-templates"></a>

Use modelos em pontos de contato para personalizar as notificações.

**Para usar um modelo ao criar um ponto de contato**

1. No menu **Alertas**, escolha a guia **Pontos de contato** para ver uma lista dos pontos de contato existentes.

1. Escolha **Novo**. Como alternativa, você pode editar um ponto de contato existente escolhendo o ícone de **Editar**.

1. Insira os modelos que você deseja usar em um campo, como **Mensagem** ou **Assunto**. Para inserir um modelo, use o formulário`{{ template "template_name" . }}`, *template\$1name* substituindo-o pelo nome do modelo que você deseja usar.

1. Escolha **Salvar ponto de contato**.

# Referência do modelo
<a name="v10-alerting-template-reference"></a>

****  
Este tópico de documentação foi desenvolvido para espaços de trabalho do Grafana compatíveis com o **Grafana versão 10.x**.  
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 9.x, consulte [Trabalhar no Grafana versão 9](using-grafana-v9.md).  
Para espaços de trabalho do Grafana compatíveis com o Grafana versão 8.x, consulte [Trabalhar no Grafana versão 8](using-grafana-v8.md).

Esta seção fornece informações de referência para criar os modelos.

**Alerta (tipo)**

O tipo de alerta contém os dados a seguir.


| Nome | Tipo | Description | Exemplo | 
| --- | --- | --- | --- | 
|  Status  |  string  |  `firing` ou `resolved`.  | \$1\$1 .Status \$1\$1 | 
|  Rótulos  |  KeyValue  |  Um conjunto de rótulos anexados ao alerta.  | \$1\$1 .Labels \$1\$1 | 
|  Anotações  |  KeyValue  |  Um conjunto de anotações anexadas ao alerta.  | \$1\$1 .Annotations \$1\$1 | 
| Valores | KeyValue | Os valores de todas as expressões, incluindo as condições clássicas | \$1\$1 .Values \$1\$1 | 
|  StartsAt  |  time.Time  |  Hora em que o alerta começou a disparar.  | \$1\$1 .StartsAt \$1\$1 | 
|  EndsAt  |  time.Time  |  Definido somente se a hora de término de um alerta for conhecida. Caso contrário, defina um período de tempo limite configurável a partir do momento em que o último alerta foi recebido.  | \$1\$1 .EndsAt \$1\$1 | 
|  GeneratorURL  |  string  |  Um link de retorno para o Grafana ou para o Alertmanager externo.  | \$1\$1 .GeneratorURL \$1\$1 | 
|  SilenceURL  |  string  |  Um link para silenciar o alerta (com rótulos para esse alerta pré-preenchidos). Somente para alertas gerenciados pelo Grafana.  | \$1\$1 .SilenceURL\$1\$1 | 
|  DashboardURL  |  string  |  Link para o dashboard do Grafana, se a regra de alerta pertencer a um. Somente para alertas gerenciados pelo Grafana.  | \$1\$1 .DashboardURL \$1\$1 | 
|  PanelURL  |  string  |  Link para o painel do dashboard do Grafana, se a regra de alerta pertencer a um. Somente para alertas gerenciados pelo Grafana.  | \$1\$1 .PanelURL \$1\$1 | 
|  Impressão digital  |  string  |  Impressão digital que pode ser usada para identificar o alerta.  | \$1\$1 .Fingerprint \$1\$1 | 
|  ValueString  |  string  |  Uma string que contém os rótulos e o valor de cada expressão reduzida no alerta.  | \$1\$1 .ValueString \$1\$1 | 

 **ExtendedData**

O ExtendedData objeto contém as seguintes propriedades.


| Nome | Tipo | Description | Exemplo | 
| --- | --- | --- | --- | 
|  Receptor  |  `string`  |  O nome do ponto de contato que envia a notificação.  |  `{{ .Receiver }}`  | 
|  Status  |  `string`  |  O status será `firing` se pelo menos um alerta estiver sendo disparado, do contrário, `resolved`.  |  `{{ .Status }}`  | 
|  Alertas  |  `[]Alert`  |  Lista de todos os alertas disparados e resolvidos nesta notificação.  |  `There are {{ len .Alerts }} alerts`  | 
|  Alertas disparados  |  `[]Alert`  |  Lista de todos os alertas disparados nesta notificação.  |  `There are {{ len .Alerts.Firing }} firing alerts`  | 
|  Alertas resolvidos  |  `[]Alert`  |  Lista de todos os alertas resolvidos nesta notificação.  |  `There are {{ len .Alerts.Resolved }} resolved alerts`  | 
|  GroupLabels  |  `KeyValue`  |  Os rótulos que agrupam esses alertas nesta notificação.  |  `{{ .GroupLabels }}`  | 
|  CommonLabels  |  `KeyValue`  |  Os rótulos comuns a todos os alertas nesta notificação.  |  `{{ .CommonLabels }}`  | 
|  CommonAnnotations  |  `KeyValue`  |  As anotações comuns a todos os alertas nesta notificação.  |  `{{ .CommonAnnotations }}`  | 
|  ExternalURL  |  `string`  |  Um link para o espaço de trabalho do Grafana ou para o Alertmanager que enviou esta notificação.  |  `{{ .ExternalURL }}`  | 

**KeyValue tipo**

O `KeyValue` tipo é um conjunto de pares de key/value strings que representam rótulos e anotações.

Além do acesso direto aos dados armazenados como um `KeyValue`, também existem métodos para classificar, remover e transformar os dados.


| Nome | Argumentos | Retornos | Observações | Exemplo | 
| --- | --- | --- | --- | --- | 
|  SortedPairs  |    |  Lista ordenada de pares de strings de chave e valor  |    | `{{ .Annotations.SortedPairs }}` | 
|  Remover  |  []string  |  KeyValue  |  Retorna uma cópia do Key/Value mapa sem as chaves fornecidas.  | `{{ .Annotations.Remove "summary" }}` | 
|  Nomes  |    |  []string  |  Lista de nomes  | `{{ .Names }}` | 
|  Valores  |    |  []string  |  Lista de valores  | `{{ .Values }}` | 

**Tempo**

A hora vem do pacote [https://pkg.go.dev/time#Time](https://pkg.go.dev/time#Time) do Go. Você pode imprimir uma hora em vários formatos diferentes. Por exemplo, para imprimir a hora em que um alerta foi disparado no formato `Monday, 1st January 2022 at 10:00AM`, você escreve o seguinte modelo:

```
{{ .StartsAt.Format "Monday, 2 January 2006 at 3:04PM" }}
```

Você pode encontrar uma referência para o formato de hora do Go [aqui](https://pkg.go.dev/time#pkg-constants).