Skip to content

Latest commit

 

History

History
732 lines (497 loc) · 24.6 KB

README.pt.md

File metadata and controls

732 lines (497 loc) · 24.6 KB
Raw

Create ReleaseGenerate HTMLSlack Notification

ContributorsForksStargazersIssuesMIT LicenseLinkedIn


observability

Learning Observability

Project for learning about Learning Observability.
Explore the docs »

Project Page - Report Bug - Request Feature

Table of Contents
  1. About The Project
  2. Getting Started
  3. Usage
  4. Roadmap
  5. Contributing
  6. License
  7. Contact
  8. Acknowledgments

Sobre o projeto

Este projeto é para aprender sobre Observabilidade.

(back to top)

Construído com

  • Github
  • GNULinux
  • Windows
  • Bash
  • Powershell
  • Kubernetes

(back to top)

Começando

Este projeto é para começar a usar ferramentas e práticas recomendadas de Observabilidade de Aprendizagem.

Algumas ferramentas para aprender:

  • Prometeu
  • Gerenciador de alertas
  • Grafana
  • Grafana Loki
  • Grafana Tempo

Pré-requisitos

  • Sistema Linux ativado
  • Cluster Kubernetes em alta
  • Git

Instalação

Clonar o repositório

git clone https://github.com/marcossilvestrini/learning-observability.git
cd learning-observability || exit

(back to top)

Uso

Publico alguns exemplos para uso neste repositório.

(back to top)

Roteiro

  • Criar repositório
  • Prometeu
  • Gerenciador de alertas
  • Grafana
  • Grafana Loki
  • Grafana Tempo
  • Liga Grafana
  • Outras ferramentas

Veja oquestões em abertopara obter uma lista completa dos recursos propostos (e problemas conhecidos).

(back to top)

Prometeu

prometheus

Prometheus é um kit de ferramentas de alerta e monitoramento de sistemas de código aberto originalmente desenvolvido no SoundCloud.

Desde a sua criação em 2012, muitas empresas e organizações adotaram o Prometheus, e o projeto tem uma comunidade de desenvolvedores e usuários muito ativa.

O ecossistema Prometheus consiste em vários componentes, muitos dos quais são opcionais:

  • o principal servidor Prometheus que coleta e armazena dados de séries temporais
  • bibliotecas de cliente para instrumentação de código de aplicativo
  • um gateway push para apoiar empregos de curta duração
  • exportadores para fins especiais de serviços como HAProxy, StatsD, Graphite, etc.
  • um gerenciador de alertas para lidar com alertas
  • diversas ferramentas de suporte

Para mais informações sobre o Prometheus acesse a documentação oficial:
https://prometheus.io/docs/introduction/overview/

Nomes e rótulos de métricas

Exemplo de nome de métrica:

<metric name>{<label name>=<label value>, ...}

Exemplo de nome de métrica com rótulos:

api_http_requests_total{method="POST", handler="/messages"}

Tipos de métricas

Metrics Type

Contador– aceita e armazena apenas os valores que aumentarão com o tempo.
Medidor– armazena os valores que podem assumir valores diferentes, que podem aumentar e diminuir.
Histograma– coleta amostras de observações (geralmente coisas como durações de solicitações ou tamanhos de respostas) e as conta em intervalos configuráveis. Também fornece uma soma de todos os valores observados, permitindo calcular médias.
Resumo– histograma com representação mais detalhada dos dados utilizando estatísticas adicionais (quantis).

Empregos e instâncias

Jobs

Nos termos do Prometheus, um endpoint que você pode raspar é chamado de instância, geralmente correspondendo a um único processo.
Uma coleção de instâncias com a mesma finalidade, um processo replicado para escalabilidade ou confiabilidade, por exemplo, é chamada de trabalho.

Especificação de gravação remota do Prometheus

O protocolo de gravação remota foi projetado para possibilitar a propagação confiável de amostras em tempo real de um remetente para um destinatário, sem perdas.

  • um "Remetente" é algo que envia dados de gravação remota do Prometheus.
  • um "Receptor" é algo que recebe dados de gravação remota do Prometheus.
  • uma "amostra" é um par de (timestamp, valor).
  • um "Rótulo" é um par de (chave, valor).
  • uma "Série" é uma lista de amostras, identificadas por um conjunto exclusivo de rótulos.

Remetentes e destinatários compatíveis

A especificação pretende descrever como os seguintes componentes interagem:

  • Prometeu (como "remetente" e "receptor")
  • Avalanche (como um "remetente") - Uma ferramenta de teste de carga Prometheus Metrics.
  • Cortex (como um "receptor")
  • Agente Elástico (como um "receptor")
  • Agente Grafana (como "remetente" e "destinatário")
  • GreptimeDB (como um "receptor")
  • Agente Telegraf da InfluxData. (como remetente e como destinatário)
  • M3 (como um "receptor")
  • Mimir (como um "receptor")
  • OpenTelemetry Collector (como "remetente" e eventualmente como "receptor")
  • Thanos (como um "receptor")
  • Vetor (como "remetente" e "destinatário")
  • VictoriaMetrics (como um "receptor")

Lavado

promql

O Prometheus fornece uma linguagem de consulta funcional chamada PromQL (Prometheus Query Language) que permite ao usuário selecionar e agregar dados de séries temporais em tempo real.
O resultado de uma expressão pode ser mostrado como um gráfico, visualizado como dados tabulares no navegador de expressões do Prometheus ou consumido por sistemas externos por meio da API HTTP.

Exemplos de consulta

Federação

federation

A federação permite que um servidor Prometheus extraia séries temporais selecionadas de outro servidor Prometheus.

Federação Hierárquica

A federação hierárquica permite que o Prometheus seja dimensionado para ambientes com dezenas de data centers e milhões de nós.

Nesse caso de uso, a topologia de federação se assemelha a uma árvore, com servidores Prometheus de nível superior coletando dados agregados de séries temporais de um número maior de servidores subordinados.

Isso significa que temos servidores Prometheus maiores que coletam dados de séries temporais de servidores menores. Temos uma abordagem de cima para baixo, onde os dados são coletados em diferentes níveis.

federation-hierarchical

Federação entre serviços

Este método envolve um servidor Prometheus monitorando um determinado serviço ou grupo de serviços, coletando dados de série temporal específicos de outro servidor que está monitorando um conjunto diferente de serviços.

Por exemplo, um agendador de cluster que executa vários serviços pode expor informações de uso de recursos (como uso de memória e CPU) sobre instâncias de serviço em execução no cluster.

Por outro lado, um serviço em execução nesse cluster exporá apenas métricas de serviço específicas do aplicativo.

Freqüentemente, esses dois conjuntos de métricas são coletados por servidores Prometheus separados. Usando a federação, o servidor Prometheus que contém métricas de nível de serviço pode extrair as métricas de uso de recursos do cluster sobre seu serviço específico do cluster Prometheus, para que ambos os conjuntos de métricas possam ser usados ​​nesse servidor.

Ao fazer isso, podemos executar consultas e alertas nos dados mesclados de ambos os servidores.

cross-service-federation

Descoberta de serviço HTTP

http_sd

O Prometheus fornece uma descoberta de serviço HTTP genérica, que permite descobrir alvos em um endpoint HTTP.

A descoberta de serviço HTTP é complementar aos mecanismos de descoberta de serviço suportados e é uma alternativa à descoberta de serviço baseada em arquivo.

  • static_configs não é escalonável para ambientes mais dinâmicos onde instâncias são adicionadas/removidas com frequência
  • O Prometheus pode ser integrado a mecanismos de descoberta de serviço para atualizar automaticamente sua visão das instâncias em execução
    • quando novas instâncias são adicionadas, o Prometheus começará a ser copiado; quando perdida na descoberta, a série temporal também será removida
    • integrações integradas com Consul, Azure, AWS ou baseadas em arquivo, se necessário, mecanismo personalizado
  • O arquivo JSON/YAML pode ser publicado pela plataforma especificando todos os alvos dos quais extrair. Prometheus o usa para atualizar alvos automaticamente

Exemplo usando http sd_file

http_file_sd

prometheus.yaml para descartar os serviços no destino http_sd.json

global:
  scrape_interval: 15s
  evaluation_interval: 15s
scrape_configs:  
  # Service Discovery with file_sd  
  - job_name: 'http_sd'
    basic_auth:
      username: "skynet"
      password: "prometheus"
    file_sd_configs:
      - files:
        - /home/vagrant/prometheus-server/http_sd.json

http_sd.json

[
    {
        "targets": ["192.168.0.130:9100", "192.168.0.131:9100"],
        "labels": {            
            "__meta_prometheus_job": "node"
        }
    },
    {
        "targets": ["192.168.0.130:9091"],
        "labels": {            
            "__meta_prometheus_job": "pushgateway"
        }
    }    
]

Instale o Prometheus

# Download files - https://prometheus.io/download/
wget https://github.com/prometheus/prometheus/releases/download/v2.51.2/prometheus-2.51.2.linux-amd64.tar.gz

# Extract files
tar xvfz prometheus-*.tar.gz
rm  prometheus-*.tar.gz
cd prometheus-*

# Check version
./prometheus --version

Configurar o Prometheus

Veja meu arquivo de configuraçãoprometheus.yaml

vim prometheus.yaml
# my global config
global:
  scrape_interval: 15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
  evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute.
  # scrape_timeout is set to the global default (10s).

# Alertmanager configuration
alerting:
  alertmanagers:
    - static_configs:
        - targets:
          # - alertmanager:9093

# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
rule_files:
  # - "first_rules.yml"
  # - "second_rules.yml"

# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:
  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
  - job_name: "prometheus"

    # metrics_path defaults to '/metrics'
    # scheme defaults to 'http'.

    static_configs:
      - targets: ["localhost:9090"]

Inicie o Prometeu

# Start
./prometheus --config.file=prometheus.yml

# Start with PM2 - npm install pm2@latest -g
pm2 start prometheus --name prometheus-server -- --config.file=prometheus.yml

Pontos finais importantes

http://localhost:9090 # all endpoints
http://localhost:9090/graph # PromQL expressions
http://localhost:9090/metrics # metrics
http://localhost:9090/targets # scrape_configs jobs

Usando o navegador de expressões

Você pode usar a expressão no modo Tabela ou Gráfico.

Abra a página http://localhost:9090

# Check all http metrics
promhttp_metric_handler_requests_total

# Check http metrics with http status code 200
promhttp_metric_handler_requests_total{code="200"}

# Count http metrics
count(promhttp_metric_handler_requests_total)

# Rate function
rate(promhttp_metric_handler_requests_total{code="200"}[1m])

Prometheus Exportadores

Um exportador é um binário executado junto com o aplicativo do qual você deseja obter métricas.
O exportador expõe métricas do Prometheus, geralmente convertendo métricas expostas em um formato não Prometheus em um formato compatível com o Prometheus.

Exportador de nós

O Prometheus Node Exporter expõe uma ampla variedade de métricas relacionadas a hardware e kernel.

Exportador de nó de instalação
# Download - https://prometheus.io/download#node_exporter
wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz

# Extract
tar xvfz node_exporter-*.*-amd64.tar.gz
cd node_exporter-*.*-amd64
Iniciar exportador de nós
# Start
./node_exporter

# Start with PM2 - npm install pm2@latest -g
pm2 start node_exporter --name node_exporter
Exportador de nós de endpoints
# Access metrics
http://localhost:9100/metrics
Configurar exportador de nós

Para ativar o scrap para o exportador de nós, você pode configurar o prometheus.

# Edit prometheus file and add job node
vim prometheus.yaml
...
scrape_configs:
- job_name: node
  static_configs:
  - targets: ['localhost:9100']
...

Reinicie o serviço Prometheus para aplicar um novo trabalho.

PushGateway

O Prometheus Pushgateway é um serviço intermediário que permite que trabalhos efêmeros e em lote exponham suas métricas ao Prometheus.
Como esses tipos de trabalhos podem não existir por tempo suficiente para serem eliminados, eles podem, em vez disso, enviar suas métricas para um Pushgateway.
O Pushgateway atua então como um armazenamento temporário de métricas que o Prometheus coleta.

Essa configuração é particularmente útil para capturar o resultado de uma tarefa que não é executada continuamente, como uma tarefa em lote em um sistema de CI ou um script de backup em execução em um horário agendado.
Ele simplifica o monitoramento desses tipos de trabalhos sem a necessidade de executar uma instância do Prometheus de longa duração que pode sobreviver aos próprios trabalhos.

Instale o PushGateway

# Download 
wget -q https://github.com/prometheus/pushgateway/releases/download/v1.8.0/pushgateway-1.8.0.linux-amd64.tar.gz

# Extract
tar xvfz pushgateway-*.*-amd64.tar.gz
cd pushgateway-*.*-amd64

# Start 
# Start with PM2 - npm install pm2@latest -g
pm2 start pushgateway --name pushgateway -- --web.listen-address "192.168.0.130:9091"

Configurar PushGateway

# Edit prometheus file and add job pushgateway
vim prometheus.yaml
scrape_configs:
  - job_name: 'pushgateway'
    honor_labels: true
    static_configs:
      - targets: ['192.168.0.130:9091'] # prometheus server for scraping
# Restart prometheus

# restart with pm2
pm2 restart prometheus-server

Crie métricas para teste pushgateway

echo 'training_completion{course="CKA", status="complete"} 1' > metrics.txt
echo 'training_completion{course="CKS", status="in_progress"} 0.5' >> metrics.txt
echo 'training_completion{course="LPIC2", status="not_started"} 0' >> metrics.txt
curl --data-binary @metrics.txt http://192.168.0.130:9091/metrics/job/training_metrics
Pontos de extremidade PushGateway
# Access metrics
http://localhost:9091

Use PromQL para encontrar o alvo do pushgateway de métricas

promql-pushgateway

Promlens

Instalar Promlens

Funciona apenas sem autenticação básica

echo "Downloading Promlens..."
wget -q https://github.com/prometheus/promlens/releases/download/v0.3.0/promlens-0.3.0.linux-amd64.tar.gz

echo "Extracting Promlens..."
tar xvfz promlens-*.*-amd64.tar.gz
rm promlens-*.*-amd64.tar.gz
cd promlens-*.*-amd64 || exit

echo "Starting Promlens..."
pm2 start promlens --name promlens -- --web.listen-address "192.168.0.130:8081"
cd || exit

Pontos de extremidade do Promlens

# Access query builder
http://192.168.0.130:8081

promlens

Gerenciador de alertas

alertmanager

Para mais informações sobre o Alertmanager acesse a documentação oficial:
https://github.com/prometheus/alertmanager

(back to top)

Grafana

Grafana Loki

Grafana Tempo

Liga Grafana

(back to top)

Contribuindo

As contribuições são o que tornam a comunidade de código aberto um lugar incrível para aprender, inspirar e criar. Qualquer contribuição que você fizer serámuito apreciado.

Se você tiver uma sugestão que possa melhorar isso, bifurque o repositório e crie uma solicitação pull. Você também pode simplesmente abrir um problema com a tag “aprimoramento”. Não se esqueça de dar uma estrela ao projeto! Obrigado novamente!

  1. Bifurque o projeto
  2. Crie sua ramificação de recursos (git checkout -b feature/AmazingFeature)
  3. Confirme suas alterações (git commit -m 'Add some AmazingFeature')
  4. Empurre para a filial (git push origin feature/AmazingFeature)
  5. Abra uma solicitação pull

(back to top)

Licença

Distribuído sob a licença MIT. VerLICENSEPara maiores informações.

(back to top)

Contato

Link do projeto:https://github.com/marcossilvestrini/learning-observability

(back to top)

Agradecimentos

(back to top)