Esegui il deployment del monitoraggio distribuito per osservare la latenza dei microservizi

Last reviewed 2023-08-11 UTC

Questo documento mostra come eseguire il deployment dell'architettura di riferimento descritta in Utilizzare il monitoraggio distribuito per osservare la latenza dei microservizi. Il deployment illustrato in questo documento acquisisce informazioni sulle tracce nelle applicazioni di microservizi che utilizzano OpenTelemetry e Cloud Trace.

L'applicazione di esempio in questo deployment è composta da due microserviziscritti in Go.

Questo documento presuppone che tu abbia familiarità con quanto segue:

• Il linguaggio di programmazione Go
• Google Kubernetes Engine (GKE)

Obiettivi

• Crea un cluster GKE ed esegui il deployment di un'applicazione di esempio.
• Esamina il codice di strumentazione OpenTelemetry.
• Esamina le tracce e i log generati dalla misurazione.

Architettura

Il seguente diagramma mostra l'architettura di cui esegui il deployment.

Utilizzi Cloud Build, una piattaforma di integrazione continua, distribuzione e deployment completamente gestita, per creare immagini container dal codice campione e archiviarle in Artifact Registry. I cluster GKE estraggono le immagini da Artifact Registry al momento del deployment.

Il servizio frontend accetta le richieste HTTP sull'URL / e chiama il servizio di backend. L'indirizzo del servizio di backend è definito da una variabile di ambiente.

Il servizio di backend accetta le richieste HTTP sull'URL /e effettua una chiamata in uscita a un URL esterno come definito in una variabile di ambiente. Al termine della chiamata esterna, il servizio di backend restituisce al chiamante la chiamata dello stato HTTP (ad esempio 200).

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

• GKE
• Compute Engine
• Cloud Trace
• Cloud Build
• Artifact Registry

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Al termine delle attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la sezione Pulizia.

Prima di iniziare

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the GKE, Cloud Trace, Cloud Build, Cloud Storage, and Artifact Registry APIs.

   Enable the APIs

5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

6. Make sure that billing is enabled for your Google Cloud project.

7. Enable the GKE, Cloud Trace, Cloud Build, Cloud Storage, and Artifact Registry APIs.

   Enable the APIs

Configura l'ambiente

In questa sezione, configuri l'ambiente con gli strumenti che utilizzi durante il deployment. Esegui tutti i comandi del terminale in questo deployment da Cloud Shell.

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Imposta una variabile di ambiente sull'ID del tuo progetto Google Cloud:

   export PROJECT_ID=$(gcloud config list --format 'value(core.project)' 2>/dev/null)
   

3. Scarica i file necessari per questo deployment clonando il repository Git associato:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
   cd kubernetes-engine-samples/observability/distributed-tracing
   WORKDIR=$(pwd)
   

   Imposta la cartella del repository come directory di lavoro ($WORKDIR) da cui svolgere tutte le attività relative a questo deployment. In questo modo, se non vuoi conservare le risorse, puoi eliminare la cartella al termine del deployment.

Installa gli strumenti

1. In Cloud Shell, installa kubectx e kubens:

   git clone https://github.com/ahmetb/kubectx $WORKDIR/kubectx
   export PATH=$PATH:$WORKDIR/kubectx
   

   Utilizza questi strumenti per lavorare con più cluster, contesti e spazi dei nomi Kubernetes.

2. In Cloud Shell, installa Apache Bench, uno strumento di generazione di carico open source:

   sudo apt-get install apache2-utils
   

Crea un repository Docker

Crea un repository Docker per archiviare l'immagine di esempio per questo deployment.

Console

1. Nella console Google Cloud, apri la pagina Repositori.

   Apri la pagina Repository

2. Fai clic su Crea repository.

3. Specifica distributed-tracing-docker-repo come nome del repository.

4. Scegli Docker come formato e Standard come modalità.

5. In Tipo di località, seleziona Regione, quindi scegli la localitàus-west1.

6. Fai clic su Crea.

Il repository viene aggiunto all'elenco dei repository.

gcloud

1. In Cloud Shell, crea un nuovo repository Docker denominato distributed-tracing-docker-repo nella località us-west1 con la descrizione docker repository:

   gcloud artifacts repositories create distributed-tracing-docker-repo --repository-format=docker \
   --location=us-west1 --description="Docker repository for distributed tracing deployment"
   

2. Verifica che il repository sia stato creato:

   gcloud artifacts repositories list
   

Creare cluster GKE

In questa sezione crei due cluster GKE in cui eseguire il deployment dell'applicazione di esempio. Per impostazione predefinita, i cluster GKE vengono creati con accesso di sola scrittura all'Cloud Trace API, pertanto non è necessario definire l'accesso quando crei i cluster.

1. In Cloud Shell, crea i cluster:

   gcloud container clusters create backend-cluster \
       --zone=us-west1-a \
       --verbosity=none --async
   
   gcloud container clusters create frontend-cluster \
       --zone=us-west1-a \
       --verbosity=none
   

   In questo esempio, i cluster si trovano nella zona us-west1-a. Per ulteriori informazioni, consulta Geografia e regioni.

2. Recupera le credenziali del cluster e memorizzale localmente:

   gcloud container clusters get-credentials backend-cluster --zone=us-west1-a
   gcloud container clusters get-credentials frontend-cluster --zone=us-west1-a
   

3. Rinomina i contesti dei cluster per accedervi più facilmente più avanti nel deployment:

   kubectx backend=gke_${PROJECT_ID}_us-west1-a_backend-cluster
   kubectx frontend=gke_${PROJECT_ID}_us-west1-a_frontend-cluster
   

Rivedi l'instrumentazione OpenTelemetry

Nelle sezioni seguenti esamini il codice del file main.go nell'applicazione di esempio. Questo ti aiuta a capire come utilizzare la propagazione del contesto per consentire di aggiungere gli span di più richieste a una singola traccia principale.

Esamina le importazioni nel codice dell'applicazione

import (
	"context"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"strconv"

	cloudtrace "github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/trace"
	"github.com/gorilla/mux"
	"go.opentelemetry.io/contrib/detectors/gcp"
	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
	"go.opentelemetry.io/contrib/propagators/autoprop"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/sdk/resource"
	"go.opentelemetry.io/otel/sdk/trace"
)

Tieni presente quanto segue sulle importazioni:

• Il pacchetto go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp contiene il plug-in otelhttp, che può eseguire l'instrumentazione di un server HTTP o di un client HTTP. La misurazione del server recupera il contesto dello span dalla richiesta HTTP e registra un span per la gestione della richiesta da parte del server. La misurazione del client inietta il contesto dell'elemento nell'ambito della richiesta HTTP in uscita e registra un elemento per il tempo impiegato per attendere una risposta.
• Il pacchetto go.opentelemetry.io/contrib/propagators/autoprop fornisce un'implementazione dell'interfaccia TextMapPropagator di OpenTelemetry, che viene utilizzata da otelhttp per gestire la propagazione. I propagatori determinano il formato e le chiavi utilizzati per memorizzare il contesto della traccia in trasporti come HTTP. Nello specifico, otelhttp passa le intestazioni HTTP al propagatore. Il propagatore estrae un contesto span in un contesto Go dalle intestazioni oppure codifica e inietta un contesto span nel contesto Go nelle intestazioni (a seconda che si tratti di client o server). Per impostazione predefinita, il pacchetto autoprop inietta ed estrae il contesto dell'intervallo utilizzando il formato di propagazione del contesto della traccia W3C.
• L'importazione github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/trace esporta le tracce in Cloud Trace.
• L'importazione github.com/gorilla/mux è la libreria utilizzata dall'applicazione di esempio per la gestione delle richieste.
• L'importazione go.opentelemetry.io/contrib/detectors/gcp aggiunge attributi ai tratti, ad esempio cloud.availability_zone, che identificano dove viene eseguita la tua applicazione in Google Cloud.
• Le importazioni go.opentelemetry.io/otel, go.opentelemetry.io/otel/sdk/trace e go.opentelemetry.io/otel/sdk/resource utilizzate per configurare OpenTelemetry.

Esamina la funzione main

La funzione main configura l'esportazione delle tracce in Cloud Trace e utilizza un router mux per gestire le richieste inviate all'URL /.

func main() {
	ctx := context.Background()
	// Set up the Cloud Trace exporter.
	exporter, err := cloudtrace.New()
	if err != nil {
		log.Fatalf("cloudtrace.New: %v", err)
	}
	// Identify your application using resource detection.
	res, err := resource.New(ctx,
		// Use the GCP resource detector to detect information about the GKE Cluster.
		resource.WithDetectors(gcp.NewDetector()),
		resource.WithTelemetrySDK(),
	)
	if err != nil {
		log.Fatalf("resource.New: %v", err)
	}
	tp := trace.NewTracerProvider(
		trace.WithBatcher(exporter),
		trace.WithResource(res),
	)
	// Set the global TracerProvider which is used by otelhttp to record spans.
	otel.SetTracerProvider(tp)
	// Flush any pending spans on shutdown.
	defer tp.ForceFlush(ctx)

	// Set the global Propagators which is used by otelhttp to propagate
	// context using the w3c traceparent and baggage formats.
	otel.SetTextMapPropagator(autoprop.NewTextMapPropagator())

	// Handle incoming request.
	r := mux.NewRouter()
	r.HandleFunc("/", mainHandler)
	var handler http.Handler = r

	// Use otelhttp to create spans and extract context for incoming http
	// requests.
	handler = otelhttp.NewHandler(handler, "server")
	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%v", os.Getenv("PORT")), handler))
}

Tieni presente quanto segue in merito a questo codice:

• Configura un TracerProvider OpenTelemetry, che rileva gli attributi quando viene eseguito su Google Cloud ed esporta le tracce in Cloud Trace.
• Utilizza le funzioni otel.SetTracerProvider e otel.SetTextMapPropagators per impostare le impostazioni globali TracerProvider e Propagator. Per impostazione predefinita, le librerie di strumenti come otelhttp utilizzano il TracerProvider registrato a livello globale per creare gli span e il Propagator per propagare il contesto.
• Avvolgi il server HTTP con otelhttp.NewHandler per misurarlo.

Esamina la funzione mainHandler

func mainHandler(w http.ResponseWriter, r *http.Request) {
	// Use otelhttp to record a span for the outgoing call, and propagate
	// context to the destination.
	destination := os.Getenv("DESTINATION_URL")
	resp, err := otelhttp.Get(r.Context(), destination)
	if err != nil {
		log.Fatal("could not fetch remote endpoint")
	}
	defer resp.Body.Close()
	_, err = ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatalf("could not read response from %v", destination)
	}

	fmt.Fprint(w, strconv.Itoa(resp.StatusCode))
}

Per acquisire la latenza delle richieste in uscita inviate alla destinazione, utilizza il plug-in otelhttp per effettuare una richiesta HTTP. Utilizza anche la funzione r.Context per collegare la richiesta in arrivo a quella in uscita, come mostrato nella seguente scheda:

// Use otelhttp to record a span for the outgoing call, and propagate
// context to the destination.
resp, err := otelhttp.Get(r.Context(), destination)

Esegui il deployment dell'applicazione

In questa sezione utilizzerai Cloud Build per creare immagini container per i servizi frontend e backend. che poi vengono implementati nei loro cluster GKE.

Crea il container Docker

1. In Cloud Shell, invia la compilazione dalla directory di lavoro:

   cd $WORKDIR
   gcloud builds submit . --tag us-west1-docker.pkg.dev/$PROJECT_ID/distributed-tracing-docker-repo/backend:latest
   

2. Verifica che l'immagine del contenitore sia stata creata correttamente e sia disponibile in Artifact Registry:

   gcloud artifacts docker images list us-west1-docker.pkg.dev/$PROJECT_ID/distributed-tracing-docker-repo
   

   L'immagine del contenitore è stata creata correttamente quando l'output è simile al seguente, dove PROJECT_ID è l'ID del tuo progetto Google Cloud:

   NAME
   us-west1-docker.pkg.dev/PROJECT_ID/distributed-tracing-docker-repo/backend
   

Esegui il deployment del servizio di backend

1. In Cloud Shell, imposta il contesto kubectx sul cluster backend:

   kubectx backend
   

2. Crea il file YAML per il deployment di backend:

   export PROJECT_ID=$(gcloud info --format='value(config.project)')
   envsubst < backend-deployment.yaml | kubectl apply -f -
   

3. Verifica che i pod siano in esecuzione:

   kubectl get pods
   

   L'output mostra un valore Status di Running:

   NAME                       READY   STATUS    RESTARTS   AGE
   backend-645859d95b-7mx95   1/1     Running   0          52s
   backend-645859d95b-qfdnc   1/1     Running   0          52s
   backend-645859d95b-zsj5m   1/1     Running   0          52s
   

4. Esponi il deployment backend utilizzando un bilanciatore del carico:

   kubectl expose deployment backend --type=LoadBalancer
   

5. Ottieni l'indirizzo IP del servizio backend:

   kubectl get services backend
   

   L'output è simile al seguente:

   NAME      TYPE           CLUSTER-IP     EXTERNAL-IP    PORT(S)          AGE
   backend   LoadBalancer   10.11.247.58   34.83.88.143   8080:30714/TCP   70s
   

   Se il valore del campo EXTERNAL-IP è <pending>, ripeti il comando finché il valore non è un indirizzo IP.

6. Acquisisci l'indirizzo IP del passaggio precedente in una variabile:

   export BACKEND_IP=$(kubectl get svc backend -ojson | jq -r '.status.loadBalancer.ingress[].ip')
   

Esegui il deployment del servizio di frontend

1. In Cloud Shell, imposta il contesto kubectx sul cluster di backend:

   kubectx frontend
   

2. Crea il file YAML per il deployment di frontend:

   export PROJECT_ID=$(gcloud info --format='value(config.project)')
   envsubst < frontend-deployment.yaml | kubectl apply -f -
   

3. Verifica che i pod siano in esecuzione:

   kubectl get pods
   

   L'output mostra un valore Status di Running:

   NAME                        READY   STATUS    RESTARTS   AGE
   frontend-747b445499-v7x2w   1/1     Running   0          57s
   frontend-747b445499-vwtmg   1/1     Running   0          57s
   frontend-747b445499-w47pf   1/1     Running   0          57s
   

4. Esponi il deployment frontend utilizzando un bilanciatore del carico:

   kubectl expose deployment frontend --type=LoadBalancer
   

5. Ottieni l'indirizzo IP del servizio frontend:

   kubectl get services frontend
   

   L'output è simile al seguente:

   NAME       TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)         AGE
   frontend   LoadBalancer   10.27.241.93   34.83.111.232   8081:31382/TCP  70s
   

   Se il valore del campo EXTERNAL-IP è <pending>, ripeti il comando finché il valore non è un indirizzo IP.

6. Acquisisci l'indirizzo IP del passaggio precedente in una variabile:

   export FRONTEND_IP=$(kubectl get svc frontend -ojson | jq -r '.status.loadBalancer.ingress[].ip')
   

Carica l'applicazione e rivedi le tracce

In questa sezione utilizzerai l'utilità Apache Bench per creare richieste per la tua applicazione. Poi, esamini le tracce risultanti in Cloud Trace.

1. In Cloud Shell, utilizza Apache Bench per generare 1000 richieste utilizzando 3 thread simultanei:

   ab -c 3 -n 1000 http://${FRONTEND_IP}:8081/
   

2. Nella console Google Cloud, vai alla pagina Elenco di tracciamenti.

   Vai a Elenco Trace

3. Per esaminare la cronologia, fai clic su uno degli URI etichettati come server.

   

   Questa traccia contiene quattro span con i seguenti nomi:

   • Il primo intervallo server acquisisce la latenza end-to-end della gestione della richiesta HTTP nel server frontend.
   • Il primo span HTTP GET acquisisce la latenza della chiamata GET effettuata dal client del frontend al backend.
   • Il secondo intervallo server acquisisce la latenza end-to-end della gestione della richiesta HTTP nel server di backend.
   • Il secondo span HTTP GET acquisisce la latenza della chiamata GET effettuata dal client del backend a google.com.

   

Esegui la pulizia

Il modo più semplice per eliminare la fatturazione è eliminare il progetto Google Cloud che hai creato per il deployment. In alternativa, puoi eliminare le singole risorse.

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:
• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini elimini anche tutto il lavoro svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.
1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Elimina singole risorse

Per eliminare singole risorse anziché l'intero progetto, esegui i seguenti comandi in Cloud Shell:

gcloud container clusters delete frontend-cluster --zone=us-west1-a
gcloud container clusters delete backend-cluster --zone=us-west1-a
gcloud artifacts repositories delete distributed-tracing-docker-repo --location us-west1

Passaggi successivi

• Scopri di più su OpenTelemetry.
• Per altre architetture di riferimento, diagrammi e best practice, visita il Cloud Architecture Center.