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 descritti in Utilizza il tracciamento distribuito per osservare la latenza dei microservizi. Il deployment illustrato in questo documento acquisisce le informazioni di traccia su applicazioni basate su microservizi utilizzando OpenTelemetry e Cloud Trace.

L'applicazione di esempio in questo deployment è composta da due microservizi che sono scritte in Vai.

In questo documento si presuppone che tu conosca i seguenti concetti:

• 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.
• Rivedi le tracce e i log generati dalla strumentazione.

Architettura

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

Utilizzi Cloud Build: un completamente gestita per l'integrazione continua, la distribuzione e il deployment creare immagini container dal codice campione e archiviarle 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 la chiamata dello stato HTTP (ad esempio, 200) al chiamante.

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.

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. 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 richiesti per questo deployment clonando 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à correlate a questo deployment. In questo modo, se non vuoi conservare le risorse, puoi eliminare la cartella al termine del deployment.

Installazione di strumenti

1. In Cloud Shell, installa kubectx e kubens:

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

   Questi strumenti sono utili per lavorare con più cluster, contesti, e spazi dei nomi.

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 in cui archiviare l'immagine di esempio per questo deployment.

Console

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

   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 di 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 creerai due cluster GKE in cui eseguirai il deployment dell'applicazione di esempio. Per impostazione predefinita, i cluster GKE vengono creati con accesso di sola scrittura all'API Cloud Trace, 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 maggiori informazioni le informazioni, vedi Area geografica e regioni.

2. Ottieni le credenziali del cluster e archiviale 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 facilitarne l'accesso 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 la strumentazione OpenTelemetry

Nelle sezioni seguenti esamini il codice del file main.go nell'applicazione di esempio. Questo ti aiuta a imparare a utilizzare la propagazione del contesto per consentire intervalli di più richieste da aggiungere a una singola traccia padre.

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:

• Pacchetto go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp contiene il plug-in otelhttp, che può instrumentare un server HTTP o HTTP di alto profilo. La strumentazione del server recupera span context dalla richiesta HTTP e registra un intervallo per la gestione della richiesta da parte del server. Strumentazione client inserisce il contesto dell'intervallo nella richiesta HTTP in uscita e registra un intervallo per il tempo trascorso in attesa di 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.
• github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/trace Import 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 agli intervalli, ad esempio cloud.availability_zone, che identificano la tua applicazione è in esecuzione all'interno di 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.
• Utilizzi otel.SetTracerProvider e otel.SetTextMapPropagators per definire le impostazioni globali di 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.
• Esegui il wrapping del server HTTP con otelhttp.NewHandler per instrumentare la richiesta HTTP server web.

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. Puoi utilizzare anche Funzione r.Context per collegare la richiesta in arrivo alla richiesta in uscita, come mostrato nell'elenco seguente:

// 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 backend e frontend. Poi devi eseguirne il deployment cluster GKE.

crea il container Docker

1. In Cloud Shell, invia la build 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 container sia stata creata correttamente e che sia disponibili in Artifact Registry:

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

   L'immagine container è stata creata quando l'output è simile al seguente, dove PROJECT_ID è l'ID di per il 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 su backend cluster:

   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 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 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 ed esamina le tracce

In questa sezione utilizzerai l'utilità Apache Bench per creare richieste per la tua applicazione. Quindi, esaminerai 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 all'elenco di tracce

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

   

   Questa traccia contiene quattro intervalli 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 intervallo 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 le singole risorse anziché eliminare l'intero progetto, esegui 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 Centro architetture di Google Cloud.