Como Configurar um Conjunto de Monitoramento do Kubernetes com Prometheus, Grafana e Alertmanager na DigitalOcean

Tutoriais
Kubernetes Monitoring

Estado: Obsoleto

Este artigo está obsoleto e não é mais mantido.

Motivo

Os passos deste tutorial ainda funcionam, mas produzirão uma configuração que agora é desnecessariamente difícil de manter.

Veja em vez disso

Este artigo ainda pode ser útil como referência, mas pode não seguir as melhores práticas. Recomendamos fortemente o uso de um artigo mais recente.

Introdução

Junto com o rastreamento e o registro, o monitoramento e o alerta são componentes essenciais de um conjunto de observabilidade do Kubernetes. Configurar o monitoramento para o seu cluster Kubernetes da DigitalOcean permite que você acompanhe o uso de recursos e analise e depure erros de aplicativos.

A monitoring system usually consists of a time-series database that houses metric data and a visualization layer. In addition, an alerting layer creates and manages alerts, handing them off to integrations and external services as necessary. Finally, one or more components generate or expose the metric data that will be stored, visualized, and processed for alerts by the stack.

Uma solução de monitoramento popular é o conjunto de código aberto Prometheus, Grafana e Alertmanager, implantado junto com kube-state-metrics e node_exporter para expor métricas de objetos Kubernetes em nível de cluster, bem como métricas de nível de máquina, como uso de CPU e memória.

Implantar este conjunto de monitoramento em um cluster Kubernetes requer a configuração de componentes individuais, manifestos, métricas do Prometheus e painéis do Grafana, o que pode levar algum tempo. O Início Rápido do Monitoramento do Cluster Kubernetes da DigitalOcean, lançado pela equipe de Educação de Desenvolvedores da Comunidade DigitalOcean, contém manifestos totalmente definidos para um conjunto de monitoramento de cluster Prometheus-Grafana-Alertmanager, bem como um conjunto de alertas predefinidos e painéis do Grafana. Isso pode ajudá-lo a começar rapidamente e forma uma base sólida a partir da qual construir seu conjunto de observabilidade.

Neste tutorial, vamos implantar este conjunto pré-configurado no Kubernetes da DigitalOcean, acessar as interfaces do Prometheus, Grafana e Alertmanager e descrever como personalizá-lo.

Pré-requisitos

Antes de começar, você precisará de um cluster Kubernetes da DigitalOcean disponível para você e das seguintes ferramentas instaladas em seu ambiente de desenvolvimento local:

  • O interface de linha de comando kubectl instalado em sua máquina local e configurado para se conectar ao seu cluster. Você pode ler mais sobre como instalar e configurar o kubectl na sua documentação oficial.
  • O sistema de controle de versão git instalado em sua máquina local. Para aprender como instalar o git no Ubuntu 18.04, consulte Como Instalar o Git no Ubuntu 18.04.
  • A ferramenta Coreutils base64 instalada em sua máquina local. Se você estiver usando uma máquina Linux, provavelmente isso já estará instalado. Se estiver usando o macOS, você pode usar openssl base64, que vem instalado por padrão.

<$>[nota]
Nota: O Início Rápido de Monitoramento de Cluster foi testado apenas em clusters Kubernetes da DigitalOcean. Para usar o Início Rápido com outros clusters Kubernetes, algumas modificações nos arquivos de manifesto podem ser necessárias.
<$>

Passo 1 — Clonando o Repositório do GitHub e Configurando Variáveis de Ambiente

Para começar, clone o repositório do GitHub de Monitoramento de Cluster Kubernetes da DigitalOcean em sua máquina local usando git:

  1. git clone https://github.com/do-community/doks-monitoring.git

Em seguida, navegue até o repositório:

  1. cd doks-monitoring

Você deverá ver a seguinte estrutura de diretórios:

  1. ls



Output
LICENSE
README.md
changes.txt
manifest

O diretório manifest contém manifestos do Kubernetes para todos os componentes do stack de monitoramento, incluindo Contas de Serviço, Implantações, Sets de Estado, Mapas de Configuração, etc. Para saber mais sobre esses arquivos de manifesto e como configurá-los, avance para Configurando o Stack de Monitoramento.

Se você apenas deseja colocar as coisas em funcionamento, comece configurando as variáveis de ambiente APP_INSTANCE_NAME e NAMESPACE, que serão usadas para configurar um nome exclusivo para os componentes do stack e configurar o Namespace no qual o stack será implantado:

  1. export APP_INSTANCE_NAME=sammy-cluster-monitoring

  2. export NAMESPACE=default

Neste tutorial, definimos APP_INSTANCE_NAME como sammy-cluster-monitoring, que será prefixado em todos os nomes de objetos Kubernetes do stack de monitoramento. Você deve substituir por um prefixo descritivo único para o seu stack de monitoramento. Também definimos o Namespace como default. Se você deseja implantar o stack de monitoramento em um Namespace diferente de default, certifique-se de criá-lo primeiro em seu cluster:

  1. kubectl create namespace "$NAMESPACE"

Você deve ver a seguinte saída:

Output
namespace/sammy created

Neste caso, a variável de ambiente NAMESPACE foi definida como sammy. Ao longo do resto do tutorial, assumiremos que NAMESPACE foi definido como default.

Agora, use o comando base64 para codificar em base64 uma senha segura do Grafana. Certifique-se de substituir uma senha de sua escolha por sua_senha_grafana:

  1. export GRAFANA_GENERATED_PASSWORD="$(echo -n 'your_grafana_password' | base64)"

Se estiver usando macOS, você pode substituir o comando openssl base64, que vem instalado por padrão.

Neste ponto, você pegou os manifestos Kubernetes do stack e configurou as variáveis de ambiente necessárias, então agora está pronto para substituir as variáveis configuradas nos arquivos de manifesto Kubernetes e criar o stack em seu cluster Kubernetes.

Passo 2 — Criando o Conjunto de Monitoramento

O repositório DigitalOcean Kubernetes Monitoring Quickstart contém manifestos para os seguintes componentes de monitoramento, coleta e visualização:

  • Prometheus é um banco de dados de séries temporais e uma ferramenta de monitoramento que funciona realizando sondagens nos pontos de métricas e coletando e processando os dados expostos por esses pontos. Ele permite consultar esses dados usando PromQL, uma linguagem de consulta de dados de séries temporais. O Prometheus será implantado no cluster como um StatefulSet com 2 réplicas que utiliza Volumes Persistentes com o Armazenamento de Blocos da DigitalOcean. Além disso, um conjunto preconfigurado de Alertas, Regras e Tarefas do Prometheus será armazenado como um ConfigMap. Para saber mais sobre esses, vá para a seção Prometheus de Configurando o Conjunto de Monitoramento.
  • Alertmanager, geralmente implantado junto com Prometheus, forma a camada de alerta do conjunto, lidando com alertas gerados pelo Prometheus e deduplicando, agrupando e roteando-os para integrações como email ou PagerDuty. O Alertmanager será instalado como um StatefulSet com 2 réplicas. Para saber mais sobre o Alertmanager, consulte Alerting na documentação do Prometheus.
  • Grafana é uma ferramenta de visualização e análise de dados que permite construir painéis e gráficos para seus dados de métricas. Grafana será instalado como um StatefulSet com uma réplica. Além disso, um conjunto preconfigurado de Painéis gerados pelo kubernetes-mixin será armazenado como um ConfigMap.
  • kube-state-metrics é um agente adicional que escuta o servidor de API do Kubernetes e gera métricas sobre o estado de objetos do Kubernetes como Deployments e Pods. Essas métricas são servidas como texto simples em endpoints HTTP e consumidas pelo Prometheus. kube-state-metrics será instalado como um Deployment autoescalável com uma réplica.
  • node-exporter, um exportador do Prometheus que é executado em nós do cluster e fornece métricas de SO e hardware como uso de CPU e memória para o Prometheus. Essas métricas também são servidas como texto simples em endpoints HTTP e consumidas pelo Prometheus. node-exporter será instalado como um DaemonSet.

Por padrão, juntamente com a coleta de métricas geradas pelo node-exporter, kube-state-metrics e os outros componentes listados acima, o Prometheus será configurado para coletar métricas dos seguintes componentes:

  • kube-apiserver, o servidor de API do Kubernetes.
  • kubelet, o agente primário do nó que interage com o kube-apiserver para gerenciar Pods e containers em um nó.
  • cAdvisor, um agente de nó que descobre containers em execução e coleta suas métricas de uso de CPU, memória, sistema de arquivos e rede.

Para saber mais sobre a configuração desses componentes e trabalhos de coleta do Prometheus, pule para Configurando o Stack de Monitoramento. Agora vamos substituir as variáveis de ambiente definidas na etapa anterior nos arquivos de manifesto do repositório e concatenar os manifestos individuais em um único arquivo principal.

Comece usando awk e envsubst para preencher as variáveis APP_INSTANCE_NAME, NAMESPACE e GRAFANA_GENERATED_PASSWORD nos arquivos de manifesto do repositório. Após substituir os valores das variáveis, os arquivos serão combinados e salvos em um arquivo de manifesto principal chamado sammy-cluster-monitoring_manifest.yaml.

  1. awk 'FNR==1 {print "---"}{print}' manifest/* \

  2.  | envsubst '$APP_INSTANCE_NAME $NAMESPACE $GRAFANA_GENERATED_PASSWORD' \

  3.  > "${APP_INSTANCE_NAME}_manifest.yaml"

Você deve considerar armazenar este arquivo no controle de versão para que você possa rastrear as alterações no conjunto de monitoramento e reverter para versões anteriores. Se fizer isso, certifique-se de limpar a variável admin-password do arquivo para não enviar sua senha do Grafana para o controle de versão.

Agora que você gerou o arquivo de manifesto principal, use kubectl apply -f para aplicar o manifesto e criar o conjunto no Namespace que você configurou:

  1. kubectl apply -f "${APP_INSTANCE_NAME}_manifest.yaml" --namespace "${NAMESPACE}"

Você deve ver uma saída semelhante à seguinte:

Output
serviceaccount/alertmanager created
configmap/sammy-cluster-monitoring-alertmanager-config created
service/sammy-cluster-monitoring-alertmanager-operated created
service/sammy-cluster-monitoring-alertmanager created

. . .

clusterrolebinding.rbac.authorization.k8s.io/prometheus created
configmap/sammy-cluster-monitoring-prometheus-config created
service/sammy-cluster-monitoring-prometheus created
statefulset.apps/sammy-cluster-monitoring-prometheus created

Você pode acompanhar o progresso de implantação do conjunto usando kubectl get all. Assim que todos os componentes do conjunto estiverem RUNNING, você poderá acessar os painéis preconfigurados do Grafana através da interface web do Grafana.

Etapa 3 — Acessando o Grafana e Explorando Dados de Métricas

O manifesto do serviço Grafana expõe o Grafana como um Serviço ClusterIP, o que significa que ele só é acessível por meio de um endereço IP interno do cluster. Para acessar o Grafana fora do seu cluster Kubernetes, você pode usar kubectl patch para atualizar o Serviço no local para um tipo voltado para o público, como NodePort ou LoadBalancer, ou kubectl port-forward para encaminhar uma porta local para uma porta do Pod Grafana. Neste tutorial, encaminharemos portas, então você pode pular para Encaminhando uma Porta Local para Acessar o Serviço Grafana. A seguinte seção sobre a exposição externa do Grafana é incluída para fins de referência.

Expondo o Serviço Grafana usando um Balanceador de Carga (opcional)

Se desejar criar um Balanceador de Carga DigitalOcean para o Grafana com um IP público externo, use kubectl patch para atualizar o Serviço Grafana existente no local para o tipo de Serviço LoadBalancer:

  1. kubectl patch svc "$APP_INSTANCE_NAME-grafana" \

  2.   --namespace "$NAMESPACE" \

  3.   -p '{"spec": {"type": "LoadBalancer"}}'

O comando patch do kubectl permite que você atualize objetos do Kubernetes no local para fazer alterações sem precisar reimplantar os objetos. Você também pode modificar diretamente o arquivo de manifesto principal, adicionando um parâmetro type: LoadBalancer à especificação do Serviço do Grafana. Para saber mais sobre kubectl patch e os tipos de Serviço do Kubernetes, você pode consultar os recursos Atualizar Objetos da API no Local Usando kubectl patch e Serviços na documentação oficial do Kubernetes.

Após executar o comando acima, você deve ver o seguinte:

Output
service/sammy-cluster-monitoring-grafana patched

Pode demorar alguns minutos para criar o Balanceador de Carga e atribuir a ele um IP público. Você pode acompanhar o progresso usando o seguinte comando com a flag -w para assistir as mudanças:

  1. kubectl get service "$APP_INSTANCE_NAME-grafana" -w

Assim que o Balanceador de Carga DigitalOcean for criado e atribuído um endereço IP externo, você pode buscar seu IP externo usando os seguintes comandos:

  1. SERVICE_IP=$(kubectl get svc $APP_INSTANCE_NAME-grafana \

  2.   --namespace $NAMESPACE \

  3.   --output jsonpath='{.status.loadBalancer.ingress[0].ip}')

  4. echo "http://${SERVICE_IP}/"

Agora você pode acessar a interface do usuário do Grafana navegando para http://SERVICE_IP/.

Encaminhando uma Porta Local para Acessar o Serviço do Grafana

Se você não deseja expor o Serviço Grafana externamente, também pode encaminhar a porta local 3000 diretamente para um Pod Grafana dentro do cluster usando kubectl port-forward.

  1. kubectl port-forward --namespace ${NAMESPACE} ${APP_INSTANCE_NAME}-grafana-0 3000

Você deverá ver a seguinte saída:

Output
Forwarding from 127.0.0.1:3000 -> 3000
Forwarding from [::1]:3000 -> 3000

Isso encaminhará a porta local 3000 para a porta containerPort 3000 do Pod Grafana sammy-cluster-monitoring-grafana-0. Para saber mais sobre encaminhamento de portas para um cluster Kubernetes, consulte Usar Encaminhamento de Portas para Acessar Aplicações em um Cluster.

Acesse http://localhost:3000 em seu navegador da web. Você deverá ver a seguinte página de login do Grafana:

Para fazer login, use o nome de usuário padrão admin (se você não modificou o parâmetro admin-user), e a senha que você configurou no Passo 1.

Você será levado ao seguinte Painel Inicial:

No menu de navegação à esquerda, selecione o botão Painéis, e então clique em Gerenciar:

Você será levado à seguinte interface de gerenciamento de painéis, que lista os painéis configurados no manifesto dashboards-configmap.yaml:

Estes painéis são gerados pelo kubernetes-mixin, um projeto de código aberto que permite criar um conjunto padronizado de painéis de monitoramento de cluster Grafana e alertas Prometheus. Para saber mais, consulte o repositório do GitHub do kubernetes-mixin.

Clique no painel Kubernetes / Nodes, que visualiza o uso de CPU, memória, disco e rede para um nó específico:

Descrever como usar esses painéis está fora do escopo deste tutorial, mas você pode consultar os seguintes recursos para saber mais:

No próximo passo, seguiremos um processo semelhante para conectar-se e explorar o sistema de monitoramento Prometheus.

Passo 4 — Acessando Prometheus e Alertmanager

Para conectar aos Pods do Prometheus, podemos usar kubectl port-forward para encaminhar uma porta local. Se você terminou de explorar o Grafana, pode fechar o túnel de encaminhamento de porta pressionando CTRL-C. Alternativamente, você pode abrir um novo terminal e criar uma nova conexão de encaminhamento de porta.

Comece listando os Pods em execução no namespace default:

  1. kubectl get pod -n default

Você deverá ver os seguintes Pods:

Output
sammy-cluster-monitoring-alertmanager-0                      1/1     Running   0          17m
sammy-cluster-monitoring-alertmanager-1                      1/1     Running   0          15m
sammy-cluster-monitoring-grafana-0                           1/1     Running   0          16m
sammy-cluster-monitoring-kube-state-metrics-d68bb884-gmgxt   2/2     Running   0          16m
sammy-cluster-monitoring-node-exporter-7hvb7                 1/1     Running   0          16m
sammy-cluster-monitoring-node-exporter-c2rvj                 1/1     Running   0          16m
sammy-cluster-monitoring-node-exporter-w8j74                 1/1     Running   0          16m
sammy-cluster-monitoring-prometheus-0                        1/1     Running   0          16m
sammy-cluster-monitoring-prometheus-1                        1/1     Running   0          16m

Vamos encaminhar a porta local 9090 para a porta 9090 do Pod sammy-cluster-monitoring-prometheus-0:

  1. kubectl port-forward --namespace ${NAMESPACE} sammy-cluster-monitoring-prometheus-0 9090

Você deverá ver a seguinte saída:

Output
Forwarding from 127.0.0.1:9090 -> 9090
Forwarding from [::1]:9090 -> 9090

Isso indica que a porta local 9090 está sendo encaminhada com sucesso para o Pod do Prometheus.

Acesse http://localhost:9090 em seu navegador da web. Você deverá ver a seguinte página de Gráfico do Prometheus:

A partir daqui, você pode usar o PromQL, a linguagem de consulta do Prometheus, para selecionar e agregar métricas de séries temporais armazenadas em seu banco de dados. Para saber mais sobre o PromQL, consulte Consultando o Prometheus na documentação oficial do Prometheus.

No campo de Expressão, digite kubelet_node_name e pressione Executar. Você deverá ver uma lista de séries temporais com a métrica kubelet_node_name que relata os Nós em seu cluster Kubernetes. Você pode ver qual nó gerou a métrica e qual trabalho coletou a métrica nos rótulos da métrica:

Finalmente, na barra de navegação superior, clique em Status e depois em Alvos para ver a lista de alvos que o Prometheus foi configurado para coletar. Você deverá ver uma lista de alvos correspondentes à lista de endpoints de monitoramento descritos no início do Passo 2.

Para saber mais sobre o Prometheus e como consultar as métricas do seu cluster, consulte a documentação oficial do Prometheus.

Para se conectar ao Alertmanager, que gerencia Alertas gerados pelo Prometheus, seguiremos um processo semelhante ao que usamos para nos conectar ao Prometheus. Em geral, você pode explorar os Alertas do Alertmanager clicando em Alertas na barra de navegação superior do Prometheus.

Para se conectar aos Pods do Alertmanager, usaremos novamente kubectl port-forward para encaminhar uma porta local. Se você terminou de explorar o Prometheus, pode fechar o túnel de encaminhamento de porta pressionando CTRL-C ou abrir um novo terminal para criar uma nova conexão.

Vamos encaminhar a porta local 9093 para a porta 9093 do Pod sammy-cluster-monitoring-alertmanager-0:

  1. kubectl port-forward --namespace ${NAMESPACE} sammy-cluster-monitoring-alertmanager-0 9093

Você deve ver a seguinte saída:

Output
Forwarding from 127.0.0.1:9093 -> 9093
Forwarding from [::1]:9093 -> 9093

Isso indica que a porta local 9093 está sendo encaminhada com sucesso para um Pod Alertmanager.

Acesse http://localhost:9093 em seu navegador da web. Você deverá ver a página de Alertas do Alertmanager:

A partir daqui, você pode explorar alertas ativados e, opcionalmente, silenciá-los. Para saber mais sobre o Alertmanager, consulte a documentação oficial do Alertmanager.

No próximo passo, você aprenderá como configurar opcionalmente e dimensionar alguns dos componentes do stack de monitoramento.

Passo 6 — Configurando o Stack de Monitoramento (opcional)

Os manifestos incluídos no repositório DigitalOcean Kubernetes Cluster Monitoring Quickstart podem ser modificados para usar imagens de contêiner diferentes, números diferentes de réplicas de Pod, portas diferentes e arquivos de configuração personalizados.

Neste passo, forneceremos uma visão geral de alto nível do propósito de cada manifesto e, em seguida, demonstraremos como escalar o Prometheus para 3 réplicas modificando o arquivo de manifesto principal.

Para começar, navegue até o subdiretório manifests no repositório e liste o conteúdo do diretório:

  1. cd manifest

  2. ls



Output
alertmanager-0serviceaccount.yaml
alertmanager-configmap.yaml
alertmanager-operated-service.yaml
alertmanager-service.yaml
. . .
node-exporter-ds.yaml
prometheus-0serviceaccount.yaml
prometheus-configmap.yaml
prometheus-service.yaml
prometheus-statefulset.yaml

Aqui você encontrará manifestos para os diferentes componentes do stack de monitoramento. Para saber mais sobre parâmetros específicos nos manifestos, clique nos links e consulte os comentários incluídos nos arquivos YAML:

Alertmanager

Grafana

kube-state-metrics

node-exporter

###Prometheus

  • prometheus-0serviceaccount.yaml: A conta de serviço do Prometheus, ClusterRole e ClusterRoleBinding.

  • prometheus-configmap.yaml: Um ConfigMap que contém três arquivos de configuração:

    • alerts.yaml: Contém um conjunto preconfigurado de alertas gerados pelo kubernetes-mixin (que também foi usado para gerar os painéis do Grafana). Para saber mais sobre a configuração das regras de alerta, consulte Regras de Alerta na documentação do Prometheus.
    • prometheus.yaml: O arquivo de configuração principal do Prometheus. O Prometheus foi pré-configurado para coletar dados de todos os componentes listados no início do Passo 2. Configurar o Prometheus vai além do escopo deste artigo, mas para saber mais, você pode consultar Configuração na documentação oficial do Prometheus.
    • rules.yaml: Um conjunto de regras de gravação do Prometheus que permitem ao Prometheus calcular expressões frequentemente necessárias ou computacionalmente caras e salvar seus resultados como um novo conjunto de séries temporais. Estas também são geradas pelo kubernetes-mixin, e configurá-las vai além do escopo deste artigo. Para saber mais, você pode consultar Regras de Gravação na documentação oficial do Prometheus.

  • prometheus-service.yaml: O Serviço que expõe o StatefulSet do Prometheus.

  • prometheus-statefulset.yaml: O StatefulSet do Prometheus, configurado com 2 réplicas. Este parâmetro pode ser dimensionado dependendo das suas necessidades.

Exemplo: Dimensionando o Prometheus

Para demonstrar como modificar o conjunto de monitoramento, vamos aumentar o número de réplicas do Prometheus de 2 para 3.

Abra o arquivo mestre do manifesto sammy-cluster-monitoring_manifest.yaml usando o seu editor de escolha:

  1. nano sammy-cluster-monitoring_manifest.yaml

Role para baixo até a seção StatefulSet do Prometheus no manifesto:

Output
. . .
apiVersion: apps/v1beta2
kind: StatefulSet
metadata:
  name: sammy-cluster-monitoring-prometheus
  labels: &Labels
    k8s-app: prometheus
    app.kubernetes.io/name: sammy-cluster-monitoring
    app.kubernetes.io/component: prometheus
spec:
  serviceName: "sammy-cluster-monitoring-prometheus"
  replicas: 2
  podManagementPolicy: "Parallel"
  updateStrategy:
    type: "RollingUpdate"
  selector:
    matchLabels: *Labels
  template:
    metadata:
      labels: *Labels
    spec:
. . .

Altere o número de réplicas de 2 para 3:

Output
. . .
apiVersion: apps/v1beta2
kind: StatefulSet
metadata:
  name: sammy-cluster-monitoring-prometheus
  labels: &Labels
    k8s-app: prometheus
    app.kubernetes.io/name: sammy-cluster-monitoring
    app.kubernetes.io/component: prometheus
spec:
  serviceName: "sammy-cluster-monitoring-prometheus"
  replicas: 3
  podManagementPolicy: "Parallel"
  updateStrategy:
    type: "RollingUpdate"
  selector:
    matchLabels: *Labels
  template:
    metadata:
      labels: *Labels
    spec:
. . .

Quando terminar, salve e feche o arquivo.

Aplique as alterações usando kubectl apply -f:

  1. kubectl apply -f sammy-cluster-monitoring_manifest.yaml --namespace default

Você pode acompanhar o progresso usando kubectl get pods. Usando essa mesma técnica, você pode atualizar muitos dos parâmetros do Kubernetes e grande parte da configuração para este conjunto de observabilidade.

Conclusão

Neste tutorial, você instalou um conjunto de monitoramento Prometheus, Grafana e Alertmanager em seu cluster Kubernetes da DigitalOcean com um conjunto padrão de painéis, regras do Prometheus e alertas.

Você também pode optar por implantar este conjunto de monitoramento usando o gerenciador de pacotes Kubernetes Helm. Para saber mais, consulte Como Configurar o Monitoramento de Cluster Kubernetes da DigitalOcean com Helm e Prometheus. Uma maneira alternativa de obter um conjunto semelhante em funcionamento é usar a solução Conjunto de Monitoramento Kubernetes do Marketplace da DigitalOcean, atualmente em beta.

O repositório de Início Rápido de Monitoramento de Clusters do Kubernetes da DigitalOcean é fortemente baseado e modificado a partir da solução click-to-deploy Prometheus da Google Cloud Platform. Um manifesto completo de modificações e alterações do repositório original pode ser encontrado no arquivo changes.md do repositório de Início Rápido.

Source:
https://www.digitalocean.com/community/tutorials/how-to-set-up-a-kubernetes-monitoring-stack-with-prometheus-grafana-and-alertmanager-on-digitalocean