Come configurare TOBS, lo stack di osservabilità, per il monitoraggio di Kubernetes

Tutorial

Stato: Obsoleto

Questo articolo è obsoleto e non è più mantenuto.

Motivo

L’installatore di TOBS è stato dichiarato obsoleto a monte.

TOBS, abbreviazione di The Observability Stack, è una distribuzione preconfezionata di strumenti di monitoraggio e interfacce di dashboard che possono essere installati su qualsiasi cluster Kubernetes esistente. Include molti dei più popolari strumenti di osservabilità open-source con Prometheus e Grafana come base, tra cui Promlens, TimescaleDB, Alertmanager e altri. Insieme, questi forniscono una soluzione diretta e mantenibile per analizzare il traffico del server e identificare eventuali problemi potenziali con un deployment fino a una scala molto ampia.

TOBS utilizza i grafici Helm standard di Kubernetes per configurare e aggiornare i deployment. Può essere installato in qualsiasi cluster Kubernetes, ma può essere dimostrato più efficacemente se si sta eseguendo kubectl per gestire il cluster da una macchina locale anziché da un nodo remoto. Il Kubernetes Gestito di DigitalOcean ti fornirà una configurazione del genere per impostazione predefinita.

In questa guida, installerai TOBS in un cluster Kubernetes esistente e imparerai come aggiornare, configurare e navigare nei dashboard dei suoi componenti.

Prerequisiti

Per seguire questa guida, avrai bisogno di:

Un cluster Kubernetes con il controllo degli accessi basato su ruoli (RBAC) abilitato. Questa configurazione utilizzerà un cluster Kubernetes di DigitalOcean, ma sei libero di creare un cluster utilizzando un altro metodo. La versione di Kubernetes deve corrispondere a una versione TOBS supportata.
Il comando da riga di comando kubectl installato sul tuo computer locale e configurato per connettersi al tuo cluster. Puoi leggere ulteriori informazioni sull’installazione di kubectl nella documentazione ufficiale. Se stai utilizzando un cluster Kubernetes di DigitalOcean, consulta Come Connettersi a un Cluster Kubernetes di DigitalOcean per imparare come connetterti al tuo cluster usando kubectl.

Passaggio 1 — Verifica della tua Configurazione Kubernetes

Per installare TOBS, dovresti prima avere una configurazione Kubernetes valida impostata con kubectl da cui puoi pingare i tuoi nodi lavorativi. Puoi testare questo eseguendo kubectl get nodes:

kubectl get nodes

Se kubectl è in grado di connettersi al tuo cluster Kubernetes e funziona come previsto, questo comando restituirà un elenco di nodi con lo stato 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 questo è avvenuto con successo, puoi passare al Passo 2. In caso contrario, dovresti controllare i dettagli della tua configurazione per eventuali problemi.

Per impostazione predefinita, kubectl cercherà un file in ~/.kube/config per comprendere il tuo ambiente. Per verificare che questo file esista e contenga una sintassi YAML valida, puoi eseguire il comando head per visualizzare le prime righe, i:

head ~/.kube/config

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

Se il file non esiste, assicurati di essere loggato come lo stesso utente con cui hai configurato Kubernetes. I percorsi ~/ riflettono le directory home degli utenti individuali e le configurazioni Kubernetes sono salvate per utente per impostazione predefinita.

Se stai utilizzando il Kubernetes gestito da DigitalOcean, assicurati di aver eseguito il comando doctl kubernetes cluster kubeconfig save dopo aver configurato un cluster in modo che la tua macchina locale possa autenticarsi. Questo creerà un file ~/.kube/config:

doctl kubernetes cluster kubeconfig save your-cluster-name

Se stai utilizzando questa macchina per accedere a più cluster, dovresti consultare la documentazione di Kubernetes sull’utilizzo delle variabili d’ambiente e dei file di configurazione multipli per evitare conflitti. Dopo aver configurato l’ambiente kubectl, puoi passare all’installazione di TOBS nel prossimo passaggio.

Passaggio 2 — Installazione di TOBS e Test dei Tuoi Punti Finali

TOBS include i seguenti componenti:

Prometheus è un database di serie temporali e strumento di monitoraggio che funziona interrogando i punti finali delle metriche e raspando e elaborando i dati esposti da questi punti finali. Ti permette di interrogare questi dati usando PromQL, un linguaggio di query di dati a serie temporali.
Alertmanager, di solito distribuito insieme a Prometheus, costituisce il livello di avviso dello stack, gestendo gli avvisi generati da Prometheus e deduplicandoli, raggruppandoli e instradandoli verso integrazioni come email o PagerDuty. Per saperne di più su Alertmanager, consulta la documentazione di Prometheus sull’avviso.
Grafana è uno strumento di visualizzazione dei dati e di analisi che ti permette di creare cruscotti e grafici per i tuoi dati metrici.
kube-state-metrics è un agente aggiuntivo che ascolta il server API di Kubernetes e genera metriche sullo stato degli oggetti Kubernetes come Deployment e Pods. Queste metriche sono servite come testo semplice su punti finali HTTP e consumate da Prometheus.
Ultimamente c’è node-exporter, un’esportazione di Prometheus che viene eseguita sui nodi del cluster e fornisce metriche del sistema operativo e dell’hardware come l’utilizzo della CPU e della memoria a Prometheus. Queste metriche vengono anche servite come testo semplice su endpoint HTTP e consumate da Prometheus.

Per installare TOBS, è necessario prima eseguire l’installatore di TOBS sul tuo control-plane. Questo imposterà il comando tobs e le directory di configurazione. Come indicato nei prerequisiti, il comando tobs è progettato solo per funzionare su sistemi Linux/macOS/BSD (come i binari ufficiali di Kubernetes), quindi se hai usato Windows fino ad ora, dovresti lavorare nell’ambiente Windows Subsystem for Linux.

Recupera ed esegui l’installatore di 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.

Ora puoi caricare TOBS nel tuo cluster Kubernetes. Questo viene fatto con un’unica riga di comando utilizzando il tuo nuovo comando tobs:

tobs install

Questo genererà diverse righe di output e potrebbe richiedere alcuni istanti. A seconda della tua versione esatta di Kubernetes, potrebbero esserci diversi avvisi nell’output, ma puoi ignorarli purché alla fine ricevi il messaggio Benvenuto in 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
…

Da questo punto in poi, l’output conterrà istruzioni per connettersi ad ogni endpoint web di Prometheus, TimescaleDB, PromLens e Grafana nel tuo browser. Viene riprodotto di seguito per riferimento:

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>

Ciascuno di questi è dotato di un nome DNS interno al tuo cluster in modo che possano essere accessibili da qualsiasi dei tuoi nodi lavoratori, ad esempio tobs-kube-prometheus-alertmanager.default.svc.cluster.local per Prometheus. Inoltre, è configurato un comando di forwarding della porta per ciascuno che ti consente di accedervi da un browser web locale.

In un nuovo terminale, esegui tobs prometheus port-forward:

tobs prometheus port-forward

Questo occuperà il terminale finché il processo di forwarding della porta è attivo. Puoi premere Ctrl+C per uscire in modo sicuro da un processo bloccante come questo quando desideri interrompere il forwarding della porta. Successivamente, in un browser web, vai all’URL http://127.0.0.1:9090/. Dovresti vedere l’interfaccia completa di Prometheus in esecuzione e che produce metriche dal tuo cluster:

Puoi fare lo stesso per Grafana, che è accessibile all’indirizzo http://127.0.0.1:8080/ fintanto che il forwarding della porta è attivo in un altro processo. Prima, dovrai utilizzare il comando get-password fornito dall’output dell’installatore:

tobs grafana get-password

Output
your-grafana-password

Puoi quindi utilizzare questa password per accedere all’interfaccia di Grafana eseguendo il suo comando di forwarding della porta e aprendo http://127.0.0.1:8080/ nel tuo browser.

tobs grafana port-forward

Ora hai uno stack TOBS funzionante in esecuzione nel tuo cluster Kubernetes. Puoi fare riferimento alla documentazione dei singoli componenti per apprendere le loro funzionalità rispettive. Nell’ultimo passaggio di questo tutorial, imparerai come apportare aggiornamenti alla configurazione di TOBS stessa.

Passo 3 — Modifica delle Configurazioni di TOBS e Aggiornamento

La configurazione di TOBS contiene alcuni parametri per le singole applicazioni nello stack, così come alcuni parametri per il deployment di TOBS stesso. Viene generata e memorizzata come un chart Helm di Kubernetes. È possibile visualizzare la configurazione attuale eseguendo il comando tobs helm show-values. Tuttavia, questo produrrà l’intera configurazione lunga nel terminale, il che può essere difficile da leggere. È possibile invece reindirizzare l’output su un file con estensione .yaml, poiché i chart Helm sono tutti validi sintassi YAML:

tobs helm show-values > values.yaml

Il contenuto del file avrà questo aspetto:

~/values.yaml

2022/01/10 11:56:37 Transport: unhandled response frame type *http.http2UnknownFrame
# Valori per configurare il deployment di TimescaleDB
# Il README dei chart si trova su:
#    https://github.com/timescale/timescaledb-kubernetes/tree/master/charts/timescaledb-single
# Consultare le varie opzioni di configurazione (guida all'amministrazione) su:
#    https://github.com/timescale/timescaledb-kubernetes/blob/master/charts/timescaledb-single/admin-guide.md
cli: false

# Sovrascrivere il namespace di deployment
namespaceOverride: ""
…

È possibile consultare i parametri aggiuntivi disponibili per la configurazione di TOBS leggendo la documentazione di TOBS

Se mai si modifica questo file per aggiornare il deployment, è possibile reinstallare TOBS su se stesso utilizzando la configurazione aggiornata. Basta passare l’opzione -f al comando tobs install con il file YAML come argomento aggiuntivo:

tobs install -f values.yaml

Finalmente, puoi aggiornare TOBS con il seguente comando:

tobs upgrade

Questo esegue l’equivalente di un helm upgrade scaricando la versione più recente della chart upstream.

Conclusione

In questo tutorial, hai imparato a distribuire e configurare TOBS, The Observability Stack, su un cluster Kubernetes esistente. TOBS è particolarmente utile perché elimina la necessità di mantenere individualmente i dettagli di configurazione per ciascuna di queste app, fornendo al contempo un monitoraggio standardizzato per le applicazioni in esecuzione nel tuo cluster.

In seguito, potresti voler imparare come utilizzare Cert-Manager per gestire l’ingresso HTTPS al tuo cluster Kubernetes.

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