Monitoraggio dei dati delle serie temporali con OpenTSDB su Bigtable e GKE

Last reviewed 2022-01-12 UTC
Questa guida descrive come raccogliere, registrare e monitorare i dati delle serie temporali su Google Cloud utilizzando OpenTSDB in esecuzione su Google Kubernetes Engine (GKE) e Bigtable.

I dati delle serie temporali sono un asset molto importante che puoi utilizzare per varie applicazioni, tra cui tendenze, monitoraggio e machine learning. Puoi generare dati delle serie temporali da infrastruttura server, codice dell'applicazione e altre origini. OpenTSDB può raccogliere e conservare grandi quantità di dati delle serie temporali con un elevato livello di granularità.

Questa guida mostra architetti e ingegneri del software come creare un livello di raccolta scalabile per i dati delle serie temporali utilizzando GKE. Illustra inoltre come utilizzare Bigtable con i dati raccolti. Questa guida presuppone che tu abbia familiarità con Kubernetes e Bigtable.

Il seguente diagramma mostra l'architettura generale di questa guida:

Origini dei dati delle serie temporali archiviati in Bigtable.

Il diagramma precedente mostra più origini di dati delle serie temporali, come eventi IoT e metriche di sistema, archiviate in Bigtable mediante OpenTSDB di cui è stato eseguito il deployment su GKE.

Obiettivi

  • Creare le immagini container utilizzate in questa guida utilizzando Cloud Build.
  • Gestisci queste immagini container utilizzando Artifact Registry.
  • Creare un'istanza Bigtable.
  • Creare un cluster GKE.
  • Esegui il deployment di OpenTSDB nel tuo cluster GKE.
  • Invia le metriche delle serie temporali a OpenTSDB.
  • Visualizza le metriche utilizzando OpenTSDB e Grafana.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

  1. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  2. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  3. Abilita le API Bigtable, Bigtable Admin, GKE, Compute Engine, Cloud Build, and Artifact Registry.

    Abilita le API

  4. Nella console Google Cloud, vai alla pagina Ti diamo il benvenuto.

    Vai alla pagina di benvenuto

    Prendi nota dell'ID progetto, perché verrà utilizzato in un passaggio successivo.

  5. Nella console Google Cloud, attiva Cloud Shell.

    Attiva Cloud Shell

Crea un'istanza Bigtable

Questa guida utilizza Bigtable per archiviare i dati delle serie temporali raccolti, quindi devi creare un'istanza Bigtable.

Bigtable è un archivio di chiavi/a colonne larghe che funziona bene per i dati delle serie temporali. Bigtable supporta l'API HBase, quindi puoi utilizzare software progettato per funzionare con Apache HBase, come OpenTSDB. Per saperne di più sullo schema HBase utilizzato da OpenTSDB, consulta la pagina Schema HBase.

Un componente chiave di OpenTSDB è il client AsyncHBase, che consente di scrivere in blocco in HBase in modo completamente asincrono, non bloccante e sicuro per i thread. Quando utilizzi OpenTSDB con Bigtable, AsyncHBase viene implementato come client AsyncBigtable.

Questa guida utilizza un'istanza Bigtable con un cluster a nodo singolo. Quando passi a un ambiente di produzione, valuta l'utilizzo di istanze di Bigtable con cluster più grandi. Per ulteriori informazioni sulla scelta delle dimensioni del cluster, consulta Informazioni sulle prestazioni di Bigtable.

  1. In Cloud Shell, imposta le variabili di ambiente per la zona Google Cloud in cui creerai il cluster Bigtable e il cluster GKE, nonché l'identificatore di istanza per il cluster Bigtable:

    export BIGTABLE_INSTANCE_ID=BIGTABLE_INSTANCE_ID
export ZONE=ZONE

    Sostituisci quanto segue:

    • BIGTABLE_INSTANCE_ID: l'identificatore dell'istanza Bigtable.
    • ZONE: la zona in cui verranno creati il cluster Bigtable e il cluster GKE.

    Il comando dovrebbe essere simile al seguente esempio:

    export BIGTABLE_INSTANCE_ID=bt-opentsdb
export ZONE=us-central1-f

  2. Crea l'istanza Bigtable:

    gcloud bigtable instances create ${BIGTABLE_INSTANCE_ID} \
    --cluster-config=id=${BIGTABLE_INSTANCE_ID}-${ZONE},zone=${ZONE},nodes=1 \
    --display-name=OpenTSDB

Crea le immagini utilizzate per eseguire il deployment e testare OpenTSDB

Per eseguire il deployment e dimostrare OpenTSDB con un backend di archiviazione Bigtable, questa guida utilizza una serie di immagini container Docker di cui è stato eseguito il deployment in GKE. Puoi creare molte di queste immagini utilizzando il codice di un repository GitHub associato a Cloud Build. Quando esegui il deployment dell'infrastruttura in GKE, viene utilizzato un repository di container. In questa guida, utilizzerai Artifact Registry per gestire queste immagini container.

  1. In Cloud Shell, imposta le variabili di ambiente per la zona Google Cloud in cui creerai il repository Artifact Registry:

    export PROJECT_ID=PROJECT_ID
export REGION=REGION
export AR_REPO=AR_REPO

    Sostituisci quanto segue:

    • PROJECT_ID: il tuo ID progetto
    • REGION: la regione in cui verrà creato il repository Artifact Registry
    • AR_REPO: il nome del tuo repository Artifact Registry

    Il comando dovrebbe essere simile al seguente esempio:

    export PROJECT_ID=bt-opentsdb-project-id
export REGION=us-central1
export AR_REPO=opentsdb-bt-repo

  2. Crea un repository Artifact Registry:

    gcloud artifacts repositories create ${AR_REPO} \
    --repository-format=docker  \
    --location=${REGION} \
    --description="OpenTSDB on bigtable container images"

Crea e gestisci le immagini utilizzate per il deployment e la dimostrazione di OpenTSDB

In questa guida vengono utilizzate due immagini container Docker. La prima immagine viene utilizzata per due scopi: per eseguire la configurazione una tantum del database Bigtable per OpenTSDB e per il deployment dei container di servizio di lettura e scrittura per il deployment di OpenTSDB. La seconda immagine viene utilizzata per generare dati delle metriche di esempio per dimostrare il deployment OpenTSDB.

Quando invii il job di build delle immagini container a Cloud Build, tagghi le immagini in modo che vengano archiviate in Artifact Registry dopo la loro creazione.

  1. In Cloud Shell, clona il repository GitHub che contiene il codice associato:

    git clone https://github.com/GoogleCloudPlatform/opentsdb-bigtable.git

  2. Vai alla directory codice campione:

    cd opentsdb-bigtable

  3. Imposta le variabili di ambiente per l'immagine del server OpenTSDB che utilizza Bigtable come backend di archiviazione:

    export SERVER_IMAGE_NAME=opentsdb-server-bigtable
export SERVER_IMAGE_TAG=2.4.1

  4. Crea l'immagine utilizzando Cloud Build:

    gcloud builds submit \
    --tag ${REGION}-docker.pkg.dev/${PROJECT_ID}/${AR_REPO}/${SERVER_IMAGE_NAME}:${SERVER_IMAGE_TAG} \
    build

    Poiché hai assegnato un tag appropriato all'immagine, al completamento della build, l'immagine verrà gestita dal tuo repository Artifact Registry.

  5. Imposta le variabili di ambiente per l'immagine di generazione dati della serie temporale dimostrativa:

    export GEN_IMAGE_NAME=opentsdb-timeseries-generate
export GEN_IMAGE_TAG=0.1

  6. Crea l'immagine utilizzando Cloud Build:

    cd generate-ts
./build-cloud.sh
cd ..

crea un cluster GKE

GKE fornisce un ambiente Kubernetes gestito. Dopo aver creato un cluster GKE, puoi eseguire il deployment dei pod Kubernetes. Questa guida utilizza i pod di GKE e Kubernetes per eseguire OpenTSDB.

OpenTSDB separa il suo spazio di archiviazione dal livello dell'applicazione, che ne consente il deployment contemporaneamente su più istanze. Grazie all'esecuzione in parallelo, OpenTSDB è in grado di gestire una grande quantità di dati delle serie temporali.

  1. In Cloud Shell, imposta le variabili di ambiente per la zona Google Cloud in cui creerai il cluster Bigtable e il cluster GKE, nonché il nome, il tipo di nodo e la versione per il tuo cluster GKE:

    export GKE_CLUSTER_NAME=GKE_CLUSTER_NAME
export GKE_VERSION=1.20
export GKE_NODE_TYPE=n1-standard-4

    Sostituisci GKE_CLUSTER_NAME con il nome del tuo cluster GKE.

    Il comando dovrebbe essere simile al seguente esempio:

    export GKE_CLUSTER_NAME=gke-opentsdb
export GKE_VERSION=1.20
export GKE_NODE_TYPE=n1-standard-4

  2. Crea un cluster GKE:

    gcloud container clusters create ${GKE_CLUSTER_NAME} \
    --zone=${ZONE} \
    --cluster-version=${GKE_VERSION} \
    --machine-type ${GKE_NODE_TYPE} \
    --scopes "https://www.googleapis.com/auth/cloud-platform"

    Questa operazione può richiedere alcuni minuti. L'aggiunta di ambiti al cluster GKE consente al container OpenTSDB di interagire con Bigtable e Container Registry.

    Il resto della guida utilizza i container che hai appena creato gestiti da Artifact Registry. Lo script Dockerfile e entrypoint utilizzato per creare il container si trova nella cartella build del repository delle guide.

  3. Recupera le credenziali per connetterti al tuo cluster GKE:

    gcloud container clusters get-credentials ${GKE_CLUSTER_NAME} --zone ${ZONE}

crea un ConfigMap con i dettagli di configurazione

Kubernetes utilizza ConfigMap per disaccoppiare i dettagli di configurazione dall'immagine del container, al fine di rendere le applicazioni più portabili. La configurazione per OpenTSDB è specificata nel file opentsdb.conf. Un ConfigMap contenente il file opentsdb.conf è incluso nel codice campione.

In questo passaggio e in quelli successivi, utilizzerai l'utilità GNU envsubst per sostituire i segnaposto variabile di ambiente nei file YAML del modello che corrispondono ai rispettivi valori per il deployment.

  • Crea un ConfigMap dal file opentsdb-config.yaml aggiornato:

    envsubst < configmaps/opentsdb-config.yaml.tpl | kubectl create -f -

Creazione di tabelle OpenTSDB in Bigtable

Prima di poter leggere o scrivere dati utilizzando OpenTSDB, devi creare tabelle in Bigtable per archiviare i dati. Per creare le tabelle, devi creare un job Kubernetes.

  1. In Cloud Shell, avvia il job:

    envsubst < jobs/opentsdb-init.yaml.tpl | kubectl create -f -

    Il completamento del job può richiedere fino a un minuto o più. Verifica che il job sia stato completato correttamente:

    kubectl describe jobs

    L'output mostra che un job ha avuto esito positivo quando Pods Statuses mostra 1 Succeeded

  2. Esamina i log del job di creazione della tabella:

    OPENTSDB_INIT_POD=$(kubectl get pods --selector=job-name=opentsdb-init \
                    --output=jsonpath={.items..metadata.name})
kubectl logs $OPENTSDB_INIT_POD

    L'output è simile al seguente:

    create 'tsdb-uid',
  {NAME => 'id', COMPRESSION => 'NONE', BLOOMFILTER => 'ROW', DATA_BLOCK_ENCODING => 'DIFF'},
  {NAME => 'name', COMPRESSION => 'NONE', BLOOMFILTER => 'ROW', DATA_BLOCK_ENCODING => 'DIFF'}
0 row(s) in 3.2730 seconds

create 'tsdb',
  {NAME => 't', VERSIONS => 1, COMPRESSION => 'NONE', BLOOMFILTER => 'ROW', DATA_BLOCK_ENCODING => 'DIFF'}
0 row(s) in 1.8440 seconds

create 'tsdb-tree',
  {NAME => 't', VERSIONS => 1, COMPRESSION => 'NONE', BLOOMFILTER => 'ROW', DATA_BLOCK_ENCODING => 'DIFF'}
0 row(s) in 1.5420 seconds

create 'tsdb-meta',
  {NAME => 'name', COMPRESSION => 'NONE', BLOOMFILTER => 'ROW', DATA_BLOCK_ENCODING => 'DIFF'}
0 row(s) in 1.9910 seconds

    L'output elenca ogni tabella creata. Questo job esegue diversi comandi di creazione della tabella, ognuno nel formato create TABLE_NAME. Le tabelle vengono create correttamente quando l'output è presente sotto forma di 0 row(s) in TIME seconds.

    • TABLE_NAME: il nome della tabella creata dal job
    • TIME: il tempo necessario per creare la tabella

Modello dati

Le tabelle che hai creato archiviano i punti dati da OpenTSDB. In un passaggio successivo, scriverai i dati delle serie temporali in queste tabelle. I punti dati delle serie temporali vengono organizzati e archiviati come segue:

Campo Obbligatorio Descrizione Esempio
metric Obbligatorio Elemento in fase di misurazione: chiave predefinita sys.cpu.user
timestamp Obbligatorio Data/ora del periodo Unix della misurazione 1497561091
tags È richiesto almeno un tag Qualifica la misurazione ai fini dell'esecuzione di query hostname=www cpu=0 env=prod
value Obbligatorio Valore di misurazione 89,3

La metrica, il timestamp e i tag (chiave tag e valore tag) costituiscono la chiave di riga. Il timestamp è normalizzato a un'ora per garantire che una riga non contenga troppi punti dati. Per maggiori informazioni, consulta Schema HBase.

Esegui il deployment di OpenTSDB

Il seguente diagramma mostra l'architettura di deployment per OpenTSTB con i suoi servizi in esecuzione su GKE e con Bigtable come backend di archiviazione:

Due deployment Kubernetes OpenTSDB.

Questa guida utilizza due deployment Kubernetes OpenTSDB: un deployment invia le metriche a Bigtable e l'altro da questo deployment. L'utilizzo di due deployment impedisce che le letture e le scritture a lunga esecuzione si blocchino a vicenda. I pod in ogni deployment utilizzano la stessa immagine container. OpenTSDB fornisce un daemon chiamato tsd che viene eseguito in ogni container. Un singolo processo tsd è in grado di gestire un'elevata velocità effettiva di eventi al secondo. Per distribuire il carico, ogni deployment in questa guida crea tre repliche dei pod di lettura e scrittura.

  1. In Cloud Shell, crea un deployment per la scrittura di metriche:

    envsubst < deployments/opentsdb-write.yaml.tpl | kubectl create -f  -

    Le informazioni di configurazione per il deployment di scrittura sono disponibili nel file opentsdb-write.yaml.tpl nella cartella deployments del repository della guida.

  2. Crea un deployment per la lettura delle metriche:

    envsubst < deployments/opentsdb-read.yaml.tpl | kubectl create -f  -

    Le informazioni sulla configurazione per il deployment dei lettori sono disponibili nel file opentsdb-read.yaml.tpl nella cartella deployments del repository della guida.

In un deployment di produzione, puoi aumentare il numero di pod tsd in esecuzione, manualmente o utilizzando la scalabilità automatica in Kubernetes. Allo stesso modo, puoi aumentare il numero di istanze nel tuo cluster GKE manualmente o utilizzando il gestore della scalabilità automatica dei cluster.

crea i servizi OpenTSDB

Per fornire una connettività di rete coerente ai deployment, crei due servizi Kubernetes: un servizio scrive le metriche in OpenTSDB e l'altro legge.

  1. In Cloud Shell, crea il servizio per la scrittura delle metriche:

    kubectl create -f services/opentsdb-write.yaml

    Le informazioni di configurazione per il servizio di scrittura delle metriche sono contenute nel file opentsdb-write.yaml nella cartella services del repository della guida. Questo servizio viene creato all'interno del cluster Kubernetes ed è raggiungibile da altri servizi in esecuzione nel cluster.

  2. Crea il servizio per la lettura delle metriche:

    kubectl create -f services/opentsdb-read.yaml

    Le informazioni di configurazione per il servizio di lettura delle metriche sono contenute nel file opentsdb-read.yaml nella cartella services del repository delle guide.

Scrivi i dati delle serie temporali in OpenTSDB

Esistono diversi meccanismi per scrivere dati in OpenTSDB. Dopo aver definito gli endpoint di servizio, puoi indirizzare i processi all'inizio della scrittura di dati. Questa guida esegue il deployment di un servizio Python che emette dati dimostrativi delle serie temporali per due metriche: Utilizzo della memoria del cluster (memory_usage_gauge) e Utilizzo della CPU del cluster (cpu_node_utilization_gauge).

  • In Cloud Shell, esegui il deployment del generatore di metriche delle serie temporali nel tuo cluster:

    envsubst < deployments/generate.yaml.tpl | kubectl create -f -

Esaminare i dati delle serie temporali di esempio con OpenTSDB

Puoi eseguire query sulle metriche delle serie temporali utilizzando l'endpoint di servizio opentsdb-read di cui hai eseguito il deployment in precedenza nella guida. Puoi utilizzare i dati in vari modi. Un'opzione comune è visualizzarla. OpenTSDB include un'interfaccia di base per visualizzare le metriche raccolte. Questa guida utilizza Grafana, una popolare alternativa per visualizzare le metriche che offre funzionalità aggiuntive.

L'esecuzione di Grafana nel cluster richiede una procedura simile a quella utilizzata per configurare OpenTSDB. Oltre a creare un ConfigMap e un deployment, devi configurare il port forwarding in modo da poter accedere a Grafana mentre è in esecuzione nel tuo cluster Kubernetes.

  1. In Cloud Shell, crea il ConfigMap di Grafana utilizzando le informazioni di configurazione nel file grafana.yaml nella cartella configmaps del repository delle guide:

    kubectl create -f configmaps/grafana.yaml

  2. Crea il deployment Grafana utilizzando le informazioni di configurazione nel file grafana.yaml nella cartella deployments del repository della guida:

    kubectl create -f deployments/grafana.yaml

  3. Ottieni il nome del pod Grafana nel cluster e utilizzalo per configurare il port forwarding:

    GRAFANA_PODS=$(kubectl get pods --selector=app=grafana \
               --output=jsonpath={.items..metadata.name})
kubectl port-forward $GRAFANA_PODS 8080:3000

    Verifica che l'inoltro sia riuscito. L'output è simile al seguente:

    Forwarding from 127.0.0.1:8080 -> 3000

  4. Per connetterti all'interfaccia web di Grafana, in Cloud Shell fai clic su Anteprima web e seleziona Anteprima sulla porta 8080.

    Per maggiori informazioni, consulta Utilizzare l'anteprima web.

    Si apre una nuova scheda del browser che si collega all'interfaccia web di Grafana. Dopo qualche istante, il browser visualizza grafici come il seguente:

    Grafico a linee che mostra le metriche del cluster.

    Questa implementazione di Grafana è stata personalizzata per questa guida. I file configmaps/grafana.yaml e deployments/grafana.yaml configurano Grafana per la connessione al servizio opentsdb-read, consentire l'autenticazione anonima e visualizzare alcune metriche di base del cluster. Per un deployment di Grafana in un ambiente di produzione, ti consigliamo di implementare i meccanismi di autenticazione adeguati e di utilizzare grafici delle serie temporali più completi.

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina le singole risorse

  1. Elimina il cluster Kubernetes per eliminare tutti gli artefatti che hai creato:

    gcloud container clusters delete GKE_CLUSTER_NAME

    Per eliminare il cluster Kubernetes, conferma digitando Y.

  2. Per eliminare l'istanza Bigtable:

    1. Nella console Google Cloud, vai a Bigtable.

      Vai a Bigtable

    2. Seleziona l'istanza creata in precedenza, quindi fai clic su Elimina istanza.

Elimina il progetto

  1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi