Como Configurar o TOBS, o Stack de Observabilidade, para Monitoramento do Kubernetes

Tutoriais

Estado: Obsoleto

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

Motivo

O instalador TOBS foi marcado como obsoleto pela fonte primária.

TOBS, abreviação de The Observability Stack, é uma distribuição pré-empacotada de ferramentas de monitoramento e interfaces de painel que podem ser instaladas em qualquer cluster Kubernetes existente. Inclui muitas das ferramentas de observabilidade de código aberto mais populares, com Prometheus e Grafana como base, incluindo Promlens, TimescaleDB, Alertmanager e outros. Juntos, eles fornecem uma solução direta e sustentável para analisar o tráfego do servidor e identificar possíveis problemas com um deployment em uma escala muito grande.

TOBS faz uso dos gráficos padrão do Helm do Kubernetes para configurar e atualizar implantações. Ele pode ser instalado em qualquer cluster Kubernetes, mas pode ser demonstrado de forma mais eficaz se você estiver executando o kubectl para gerenciar seu cluster a partir de uma máquina local em vez de um nó remoto. O Kubernetes Gerenciado da DigitalOcean fornecerá a você uma configuração como essa por padrão.

Neste tutorial, você irá instalar o TOBS em um cluster Kubernetes existente e aprenderá como atualizar, configurar e navegar pelos painéis de componentes.

Pré-requisitos

Para seguir este tutorial, você precisará de:

Um cluster Kubernetes com controle de acesso baseado em função (RBAC) habilitado. Esta configuração usará um cluster Kubernetes da DigitalOcean, mas você está livre para criar um cluster usando outro método. Sua versão do Kubernetes deve corresponder a uma versão TOBS suportada.
A ferramenta de linha de comando kubectl instalada em sua máquina local e configurada para se conectar ao seu cluster. Você pode ler mais sobre a instalação do kubectl na documentação oficial. Se estiver usando um cluster Kubernetes da DigitalOcean, consulte Como Conectar-se a um Cluster Kubernetes da DigitalOcean para aprender como se conectar ao seu cluster usando kubectl.

Passo 1 — Verificando sua Configuração do Kubernetes

Para instalar o TOBS, você deve primeiro ter uma configuração válida do Kubernetes configurada com kubectl a partir da qual possa pingar seus nós de trabalho. Você pode testar isso executando kubectl get nodes:

kubectl get nodes

Se o kubectl conseguir se conectar ao seu cluster Kubernetes e estiver em execução conforme o esperado, este comando retornará uma lista de nós com o status Ready:

OutputNAME                   STATUS   ROLES    AGE   VERSION
pool-uqv8a47h0-ul5a7   Ready    <none>   22m   v1.21.5
pool-uqv8a47h0-ul5am   Ready    <none>   21m   v1.21.5
pool-uqv8a47h0-ul5aq   Ready    <none>   21m   v1.21.5

Se isso for bem-sucedido, você pode prosseguir para Etapa 2. Caso contrário, você deve revisar os detalhes de sua configuração em busca de problemas.

Por padrão, o kubectl procurará um arquivo em ~/.kube/config para entender seu ambiente. Para verificar se este arquivo existe e contém sintaxe YAML válida, você pode executar head nele para visualizar suas primeiras várias linhas, i:

head ~/.kube/config

OutputapiVersion: v1
clusters:
- cluster:
    certificate-authority-data:
…

Se o arquivo não existir, verifique se você está conectado como o mesmo usuário que configurou o Kubernetes. Os caminhos ~/ refletem os diretórios pessoais dos usuários individuais, e as configurações do Kubernetes são salvas por usuário por padrão.

Se você estiver usando o Kubernetes Gerenciado da DigitalOcean, verifique se você executou o comando doctl kubernetes cluster kubeconfig save após configurar um cluster para que sua máquina local possa autenticar-se nele. Isso criará um arquivo ~/.kube/config:

doctl kubernetes cluster kubeconfig save your-cluster-name

Se você estiver usando esta máquina para acessar vários clusters, você deve revisar a documentação do Kubernetes sobre o uso de variáveis de ambiente e múltiplos arquivos de configuração para evitar conflitos. Após configurar seu ambiente kubectl, você pode prosseguir para instalar o TOBS na próxima etapa.

Passo 2 — Instalando TOBS e Testando Seus Pontos de Extremidade

TOBS inclui os seguintes componentes:

Prometheus é um banco de dados de séries temporais e ferramenta de monitoramento que funciona ao fazer sondagens nos pontos de extremidade de métricas e ao raspar e processar os dados expostos por esses pontos de extremidade. Ele permite consultar esses dados usando PromQL, uma linguagem de consulta de dados de séries temporais.
Alertmanager, geralmente implantado junto ao Prometheus, forma a camada de alerta da pilha, lidando com alertas gerados pelo Prometheus e deduplicando, agrupando e roteando-os para integrações como email ou PagerDuty. Para saber mais sobre o Alertmanager, consulte a documentação do Prometheus sobre alertas.
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.
kube-state-metrics é um agente adicional que escuta o servidor da API do Kubernetes e gera métricas sobre o estado de objetos do Kubernetes como Implantações e Pods. Essas métricas são servidas como texto simples em pontos de extremidade HTTP e consumidas pelo Prometheus.
Por último, temos o node-exporter, um exportador do Prometheus que é executado nos nós do cluster e fornece métricas do sistema operacional e hardware, como uso de CPU e memória, para o Prometheus. Essas métricas também são servidas como texto simples em pontos de extremidade HTTP e consumidas pelo Prometheus.

Para instalar o TOBS, primeiro você precisa executar o instalador do TOBS em seu plano de controle. Isso configurará o comando tobs e os diretórios de configuração. Conforme mencionado nos pré-requisitos, o comando tobs foi projetado para funcionar apenas em sistemas Linux/macOS/BSD (como os binários oficiais do Kubernetes), então se você estava usando o Windows até agora, deverá estar trabalhando no ambiente Windows Subsystem for Linux.

Obtenha e execute o instalador do TOBS:

curl --proto '=https' --tlsv1.2 -sSLf  https://tsdb.co/install-tobs-sh |sh

Outputtobs 0.7.0 was successfully installed ?

Binary is available at /root/.local/bin/tobs.

Agora você pode implantar o TOBS em seu cluster Kubernetes. Isso é feito por meio de um comando de uma linha usando o seu novo comando tobs:

tobs install

Isso gerará várias linhas de saída e pode levar alguns momentos. Dependendo da sua versão exata do Kubernetes, pode haver várias advertências na saída, mas você pode ignorá-las contanto que eventualmente receba a mensagem Bem-vindo ao tobs:

OutputWARNING: Using a generated self-signed certificate for TLS access to TimescaleDB.
         This should only be used for development and demonstration purposes.
         To use a signed certificate, use the "--tls-timescaledb-cert" and "--tls-timescaledb-key"
         flags when issuing the tobs install command.

Creating TimescaleDB tobs-certificate secret
Creating TimescaleDB tobs-credentials secret
skipping to create TimescaleDB s3 backup secret as backup option is disabled.
2022/01/10 11:25:34 Transport: unhandled response frame type *http.http2UnknownFrame
2022/01/10 11:25:35 Transport: unhandled response frame type *http.http2UnknownFrame
2022/01/10 11:25:35 Transport: unhandled response frame type *http.http2UnknownFrame
Installing The Observability Stack
2022/01/10 11:25:37 Transport: unhandled response frame type *http.http2UnknownFrame
W0110 11:25:55.438728   75479 warnings.go:70] policy/v1beta1 PodSecurityPolicy is deprecated in v1.21+, unavailable in v1.25+
W0110 11:25:55.646392   75479 warnings.go:70] policy/v1beta1 PodSecurityPolicy is deprecated in v1.21+, unavailable in v1.25+
…
?? Welcome to tobs, The Observability Stack for Kubernetes
…

A partir deste ponto, a saída conterá instruções para se conectar a cada um dos pontos de extremidade da web do Prometheus, TimescaleDB, PromLens e Grafana em seu navegador. Ela é reproduzida abaixo para referência:

Output###############################################################################
? PROMETHEUS NOTES:
###############################################################################

Prometheus can be accessed via port 9090 on the following DNS name from within your cluster:
tobs-kube-prometheus-prometheus.default.svc.cluster.local

Get the Prometheus server URL by running these commands in the same shell:
  tobs prometheus port-forward


The Prometheus alertmanager can be accessed via port 9093 on the following DNS name from within your cluster:
tobs-kube-prometheus-alertmanager.default.svc.cluster.local


Get the Alertmanager URL by running these commands in the same shell:
  export POD_NAME=$(kubectl get pods --namespace default -l "app=alertmanager,alertmanager=tobs-kube-prometheus-alertmanager" -o jsonpath="{.items[0].metadata.name}")
  kubectl --namespace default port-forward $POD_NAME 9093
WARNING! Persistence is disabled on AlertManager.
         You will lose your data when the AlertManager pod is terminated.

###############################################################################
? TIMESCALEDB NOTES:
###############################################################################

TimescaleDB can be accessed via port 5432 on the following DNS name from within your cluster:
tobs.default.svc.cluster.local

To get your password for superuser run:
    tobs timescaledb get-password -U <user>

To connect to your database, chose one of these options:

1. Run a postgres pod and connect using the psql cli:
    tobs timescaledb connect -U <user>

2. Directly execute a psql session on the master node
   tobs timescaledb connect -m


###############################################################################
? PROMLENS NOTES:
###############################################################################
   PromLens is a PromQL query builder, analyzer, and visualizer.

   You can access PromLens via a local browser by executing:
    tobs promlens port-forward

   Then you can point your browser to http://127.0.0.1:8081/.
###############################################################################
? GRAFANA NOTES:
###############################################################################

1. The Grafana server can be accessed via port 80 on
   the following DNS name from within your cluster:
   tobs-grafana.default.svc.cluster.local

   You can access grafana locally by executing:
    tobs grafana port-forward

   Then you can point your browser to http://127.0.0.1:8080/.

2. The 'admin' user password can be retrieved by:
    tobs grafana get-password

3. You can reset the admin user password with grafana-cli from inside the pod.
    tobs grafana change-password <password-you-want-to-set>

Cada um destes é fornecido com um nome DNS interno ao seu cluster para que possam ser acessados a partir de qualquer um dos seus nós de trabalho, por exemplo, tobs-kube-prometheus-alertmanager.default.svc.cluster.local para Prometheus. Além disso, há um comando de encaminhamento de porta configurado para cada um que permite acessá-los a partir de um navegador da web local.

Em um novo terminal, execute tobs prometheus port-forward:

tobs prometheus port-forward

Isto ocupará o terminal enquanto o processo de encaminhamento de porta estiver ativo. Você pode pressionar Ctrl+C para sair graciosamente de um processo bloqueante como este quando desejar interromper o encaminhamento da porta. Em seguida, em um navegador da web, vá para o URL http://127.0.0.1:9090/. Você deverá ver a interface completa do Prometheus em execução e produzindo métricas do seu cluster:

Você pode fazer o mesmo para o Grafana, que é acessível em http://127.0.0.1:8080/ enquanto o encaminhamento de porta estiver ativo em outro processo. Primeiro, você precisará usar o comando get-password fornecido pela saída do instalador:

tobs grafana get-password

Output
your-grafana-password

Você pode então usar esta senha para fazer login na interface do Grafana executando seu comando de encaminhamento de porta e abrindo http://127.0.0.1:8080/ em seu navegador.

tobs grafana port-forward

Agora você tem um stack TOBS funcional em execução no seu cluster Kubernetes. Você pode consultar a documentação dos componentes individuais para aprender sobre suas respectivas funcionalidades. No último passo deste tutorial, você aprenderá como fazer atualizações na própria configuração do TOBS.

Passo 3 — Edição das Configurações do TOBS e Atualização

As configurações do TOBS contêm alguns parâmetros para as aplicações individuais na pilha, bem como alguns parâmetros para o próprio deployment do TOBS. Ele é gerado e armazenado como um gráfico Helm do Kubernetes. Você pode visualizar sua configuração atual executando tobs helm show-values. No entanto, isso vai imprimir a configuração completa no seu terminal, o que pode ser difícil de ler. Você pode redirecionar a saída para um arquivo com a extensão .yaml, pois os gráficos Helm têm toda a sintaxe YAML válida:

tobs helm show-values > values.yaml

O conteúdo do arquivo ficará assim:

~/values.yaml

2022/01/10 11:56:37 Transport: unhandled response frame type *http.http2UnknownFrame
# Valores para configurar o deployment do TimescaleDB
# O README dos gráficos está em:
#    https://github.com/timescale/timescaledb-kubernetes/tree/master/charts/timescaledb-single
# Confira as várias opções de configuração (guia de administração) em:
#    https://github.com/timescale/timescaledb-kubernetes/blob/master/charts/timescaledb-single/admin-guide.md
cli: false

# Sobrescreva o namespace do deployment
namespaceOverride: ""
…

Você pode revisar os parâmetros adicionais disponíveis para a configuração do TOBS lendo a documentação do TOBS

Se você modificar este arquivo para atualizar seu deployment, pode reinstalar o TOBS sobre si mesmo usando a configuração atualizada. Basta passar a opção -f para o comando tobs install com o arquivo YAML como argumento adicional:

tobs install -f values.yaml

Finalmente, você pode atualizar o TOBS com o seguinte comando:

tobs upgrade

Isso realiza o equivalente a um helm upgrade ao buscar o mais recente gráfico upstream.

Conclusão

Neste tutorial, você aprendeu a implantar e configurar o TOBS, The Observability Stack, em um cluster Kubernetes existente. O TOBS é particularmente útil porque elimina a necessidade de manter individualmente detalhes de configuração para cada um desses aplicativos, ao mesmo tempo que fornece monitoramento padronizado para os aplicativos em execução em seu cluster.

Em seguida, você pode querer aprender como usar o Cert-Manager para lidar com o ingresso HTTPS para o seu cluster Kubernetes.

Source:
https://www.digitalocean.com/community/tutorials/how-to-set-up-tobs-the-observability-stack-for-kubernetes-monitoring