[JAVA] MicroProfile OpenTracing avec Helidon

introduction

Calendrier de l'Avent UL Systems 2019-Day 18

Aujourd'hui, reportez-vous au Tracing MP Guide de Helidon Eclipse MicroProfile Open Tracing et Jaeger Je voudrais essayer la visualisation de traçage distribué. (Le Tracing MP Guide utilise Zipkin, mais cette fois, j'aimerais utiliser Jaeger à cause du joli logo.)

Récemment, il est devenu plus courant de configurer l'ensemble du système avec une architecture de microservices. À ce moment-là, si un échec ou un retard se produit dans le traitement qui couvre plusieurs services avec la trace de méthode utilisée dans le système monolithique conventionnel, il est difficile de déterminer où il se produit, de sorte que la distribution est tracée tout au long. Un mécanisme appelé traçage est nécessaire.

jaeger.png

Qu'est-ce que Helidon

Un framework open source pour le développement de microservices légers pouvant être utilisés pour créer des microservices pour Java, annoncé par Oracle en septembre 2018.

Caractéristiques de Helidon

Cette fois, j'utiliserai Helidon MP qui prend en charge MaicroProfile.

Qu'est-ce que Eclipse MicroProfile?

Eclipse MicroProfile est une spécification de l'API Enterprise Java pour les microservices. Il comprend désormais des API telles que JAX-RS, JSON-P et CDI, ainsi que des API telles que la configuration, les métriques et la tolérance aux pannes. L'Helidon MP utilisé cette fois prend en charge Eclipse MicroProfile 3.2.

Qu'est-ce qu'OpenTracing?

OpenTracing se compose de spécifications d'API, de cadres et de bibliothèques qui les implémentent, ainsi que de la documentation du projet. OpenTracing permet aux développeurs d'ajouter des fonctionnalités de traçage à leur code d'application à l'aide d'API qui ne sont pas verrouillées sur un produit ou un fournisseur particulier.

Qu'est-ce que Jaeger

Un système de traçage distribué open source compatible OpenTracing inspiré de Dapper et OpenZipkin et publié par Uber Technologies. Cette fois, la partie API OpenTracing de la figure ci-dessous est MicroProfile OpenTracing, et la partie jaeger-client est le client pour Jaeger fourni par Helidon.

20181125234256.png

Configuration Jaeger

Tout d'abord, je voudrais configurer les parties autres que Client. En ce qui concerne la configuration, l'image Docker tout-en-un est publiée, alors utilisez-la. (Commencez par spécifier uniquement les ports minimum requis)

$ docker run -d --name jaeger \
   -p 5778:5778 \
   -p 16686:16686 \
   -p 14268:14268 \
   jaegertracing/all-in-one:1.15

Description de chaque port

Le client jaeger d'Helidon semble utiliser HTTP 5778 par défaut. (Cela peut être changé en réglant)

キャプチャ004.JPG

Créer un service principal

Créez ensuite le projet de service principal à l'aide du démarrage rapide de l'archétype Helidon MP Maven.

$ mvn archetype:generate -DinteractiveMode=false \
    -DarchetypeGroupId=io.helidon.archetypes \
    -DarchetypeArtifactId=helidon-quickstart-mp \
    -DarchetypeVersion=1.4.0 \
    -DgroupId=io.helidon.main_service \
    -DartifactId=main_service \
    -Dpackage=io.helidon.main_service

Client Jaeger ajouté

Ajoutez la dépendance suivante à pom.xml et ajoutez le client Jaeger.

pom.xml(ajouter à)


<dependency>
    <groupId>io.helidon.tracing</groupId>
    <artifactId>helidon-tracing-jaeger</artifactId>
</dependency>

Ajouter le nom du service de suivi

Spécifiez le nom du service à lier aux données de traçage envoyées d'Helidon à Jaeger dans META-INF / microprofile-config.properties.

microprofile-config.properties


tracing.service=helidon-main-service

Exécuter et voir le service principal

Maintenant, j'aimerais voir les résultats créés jusqu'à présent. Le projet créé par quickstart est créé pour que le serveur puisse être démarré en exécutant la méthode Main de la classe ʻio.helidon.main_service.Main`.

Si vous accédez à http: // localhost: 8080 / greet après le démarrage du serveur, le service créé par quickstart sera exécuté et vous devriez voir {" message ":" Hello World! "}.

$ curl http://localhost:8080/greet
{"message":"Hello World!"}

Si vous regardez les données de traçage de l'interface utilisateur jaeger (http: // localhost: 16686 / search) après y avoir accédé plusieurs fois, vous devriez voir les données de traçage suivantes. キャプチャ003.JPG

Cliquez davantage sur chaque trace pour afficher la page des détails de trace répertoriant les étendues. Vous pouvez voir clairement l'étendue racine et les relations entre toutes les étendues de la trace, ainsi que les informations de synchronisation. キャプチャ005.JPG

Vous pouvez également voir les détails de la plage en cliquant sur chaque ligne de plage. キャプチャ006.JPG

Traçage au niveau de la classe ou de la méthode

De plus, le traçage au niveau de la classe ou de la méthode est possible en ajoutant l'annotation @ Traced fournie par MicroProfile OpenTracing.

GreetingProvider.java


@Traced
@ApplicationScoped
public class GreetingProvider {
...
}

キャプチャ007.JPG

Traçage à travers les services

Ensuite, je voudrais faire un traçage entre les services.

Créer un deuxième service

Créez-le à l'aide du démarrage rapide de l'archétype Helidon MP Maven ainsi que du service principal et ajoutez le client Jaeger.

$ mvn archetype:generate -DinteractiveMode=false \
    -DarchetypeGroupId=io.helidon.archetypes \
    -DarchetypeArtifactId=helidon-quickstart-mp \
    -DarchetypeVersion=1.4.0 \
    -DgroupId=io.helidon.second_service \
    -DartifactId=second_service \
    -Dpackage=io.helidon.second_service

pom.xml(ajouter à)


<dependency>
    <groupId>io.helidon.tracing</groupId>
    <artifactId>helidon-tracing-jaeger</artifactId>
</dependency>

changement de réglage

microprofile-config.properties(Après le changement)


# Application properties. This is the default greeting
app.greeting=Hello From Second Service

# Microprofile server properties
server.port=8081

Contrôle de fonctionnement

Si vous exécutez le deuxième service et vérifiez l'opération, le résultat sera le suivant.

$ curl http://localhost:8081/greet
{"message":"Hello From Second Service World!"}

Appeler le deuxième service à partir du service principal

Changez pour appeler le deuxième service à partir du service principal que vous avez créé en premier.

Tout d'abord, vous devez créer un client de repos dans le service principal pour appeler le deuxième service. Contrairement au guide Tracing MP, je voudrais le créer en utilisant le Micro Profile Rest Client ici.

SecondServiceClient.java


package io.helidon.main_service;

import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;

import javax.json.JsonObject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;

@RegisterRestClient(baseUri="http://localhost:8081")
public interface SecondServiceClient {
    @Path("/greet")
    @GET
    JsonObject getDefaultMessage();
}

Ensuite, utilisez le client créé pour appeler le deuxième service à partir du service principal. Injectez le SecondServiceClient créé dans la classe appelante et appelez le service Second à l'aide de SecondServiceClient à la méthode qui a renvoyé la réponse à l'origine.

GreetResource.java


@Path("/greet")
@RequestScoped
public class GreetResource {
    @Inject
    @RestClient
    SecondServiceClient secondServiceClient;

    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public JsonObject getDefaultMessage() {
        // return createResponse("World");
        return secondServiceClient.getDefaultMessage();
    }

Contrôle de fonctionnement

Exécutez le service principal sur le port 8080 et assurez-vous que le deuxième service est appelé.

$ curl http://localhost:8080/greet
{"message":"Hello From Second Service World!"}

Vérifier les données de traçage distribuées

Le processus cette fois est configuré de sorte que la demande de la console active le service principal et appelle le deuxième service. キャプチャ009.JPG

Si vous regardez les données de traçage de cette demande dans l'interface utilisateur Jaeger, cela prendra autant de temps de traitement dans son ensemble, et vous pouvez vérifier le flux de traitement. キャプチャ008.JPG

Résumé

Cette fois, j'ai essayé le traçage distribué en utilisant Eclipse MicroProfile Open Tracing. Si le traçage distribué peut être visualisé lorsqu'un système distribué est adopté, il peut être plus facile à comprendre même en cas de défaillance ou de retard du système.

En plus d'OpenTracing, Eclipse MicroProfile a des spécifications telles que Eclipse MicroProfile Metrics et Eclipse MicroProfile Fault Tolerance, et Helidon les prend également en charge. Il peut être possible d'envisager des options autres que Spring Framework, telles que la migration à partir d'applications qui utilisent actuellement Java EE.

Recommended Posts

MicroProfile OpenTracing avec Helidon
Contactez Eclipse MicroProfile Health