Tracciamento distribuito con Spring Cloud Sleuth e Stackdriver Trace

Il tracciamento distribuito è importante per ottenere informazioni e osservabilità su un'architettura di microservizi a più livelli. Quando hai concatenato chiamate da servizio a servizio, dal servizio A al servizio B al servizio C, è importante capire se le chiamate sono andate a buon fine e anche la latenza in ogni passaggio.

In Spring Boot, puoi utilizzare Spring Cloud Sleuth per aggiungere facilmente l'instrumentazione di tracciamento distribuito alla tua applicazione. Per impostazione predefinita, può inoltrare i dati di traccia a Zipkin.

Google Cloud Platform dispone di Stackdriver Trace, un servizio gestito che consente di archiviare i dati di traccia senza dover gestire la propria istanza Zipkin o l'archiviazione. Stackdriver Trace può anche generare report sulla distribuzione della latenza e rilevare automaticamente le regressioni delle prestazioni.

Hai due opzioni per utilizzare Stackdriver Trace da un'applicazione Spring Boot:

1. Utilizza un proxy Zipkin di Stackdriver Trace e configura semplicemente Spring Cloud Sleuth per utilizzare questo proxy come endpoint Zipkin
2. In alternativa, utilizza Spring Cloud GCP Trace, che si integra perfettamente con Spring Cloud Sleuth e inoltra i dati di tracciamento direttamente a Stackdriver Trace.

In questo codelab imparerai a creare una nuova applicazione Spring Boot e a utilizzare Spring Cloud GCP Trace per il tracciamento distribuito.

Cosa imparerai a fare

• Come creare un'applicazione Java Spring Boot e configurare Stackdriver Trace.

Che cosa ti serve

• Un progetto Google Cloud
• Un browser, ad esempio Chrome o Firefox
• Familiarità con gli editor di testo standard di Linux, ad esempio Vim, EMAC o Nano

Come utilizzerai questo tutorial?

Leggilo e basta Leggilo e completa gli esercizi

Come valuti la tua esperienza di creazione di app web HTML/CSS?

Principiante Intermedio Avanzato

Come valuti la tua esperienza di utilizzo dei servizi Google Cloud Platform?

Principiante Intermedio Avanzato

Configurazione dell'ambiente autonoma

Se non hai ancora un Account Google (Gmail o Google Apps), devi crearne uno. Accedi alla console di Google Cloud (console.cloud.google.com) e crea un nuovo progetto:

Ricorda l'ID progetto, un nome univoco per tutti i progetti Google Cloud (il nome riportato sopra è già stato utilizzato e non funzionerà per te, mi dispiace). In questo codelab verrà chiamato PROJECT_ID.

Successivamente, dovrai abilitare la fatturazione nella console Cloud per utilizzare le risorse Google Cloud.

L'esecuzione di questo codelab non dovrebbe costarti più di qualche dollaro, ma potrebbe essere più cara se decidi di utilizzare più risorse o se le lasci in esecuzione (vedi la sezione "Pulizia" alla fine di questo documento).

I nuovi utenti di Google Cloud Platform possono beneficiare di una prova senza costi di 300$.

Google Cloud Shell

Sebbene Google Cloud e Kubernetes possano essere gestiti da remoto dal tuo laptop, in questo codelab utilizzeremo Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.

Attiva Google Cloud Shell

Nella console GCP, fai clic sull'icona di Cloud Shell nella barra degli strumenti in alto a destra:

Poi fai clic su "Avvia Cloud Shell":

Bastano pochi istanti per eseguire il provisioning e connettersi all'ambiente:

Questa macchina virtuale è caricata con tutti gli strumenti di sviluppo di cui avrai bisogno. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni di rete e l'autenticazione. Gran parte, se non tutto, il lavoro in questo lab può essere svolgersi semplicemente con un browser o con Google Chromebook.

Una volta eseguita la connessione a Cloud Shell, dovresti vedere che il tuo account è già autenticato e il progetto è già impostato sul tuo PROJECT_ID.

Esegui questo comando in Cloud Shell per verificare che l'account sia autenticato:

gcloud auth list

Output comando

Credentialed accounts:
 - <myaccount>@<mydomain>.com (active)

Nota : gcloud è lo strumento a riga di comando potente e unificato per Google Cloud Platform. La documentazione completa è disponibile all'indirizzo https://cloud.google.com/sdk/gcloud. È preinstallato su Cloud Shell. Noterai il supporto del completamento automatico.

gcloud config list project

Output comando

[core]
project = <PROJECT_ID>

In caso contrario, puoi impostarlo con questo comando:

gcloud config set project <PROJECT_ID>

Output comando

Updated property [core/project].

Dopo l'avvio di Cloud Shell, puoi utilizzare la riga di comando per generare una nuova applicazione Spring Boot con Spring Initializr:

$ curl https://start.spring.io/starter.tgz -d packaging=jar \
  -d dependencies=web,lombok,cloud-gcp,cloud-starter-sleuth \
  -d baseDir=trace-service-one | tar -xzvf - \
  && cd trace-service-one

Crea un nuovo controller REST aggiungendo una nuova classe:

src/main/java/com/example/demo/WorkController.java

package com.example.demo;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Random;

@RestController
@Slf4j
public class WorkController {
  Random r = new Random();

  public void meeting() {
    try {
      log.info("meeting...");
      // Delay for random number of milliseconds.
      Thread.sleep(r.nextInt(500));
    } catch (InterruptedException e) {
    }
  }

  @GetMapping("/")
  public String work() {
    // What is work? Meetings!
    // When you hit this URL, it'll call meetings() 5 times.
    // Each time will have a random delay.
    log.info("starting to work");
    for (int i = 0; i < 5; i++) {
      this.meeting();
    }
    log.info("finished!");
    return "finished work!";
  }
}

Puoi avviare l'applicazione Spring Boot normalmente con il plug-in Spring Boot. Saltiamo i test per questo lab:

$ ./mvnw -DskipTests spring-boot:run

Una volta avviata l'applicazione, fai clic sull'icona Anteprima web nella barra degli strumenti di Cloud Shell e scegli Anteprima sulla porta 8080.

Dopo una breve attesa, dovresti vedere il risultato:

In Cloud Shell dovresti visualizzare anche i messaggi di log con ID traccia e ID intervallo:

Abilita l'API Stackdriver Trace

Per utilizzare Stackdriver Trace per archiviare i dati di traccia, devi prima abilitare l'API Stackdriver Trace. Per abilitare l'API, vai a API e servizi → Libreria

Cerca Stackdriver Trace

Fai clic su API Stackdriver Trace, quindi fai clic su Abilita se non è già abilitata.

Configurare le credenziali predefinite dell'applicazione

Per questo lab, devi configurare una credenziale predefinita dell'applicazione. Questa credenziale verrà selezionata automaticamente da Spring Cloud GCP Trace starter.

Nota: questo è solo a scopo di sviluppo. Quando viene eseguito il deployment in un ambiente di produzione, lo starter può essere configurato per recuperare le credenziali da un file di credenziali del service account o utilizzare le credenziali associate alla macchina virtuale.

Innanzitutto, accedi:

$ gcloud auth application-default login
You are running on a Google Compute Engine virtual machine.
The service credentials associated with this virtual machine
will automatically be used by Application Default
Credentials, so it is not necessary to use this command.
If you decide to proceed anyway, your user credentials may be visible
to others with access to this virtual machine. Are you sure you want
to authenticate with your personal account?
Do you want to continue (Y/n)? Y

Go to the following link in your browser:
    https://accounts.google.com/o/oauth2/auth...
Enter verification code: ...

Fai clic sul link per aprire una nuova scheda del browser, quindi fai clic su Consenti.

Quindi, copia e incolla il codice di verifica in Cloud Shell e premi Invio. Dovresti vedere:

Credentials saved to file: [/tmp/tmp.jm9bnQ4R9Q/application_default_credentials.json]
These credentials will be used by any library that requests
Application Default Credentials.

Aggiungi Spring Cloud GCP Trace

In questo servizio abbiamo già utilizzato Spring Cloud Sleuth per il tracciamento. Aggiungiamo Spring Cloud GCP Trace starter per inoltrare i dati a Stackdriver Trace.

Aggiungi la dipendenza Spring Cloud GCP Trace:

pom.xml

<project>
  ...
  <dependencies>
    ...
    <!-- Add Stackdriver Trace Starter -->
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-gcp-starter-trace</artifactId>
    </dependency>
  </dependencies>
  ...
</project>

Per impostazione predefinita, Spring Cloud Sleuth non campiona ogni richiesta. Per semplificare un po' i nostri test, aumenta la frequenza di campionamento al 100% in application.properties per assicurarti di visualizzare i dati di traccia, nonché ignorare alcuni URL che non ci interessano:

$ echo "
spring.sleuth.sampler.probability=1.0
spring.sleuth.web.skipPattern=(^cleanup.*|.+favicon.*)
" > src/main/resources/application.properties

Esegui di nuovo l'applicazione e utilizza l'anteprima web di Cloud Shell per visualizzarla:

$ export GOOGLE_CLOUD_PROJECT=`gcloud config list --format 'value(core.project)'`
$ ./mvnw -DskipTests spring-boot:run

Per impostazione predefinita, Spring Cloud GCP Trace raggruppa i dati di traccia e li invia ogni 10 secondi o quando viene ricevuto un numero minimo di dati di traccia. Questo valore è configurabile e puoi consultare la documentazione di riferimento di Spring Cloud GCP Trace per saperne di più.

Effettua una richiesta al servizio:

$ curl localhost:8080

Nella console Cloud, vai a Stackdriver → Trace → Elenco tracce.

In alto, riduci l'intervallo di tempo a 1 ora. Per impostazione predefinita, l'opzione Ricarica automatica è attiva. Quindi, man mano che arrivano i dati di tracciamento, dovrebbero essere visualizzati nella console.

I dati di traccia dovrebbero essere visualizzati in circa 30 secondi.

Fai clic sul punto blu per visualizzare i dettagli della traccia:

È stato piuttosto semplice.

Apri una nuova sessione di Cloud Shell facendo clic sull'icona +:

Nella nuova sessione, crea la seconda applicazione Spring Boot:

$ curl https://start.spring.io/starter.tgz -d packaging=jar \
  -d dependencies=web,lombok,cloud-gcp,cloud-starter-sleuth \
  -d baseDir=trace-service-two | tar -xzvf - \
  && cd trace-service-two

Crea un nuovo controller REST aggiungendo una nuova classe:

src/main/java/com/example/demo/MeetingController.java

package com.example.demo;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Random;

@RestController
@Slf4j
public class MeetingController {
  Random r = new Random();

  @GetMapping("/meet")
  public String meeting() {
    try {
      log.info("meeting...");
      Thread.sleep(r.nextInt(500 - 20 + 1) + 20);
    } catch (InterruptedException e) {
    }
    return "finished meeting";
  }
}

Aggiungi Spring Cloud GCP Trace a pom.xml

pom.xml

<project>
  ...
  <dependencies>
    ...
    <!-- Add Stackdriver Trace starter -->
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-gcp-starter-trace</artifactId>
    </dependency>
  </dependencies>
  ...
</project>

Configura Sleuth in modo che campioni il 100% delle richieste:

src/main/resources/application.properties

$ echo "
spring.sleuth.sampler.probability=1.0
spring.sleuth.web.skipPattern=(^cleanup.*|.+favicon.*)
" > src/main/resources/application.properties

Infine, puoi avviare l'applicazione Spring Boot sulla porta 8081 con il plug-in Spring Boot:

$ export GOOGLE_CLOUD_PROJECT=`gcloud config list --format 'value(core.project)'`
$ ./mvnw -DskipTests spring-boot:run -Dserver.port=8081

Mentre trace-service-two è in esecuzione, torna alla prima finestra della sessione di Cloud Shell e modifica trace-service-one.

Innanzitutto, inizializza un nuovo bean RestTemplate:

src/main/java/com/example/demo/DemoApplication.java

package com.example.demo;

...

import org.springframework.web.client.RestTemplate;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class DemoApplication {
        @Bean
        public RestTemplate restTemplate() {
                return new RestTemplate();
        }
        
        public static void main(String[] args) {
                SpringApplication.run(DemoApplication.class, args);
        }
}

In WorkController.meeting(), effettua una chiamata al servizio Riunione.

src/main/java/com/example/demo/WorkController.java

package com.example.demo;

...
import org.springframework.web.client.RestTemplate;
import org.springframework.beans.factory.annotation.Autowired;

@RestController
@Slf4j
public class WorkController {
  @Autowired
  RestTemplate restTemplate;

  public void meeting() {
    String result = restTemplate.getForObject("http://localhost:8081/meet", String.class);
    log.info(result);
  }

  ...
}

Avvia di nuovo il servizio e attiva l'endpoint dall'anteprima web:

$ export GOOGLE_CLOUD_PROJECT=`gcloud config list --format 'value(core.project)'`
$ ./mvnw -DskipTests spring-boot:run

In entrambe le finestre della sessione, dovresti vedere i messaggi di log, con l'ID traccia propagato da un servizio all'altro.

Nell'elenco delle tracce di Stackdriver Trace, dovresti vedere la seconda traccia:

Puoi fare clic sul nuovo punto blu e visualizzare i dettagli della traccia:

Puoi anche fare clic su qualsiasi intervallo in questo diagramma per visualizzarne i dettagli.

Quando utilizzi Stackdriver Trace come spazio di archiviazione dei dati di traccia, Stackdriver Trace può utilizzare i dati per generare il report sulla distribuzione della latenza. Per creare il report in questo modo, devi avere più di 100 tracce:

Inoltre, Stackdriver Trace può rilevare automaticamente la regressione delle prestazioni dello stesso servizio in due periodi di tempo diversi in Report di analisi.

In questo lab hai creato due semplici servizi e hai aggiunto il tracciamento distribuito con Spring Cloud Sleuth e hai utilizzato Spring Cloud GCP per inoltrare le informazioni sulle tracce a Stackdriver Trace.

Hai imparato a scrivere la tua prima applicazione web App Engine.

Scopri di più

• Stackdriver Trace: https://cloud.google.com/trace/
• Progetto Spring on GCP: http://cloud.spring.io/spring-cloud-gcp/
• Repository GitHub di Spring su GCP: https://github.com/spring-cloud/spring-cloud-gcp
• Java su Google Cloud: https://cloud.google.com/java/

Licenza

Questo lavoro è concesso in licenza ai sensi di una licenza Creative Commons Attribution 2.0 Generic.