Introdução:

O Prometheus é um sistema de monitoramento e alerta de código aberto desenvolvido a partir do sistema de monitoramento BorgMon do Google. É usado principalmente para monitorar e medir vários dados de séries temporais, como desempenho do sistema, latência da rede, erros de aplicativos, etc. O Prometheus coleta dados de monitoramento e os armazena em um banco de dados de séries temporais e, em seguida, usa a linguagem de consulta PromQL para análise e visualização de dados.

A seguir estão algumas tecnologias que o Prometheus usa basicamente:

Instalação e configuração: aprenda a instalar e configurar o Prometheus, incluindo componentes como Prometheus Server, Exporters e Pushgateway.
Coleta de dados: aprenda a usar o Prometheus para coletar vários dados de monitoramento, incluindo desempenho do sistema, latência da rede, erros de aplicativos, etc.
Armazenamento de dados: saiba como o Prometheus armazena os dados de monitoramento coletados em um banco de dados de série temporal e como usar diferentes back-ends de armazenamento, como disco local e armazenamento remoto.
Consulta e análise de dados: aprenda como usar a linguagem de consulta PromQL para consultar e analisar dados de monitoramento e como exibir dados por meio de ferramentas de visualização.
Regras de Alerta: Aprenda como criar e gerenciar regras de alerta, e como enviar alertas para diferentes destinatários, como e-mail, Slack, PagerDuty, etc.
Visualização de dados: aprenda a usar a interface do painel fornecida pelo Prometheus para exibir dados de monitoramento e status de alarme e como criar seu próprio painel arrastando e soltando e personalizando a configuração.
Descoberta de serviço: aprenda a usar vários mecanismos de descoberta de serviço, como Kubernetes, EC2, GCE, etc., para descobrir e monitorar automaticamente o status de execução dos serviços.
Controle de segurança e permissão: saiba como o Prometheus fornece mecanismos de controle de segurança e permissão, como autenticação, autorização etc., para garantir a segurança do acesso aos dados.

Uso básico e compreensão da configuração:

Instalação e configuração: aprenda a instalar e configurar o Prometheus, incluindo componentes como Prometheus Server, Exporters e Pushgateway.

Servidor Prometheus

O Prometheus Server é a parte central dos componentes do Prometheus, responsável pela aquisição, armazenamento e consulta dos dados de monitoramento.

Em primeiro lugar, o Prometheus Server pode gerenciar destinos de monitoramento por meio de configuração estática e também pode usar o Service Discovery para gerenciar dinamicamente destinos de monitoramento e obter dados desses destinos de monitoramento. Isso significa que o Prometheus Server pode descobrir e monitorar vários serviços e destinos de acordo com regras predefinidas, sejam eles destinos configurados estaticamente ou destinos descobertos dinamicamente.

Em segundo lugar, o Prometheus Server precisa armazenar os dados coletados. O Prometheus Server em si é um banco de dados de séries temporais, que armazena os dados de monitoramento coletados no disco local de maneira de séries temporais. Esse método de armazenamento permite que o Prometheus Server salve efetivamente uma grande quantidade de dados de séries temporais e execute consultas e análises rápidas de dados no futuro.

Por fim, o Prometheus Server fornece uma linguagem PromQL personalizada e os usuários podem usar o PromQL para consultar e analisar dados. Ao mesmo tempo, o Prometheus Server também fornece APIs HTTP, os usuários podem usar essas APIs para consultar dados programaticamente. Além disso, o recurso de agrupamento federado do Prometheus Server permite que ele obtenha dados de outras instâncias do Prometheus Server, de modo a realizar o compartilhamento e o gerenciamento unificado dos dados de monitoramento.

Resumindo, o Prometheus Server é o componente principal do ecossistema Prometheus, responsável por coletar, armazenar e consultar dados de monitoramento, fornecendo aos usuários uma solução de monitoramento abrangente e em tempo real

exportadores

Exportadores é um componente do Prometheus responsável por expor os dados de monitoramento de um aplicativo ou serviço específico ao Prometheus. Os exportadores podem converter os dados de monitoramento do aplicativo em um formato que o Prometheus possa reconhecer e enviar os dados para o Prometheus via HTTP ou outros métodos.

A principal função dos Exportadores é expandir os recursos de monitoramento do Prometheus para que ele possa monitorar mais tipos de aplicativos e serviços. Como os formatos de dados de monitoramento de diferentes tipos de aplicativos e serviços podem ser diferentes, diferentes exportadores são obrigados a monitorá-los.

O ecossistema Prometheus fornece muitos exportadores comuns, como Node Exporter para monitorar o desempenho do sistema, Redis Exporter para monitorar o banco de dados Redis, MySQL Exporter para monitorar o banco de dados MySQL, etc. Os usuários podem escolher os exportadores apropriados para expandir os recursos de monitoramento do Prometheus de acordo com suas necessidades.

Além de usar os exportadores existentes, os usuários também podem personalizar seus próprios exportadores conforme necessário. Exportadores personalizados podem realizar a coleta e conversão de dados de monitoramento de acordo com as necessidades específicas da aplicação.

Resumindo, os Exportadores são componentes muito importantes no Prometheus.Eles ampliam os recursos de monitoramento do Prometheus, permitindo monitorar mais tipos de aplicativos e serviços. Os usuários podem optar por usar os exportadores existentes de acordo com suas necessidades ou personalizar seus próprios exportadores para monitorar aplicativos específicos.

Nesta coluna, o método de implantação dos Exportadores será atualizado.

Pushgateway

O Pushgateway é um componente do Prometheus que recebe dados de métricas de trabalhos de curta duração.

Como o Prometheus obtém principalmente os dados de monitoramento por meio do modo pull, mas alguns trabalhos de curto prazo podem não suportar a pesquisa ou os dados não podem ser extraídos diretamente pelo Prometheus devido a motivos de rede, o Pushgateway pode ser usado. Os usuários podem enviar os dados a serem monitorados para o Pushgateway escrevendo scripts personalizados e, em seguida, o Pushgateway envia os dados para o serviço Prometheus correspondente.

O Pushgateway pode ser executado independentemente em qualquer nó e não precisa ser executado no cliente monitorado. Ele pode armazenar os dados de monitoramento recebidos no disco local e oferece suporte a métodos personalizados de armazenamento de séries temporais. Ao mesmo tempo, o Pushgateway também fornece APIs HTTP, e os usuários podem usar essas APIs para enviar dados para o Pushgateway por meio de programação.

Resumindo, o Pushgateway é um componente importante do Prometheus, usado principalmente para receber dados de indicadores de trabalhos de curto prazo, o que resolve o problema de que o Prometheus não pode obter esses dados diretamente.

Saiba mais sobre a gravação do arquivo de configuração:

A escrita personalizada deve ser feita de acordo com nosso arquivo de configuração realista

Deve-se observar que, ao usar essas configurações no docker, é melhor montá-las na forma de volumes de dados de montagem.

Os arquivos de configuração do Prometheus geralmente incluem os seguintes tipos:

rule_files: Arquivo de regras, usado para configurar regras de alarme e configuração de agregação de dados.
scrape_configs: Configuração da coleta, usada para especificar a lista de destino e as regras de coleta a serem coletadas.
static_configs: Configuração estática, usada para especificar a lista de destino a ser coletada.
global: Configuração global, incluindo a configuração padrão global, como o intervalo para capturar dados de monitoramento, o período de tempo limite para capturar a interface de dados de negócios, o ciclo de execução das regras de alarme, etc.
alerting: Alert configuration, usado para configurar o endereço do Alertmanager para o qual os alertas são enviados.
remote_write e remote_read: Configuração remota de gravação e leitura, usada para postar dados ou ler dados de endereços remotos.

Os arquivos de configuração acima são todos escritos em prometheus.yml.

O seguinte descreve as funções desses arquivos de configuração:

rule_files: Este arquivo de configuração é usado para especificar a localização do arquivo de regra de alarme. Os arquivos de regras de alerta contêm condições e ações para acionar alertas. Esses arquivos de regras podem ser definidos com base em dados agregados para uma lógica de alerta mais complexa.
scrape_configs: Este arquivo de configuração é usado para especificar a lista de destino e as regras de coleta a serem coletadas. Ele contém informações como endereço de serviço, porta e tempo limite de solicitação de cada destino, bem como obter dados do destino e regras de processamento de dados, etc.
static_configs: Este arquivo de configuração é uma configuração estática, que é usada para especificar manualmente a lista de destino a ser coletada. Ao contrário de scrape_configs, a configuração aqui não pode adicionar ou remover destinos dinamicamente, portanto, é adequada para ambientes estáveis.
global: Este arquivo de configuração contém configurações padrão globais, como o intervalo para capturar dados de monitoramento, o período de tempo limite para capturar interfaces de dados de negócios e o ciclo de execução de regras de alarme. Essas configurações afetam como todo o sistema Prometheus opera.
alerting: Este arquivo de configuração é usado para especificar o endereço do Alertmanager para o qual o alerta é enviado. O Alertmanager é um componente independente para processamento e envio de informações de alerta. Ao configurar este arquivo, o Prometheus pode enviar informações de alarme para o Alertmanager para processamento.
remote_write e remote_read: Esses dois arquivos de configuração são usados para postar dados ou ler dados de endereços remotos. Isso permite que o Prometheus se integre a outros sistemas para obter recursos de análise e processamento de dados mais poderosos. Por exemplo, os dados de monitoramento coletados podem ser gravados remotamente em outros sistemas de armazenamento ou os dados podem ser lidos de um endereço remoto para posterior análise e processamento.

Deve-se observar que os arquivos de configuração do Prometheus geralmente precisam ser devidamente modificados e ajustados antes do uso para atender aos requisitos de ambientes e necessidades específicas.

Caso básico do arquivo de configuração

rule_files:

rule_files é usado para especificar a localização do arquivo de regra de alarme. Esses arquivos de regras contêm condições e ações para acionar alertas. Por exemplo, pode ser definido com base em dados agregados para lógica de alarme mais complexa.

rule_files:
  - "first_rules.yml"
  - "second_rules.yml"

A configuração acima especifica dois arquivos de regras, ou seja, "first_rules.yml" e "second_rules.yml". O Prometheus carregará esses arquivos de regras e aplicará as regras de alerta neles.

Caso específico:

Quando mencionado rule_files , refere-se ao arquivo usado para definir as regras de alerta ao usar um determinado sistema ou aplicativo. Esses arquivos geralmente usam um formato e sintaxe específicos para acionar alertas com base nas condições.

Abaixo está o conteúdo de um first_rules.yml arquivo de amostra com um exemplo de regra de alerta:

# first_rules.yml

rules:
  - name: "Example Rule"
    conditions:
      - metric: "CPU Usage"
        operator: "<"
        threshold: 80
    actions:
      - email: "[email protected]"
        subject: "High CPU Usage Alert"
        message: "The CPU usage has exceeded the threshold of 80%."

No exemplo acima, o arquivo de regras contém uma regra chamada "Example Rule". A regra define uma condição que monitora a métrica "CPU Usage" e verifica se ela é menor que um limite de 80 usando o operador "<". Se a condição for atendida, a ação correspondente será executada. Neste exemplo, a ação consiste em enviar um e-mail para o endereço de e-mail especificado com o assunto "Alerta de alto uso da CPU" e a mensagem contém detalhes sobre o alerta.

Observe que o formato e a sintaxe exatos do arquivo de regras podem variar dependendo do sistema ou aplicativo usado. Os exemplos acima são apenas para fins ilustrativos e podem precisar ser ajustados dependendo da ferramenta específica que está sendo usada.

scrape_configs:

O método 1 usa a configuração para gravar arquivos de configuração para descobrir serviços, etc.:

scrape_configs é usado para especificar a lista de destino e as regras de coleta a serem coletadas. Ele contém informações como endereço de serviço, porta e tempo limite de solicitação de cada destino, bem como obter dados do destino e regras de processamento de dados, etc.

scrape_configs:
  - job_name: 'example_app'
    scrape_interval: 5s
    static_configs:
      - targets: ['app1.example.com:8080', 'app2.example.com:8080']

A configuração acima define uma tarefa de coleta denominada "example_app" e usa configuração estática para especificar dois endereços de serviço de destino, ou seja, "app1.example.com:8080" e "app2.example.com:8080". Ao mesmo tempo, defina o intervalo de rastreamento para 5 segundos.

O método 2 usa arquivos de configuração adicionais para descobrir serviços:

scrape_configs:
  - job_name: "服务发现"
    file_sd_configs:
      - files:
        - /prometheus/ClientAll/*.json # 用json格式文件方式发现服务，下面的是用yaml格式文件方式，都可以
        refresh_interval: 10m
      - files:
        - /prometheus/ClientAll/*.yaml # 用yaml格式文件方式发现服务
        refresh_interval: 10m

Interpretação do arquivo de configuração:

Este arquivo de configuração é um fragmento do arquivo de configuração do Prometheus para configurar o Service Discovery. A descoberta de serviço é um método de detecção e rastreamento automático de serviços e seus relacionamentos no sistema, para que o Prometheus possa descobrir e monitorar automaticamente esses serviços.

Em um arquivo de configuração, scrape_configsuma matriz contendo um ou mais itens de configuração. Cada item de configuração é um dicionário contendo alguns pares chave-valor para definir uma configuração de descoberta de serviço específica.

Neste exemplo, há dois itens de configuração:

job_name: "服务发现" - Este item de configuração define o nome da tarefa de monitoramento como "Service Discovery".
file_sd_configs - O valor correspondente a esta chave é uma matriz contendo dois dicionários, cada um dos quais define um método de descoberta de serviço diferente.

a. O primeiro dicionário:

* `files` - 这个键对应的值是一个列表，其中包含一个文件路径`/prometheus/ClientAll/*.json`。这表示Prometheus将从该路径下查找所有满足正则表达式`*.json`的JSON文件。这些文件通常包含了关于服务的元数据和配置信息。
* `refresh_interval` - 这个键对应的值是一个字符串`10m`，表示每隔10分钟刷新一次服务发现配置。
* 总的来说，这个配置告诉Prometheus从指定的路径下读取JSON文件，然后根据这些文件的内容来自动发现并监控服务，并且每隔10分钟刷新一次服务发现配置。

b. O segundo dicionário:

* `files` - 这个键对应的值是一个列表，其中包含一个文件路径`/prometheus/ClientAll/*.yaml`。这表示Prometheus将从该路径下查找所有满足正则表达式`*.yaml`的YAML文件。这些文件通常也包含了关于服务的元数据和配置信息。
* `refresh_interval` - 这个键对应的值也是`10m`，表示每隔10分钟刷新一次服务发现配置。
* 总的来说，这个配置告诉Prometheus从指定的路径下读取YAML文件，然后根据这些文件的内容来自动发现并监控服务，并且每隔10分钟刷新一次服务发现配置。

Por meio dessa configuração, o Prometheus pode descobrir e monitorar serviços automaticamente de acordo com diferentes formatos de arquivo (JSON ou YAML) e informações de descrição do serviço. Isso é útil para ambientes dinâmicos ou serviços que precisam escalar automaticamente, pois quando um serviço muda, o Prometheus pode atualizar automaticamente sua configuração de monitoramento e começar a monitorar o novo serviço

static_configs:

static_configs é uma configuração estática usada para especificar manualmente a lista de destinos a serem coletados. Ao contrário de scrape_configs, a configuração aqui não pode adicionar ou remover destinos dinamicamente, portanto, é adequada para ambientes estáveis.

static_configs:
  - targets: ['target1.example.com:8080']

A configuração acima especifica manualmente um endereço de serviço de destino como "target1.example.com:8080" e os destinos não podem ser adicionados ou excluídos dinamicamente.

global:

global contém configurações padrão globais, como o intervalo para capturar dados de monitoramento, o período de tempo limite para capturar interfaces de dados de negócios e o ciclo de execução de regras de alarme. Essas configurações afetam como todo o sistema Prometheus opera.

global:
  scrape_interval: 10s
  evaluation_interval: 10s

A configuração acima define o intervalo de captura global para 10 segundos e o ciclo de execução da regra de alarme para 10 segundos.

alerta:

Ao usar isso, prepare e instale o componente alertmanager com antecedência

fingir estar conectado

alerting é usado para especificar o endereço do Alertmanager para o qual o alerta é enviado. O Alertmanager é um componente independente para processamento e envio de informações de alerta. Ao configurar este arquivo, o Prometheus pode enviar informações de alarme para o Alertmanager para processamento.

alerting:
  alertmanagers:
    - static_configs:
        - targets: ['alertmanager1.example.com:9093']

A configuração acima especifica que o endereço do Alertmanager para o qual os alertas são enviados é "alertmanager1.example.com:9093".

Vendo que alguns camaradas aqui vão ter dúvidas?

Estou usando Prometheus+Grafana, então quem devo usar para me enviar alertas?

eu li por um tempo

O Grafana nessas duas combinações é uma plataforma de visualização que não tem capacidade de enviar alertas, portanto o Prometheus só pode enviar alertas.

O Alertmanager é um componente independente para processamento e envio de informações de alerta. No Prometheus, o Alertmanager é usado para receber as informações de alarme enviadas pelo Prometheus e, em seguida, processar as informações, como rotear as informações de alarme para diferentes receptores, silenciar ou suprimir o alarme e, finalmente, enviar as informações de alarme para o receptor.

No arquivo de configuração, alertinga seção é usada para especificar o endereço do Alertmanager para o qual os alertas são enviados. A configuração acima alerting: alertmanagers: - static_configs: - targets: ['alertmanager1.example.com:9093']especifica que o endereço do Alertmanager para o qual os alertas são enviados é "alertmanager1.example.com:9093".

Nesta configuração, alertmanagersé uma lista onde cada elemento contém uma static_configsseção. static_configsÉ um dicionário, o valor correspondente à targetschave é uma lista, incluindo o endereço do Alertmanager. Neste exemplo, há apenas um endereço 'alertmanager1.example.com:9093'.

Por meio dessa configuração, o Prometheus pode enviar as informações de alarme para o Alertmanager especificado para processamento.

Um caso de alarme de uso do Alertmanager como um componente independente para enviar e-mails e DingTalk

Alertmanager fornece uma maneira de configurar o receptor de notificação (receptor) para receber informações de alerta. Um receptor de notificação define um conjunto de ações relacionadas a alertas, como envio de e-mails, envio de mensagens SMS, armazenamento de informações de alerta em um sistema e assim por diante. Ao configurar coletores de notificação, você pode especificar ações que devem ser executadas quando o Prometheus acionar um alerta.

O seguinte é parte de um exemplo de arquivo de configuração do Alertmanager que configura um receptor de notificação que envia e-mails:

global:
  smtp_smarthost: 'smtp.example.com:587'
  smtp_from: '[email protected]'
  smtp_auth_username: 'alertmanager'
  smtp_auth_password: 'password'
  smtp_require_tls: false

receivers:
- name: 'email'
  email_configs:
  - to: '[email protected]'
    from: '[email protected]'
    subject: '[Alertmanager] Alerts for {
   
   { .接收器的名字 }}'
    smtp_auth:
      username: 'alertmanager'
      password: 'password'
    smtp_smarthost: 'smtp.example.com:587'
    require_tls: false

Nesta configuração, definimos um receptor de notificação chamado "email" e especificamos uma configuração para enviar e-mails. Você pode modificar esta configuração de acordo com suas necessidades, como modificar o destinatário, remetente, assunto, etc. do e-mail.

Então, você precisa especificar este receptor de notificação no arquivo de configuração do Alertmanager. O seguinte é parte de um arquivo de configuração do Alertmanager de amostra:

route:
  receiver: 'email'

Nesta configuração, especificamos que quando o Alertmanager recebe mensagens de alerta, elas devem ser enviadas para um receptor de notificação chamado "email".

Por fim, você precisa implantar o arquivo de configuração do Alertmanager no servidor onde o Alertmanager está localizado e garantir que o Alertmanager possa ler e carregar esse arquivo de configuração. Então, quando o Prometheus acionar um alarme, o Alertmanager enviará uma notificação por e-mail correspondente de acordo com a configuração.

Existe uma associação entre Alertmanager e rule_files

Alertmanager é um componente para gerenciar e enviar informações de alerta e rule_files é um arquivo para configurar regras de alerta.

No Prometheus, as regras de alerta são definidas com base em expressões na linguagem de expressão do Prometheus, que são usadas para detectar condições específicas e acionar alertas. Essas regras são armazenadas em rule_files. O Alertmanager corresponde e subsequentemente processa as informações de alerta enviadas pelo Prometheus lendo as regras em rule_files.

O arquivo de configuração do Alertmanager pode especificar vários rule_files e cada arquivo contém um conjunto de regras de alerta. Ao associar esses arquivos de regras com os arquivos de configuração do Alertmanager, o processamento e a notificação de informações de alarme podem ser realizados.

Aqui está a seção relevante de um exemplo de arquivo de configuração do Alertmanager especificando o caminho para rule_files:

global:
  # rule_files字段指定了告警规则文件的路径
  rule_files:
  - 'rules/basic_rules.yml'
  - 'rules/complex_rules.yml'

Nesta configuração, especificamos dois arquivos de regras: basic_rules.yml e complex_rules.yml. O Alertmanager lerá as regras de alerta nesses dois arquivos e executará o processamento de correspondência e acompanhamento nas informações de alerta recebidas de acordo com essas regras.

Ao configurar rule_files, você pode definir e gerenciar regras de alerta de acordo com suas necessidades e associar essas regras ao arquivo de configuração do Alertmanager para executar as ações correspondentes quando o Prometheus acionar um alerta.

Como especificar quais rule_files desejo usar nesses avisos

No arquivo de configuração do Alertmanager, rule_fileso arquivo de regra de alerta a ser usado pode ser selecionado especificando um campo. rule_filesO campo aceita uma lista de sequências, cada uma representando o caminho para um arquivo de regras. Os campos podem ser incluídos ou modificados no arquivo de configuração rule_filespara especificar qual arquivo de regras usar.

A seguir, parte de um arquivo de configuração do Alertmanager de amostra que mostra como especificar o arquivo de regras a ser usado:

global:
  # rule_files字段指定了告警规则文件的路径
  rule_files:
  - 'path/to/rule_file_1.yml'
  - 'path/to/rule_file_2.yml'

route:
  # route字段指定了告警处理和通知的路由规则
  receiver: 'ReceiverName'

Neste exemplo, especificamos dois arquivos de regra: 'path/to/rule_file_1.yml' e 'path/to/rule_file_2.yml'. O Alertmanager rule_fileslerá esses arquivos de regras na ordem definida neles. Você pode modificar ou adicionar mais arquivos de regras conforme necessário, basta adicionar seus caminhos à rule_fileslista.

Certifique-se de que, após modificar o arquivo de configuração do Alertmanager, implante-o no servidor onde o Alertmanager está localizado e certifique-se de que o Alertmanager possa ler e carregar esse arquivo de configuração. Dessa forma, quando o Prometheus acionar um alarme, o Alertmanager irá compará-lo e processá-lo de acordo com o arquivo de regras especificado.

O caso de uso do Alertmanager para alertas

Ao usar o Alertmanager para enviar alertas, você pode implementar regras de alerta para situações específicas configurando rule_files. O exemplo a seguir mostra como usar Alertmanager e rule_files para enviar alertas, incluindo o envio de informações de alerta para DingTalk e e-mail.

Primeiro, certifique-se de que o Alertmanager e o Prometheus foram instalados e configurados e que os receptores para envio de DingTalk e e-mails foram criados.

Crie um arquivo de regras:

Crie um rules/alerting_rules.ymlarquivo de regras chamado com o seguinte conteúdo:

groups:
- name: alerting_rules
  interval: 1m
  rules:
    - alert: AlertName
      expr: some_metric > 100
      for: 1m
      labels:
        severity: high
      annotations:
        summary: High value detected
        description: An alert has been triggered for the 'some_metric' metric exceeding 100.

Neste arquivo de regras, definimos uma AlertNameregra de alerta chamada , que utiliza uma expressão some_metric > 100para detectar valores acima de 100. O alarme será acionado quando o indicador exceder 100 por 1 minuto. Definimos as severity: highinformações do rótulo e do comentário summarye para o alerta description.

Configure o receptor do Alertmanager:

De acordo com suas necessidades, configure o receptor do Alertmanager para receber e processar informações de alerta. Por exemplo, se você usar o DingTalk como receptor, defina-o de acordo com a configuração do receptor DingTalk. Se você usar e-mail como destinatário, siga a configuração do destinatário de e-mail. Certifique-se de que o receptor esteja configurado corretamente e ativado.

A seguir está a seção relevante de um exemplo de arquivo de configuração do Alertmanager (alertmanager.yml) para especificar os destinatários do DingTalk:

global:
  # 其他配置项...

receivers:
- name: 'DingTalkReceiver'
  dingtalk_config:
     webhook_url: 'https://oapi.dingtalk.com/robot/send?access_token=your_access_token'
     send_resolved: true
  route:
    receiver: 'DingTalkReceiver'

Neste exemplo, criamos um DingTalkReceiverreceptor chamado e configuramos as informações relacionadas ao DingTalk, incluindo a URL do webhook e o envio de alertas resolvidos. Também especificamos este receptor como o receptor padrão ( receiver: 'DingTalkReceiver').

Configure as regras de alerta do Prometheus:

No Prometheus, você precisa importar as regras de alerta no arquivo de regras para o Prometheus. Importe o arquivo de regras para o Prometheus com o seguinte comando:

kubectl apply -f rules/alerting_rules.yml

Inicie o Alertmanager e o Prometheus:

Inicie os serviços Alertmanager e Prometheus e verifique se eles estão em execução. Você pode iniciar o Alertmanager com o seguinte comando:

kubectl apply -f alertmanager.yml

Acionar um alerta:

Para acionar um alerta, você pode acionar manualmente uma condição que satisfaça uma regra de alerta. No Prometheus, você pode usar pushgatewaypara simular dados e acionar regras de alerta. Por exemplo, use o seguinte comando para enviar dados fictícios para pushgateway:

curl -X POST -H "Content-Type: application/json" --data '{"some_metric": 200}' http://<pushgateway_address>:<pushgateway_port>/metrics/job/alerting_rules/instance/prometheus-k8s-01/prometheus-k8s-01/default/alerting_rules/DingTalkReceiver/alertname/AlertName/severity/high/summary/High value detected/description/An alert has been triggered for the 'some_metric' metric exceeding 100. --header "Content-Type: application/json"

Exibir informações de alarme:

Assim que a condição da regra de alerta for atendida, P·1·1·1·1·1rometheus enviará as informações de alerta ao Alertmanager. O Alertmanager enviará informações de alerta de acordo com os destinatários configurados. Neste exemplo, receberemos informações de alarme através do DingTalk. Você pode visualizar as informações de alarme recebidas no DingTalk.

O acima é um exemplo simples que mostra como usar Alertmanager e rule_files para enviar informações de alerta para DingTalk e e-mail. Você pode fazer ajustes e configurações correspondentes de acordo com as necessidades reais.

Nesta coluna, haverá um artigo explicativo sobre o componente Alertmanager.

remote_write e remote_read:

remote_write e remote_read são usados para postar dados ou ler dados de um endereço remoto. Isso permite que o Prometheus se integre a outros sistemas para obter recursos de análise e processamento de dados mais poderosos. Por exemplo, os dados de monitoramento coletados podem ser gravados remotamente em outros sistemas de armazenamento ou os dados podem ser lidos de um endereço remoto para posterior análise e processamento.

remote_write:
  - url: "http://remote-write-url"
    write_relabel_configs:
      - source_labels: ['__address__']
        regex: '^localhost:(.*)$'
        target_label: '__address__'
        replacement: '${1}'
  - url: "https://another-remote-write-url"
    ...
remote_read:
  - url: "http://remote-read-url"
    params: {'match[]': 'some_metric'}
  - url: "https://another-remote-read-url"
    ...

A configuração acima usa remote_write para gravar remotamente os dados de monitoramento coletados em dois endereços diferentes e usa write_relabel_configs para reescrever o endereço de destino. Ao mesmo tempo, use remote_read para ler dados de dois endereços remotos diferentes e especifique o nome do índice correspondente.

Caso pessoal:

Resumo:

Ao usá-lo, você precisa especificar o caminho do arquivo de configuração

global:
  scrape_interval: 15s # 设置抓取间隔为每15秒。
  evaluation_interval: 15s # 每隔15秒评估规则。

rule_files:
  - /prometheus/rules/*.yml # 这里匹配指定目录下所有的.rules文件

scrape_configs:
  - job_name: "阿丹服务器" #使用配置来发现服务
    static_configs:
      - targets: ['ip:9090']
        labels:
          instance: prometheus
  - job_name: "服务发现"
    file_sd_configs:
      - files:
        - /prometheus/ClientAll/*.json # 用json格式文件方式发现服务，下面的是用yaml格式文件方式，都可以
        refresh_interval: 10m
      - files:
        - /prometheus/ClientAll/*.yaml # 用yaml格式文件方式发现服务
        refresh_interval: 10m

Documentação técnica do Prometheus - uso básico - solução completa do arquivo de configuração! ! ! ! !