[JAVA] Présentation des applications Zipkin to Jersey (JAX-RS2)

Que veux-tu faire

Tracez l'application Java JAX-RS2 créée dans Jersey avec Zipkin.

• À titre d'essai, exécutez l'application Java et le serveur Zipkin sur la même machine.
• Le serveur Zipkin est configuré avec docker-zipkin
• Implémentation du serveur JAX-RS ==> jersey-server 2.x
• Implémentation du client JAX-RS ==> jersey-client 2.x
• Utilisez jersey-container-jdk-http pour l'implémentation du serveur HTTP Java
• La bibliothèque brave-instrumentation-jaxrs2 crée des données de traçage
• La bibliothèque zipkin-reporter envoie des données de traçage au serveur Zipkin

Configurer un serveur Zipkin

Installez docker.

• Mac / [Windows](https://store.docker.com/editions/community/docker-ce- desktop-windows) / Linux est inclus dans la gestion des paquets

Linux installe docker-compose en plus. Mac et Windows ne sont pas nécessaires car ils sont inclus dans le programme d'installation de Docker.

sudo curl -L https://github.com/docker/compose/releases/download/1.18.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Clonez docker-zipkin depuis github et exécutez le serveur Zipkin avec docker

git clone https://github.com/openzipkin/docker-zipkin.git
cd docker-zipkin
docker-compose up -d

Vous pouvez accéder à l'interface utilisateur Web Zipkin à l'URL suivante

• http://localhost:9411

Mettre en œuvre l'application

L'application est faite avec Jersey comme son titre l'indique, celle qui est terminée est téléchargée sur github.

• https://github.com/megmogmog1965/jersey-zipkin

Bibliothèque dépendante (pom.xml)

Utilise Jersey 2, une implémentation de référence JAX-RS2 côté serveur.

Notez que groupId progressivecom.sun.jersey '', qui apparaît souvent lorsqu'il est googlé à Jersey, n'est pas compatible avec la série Jersey 1.

<!-- https://mvnrepository.com/artifact/org.glassfish.jersey.core/jersey-server -->
<dependency>
  <groupId>org.glassfish.jersey.core</groupId>
  <artifactId>jersey-server</artifactId>
  <version>2.26</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.glassfish.jersey.inject/jersey-hk2 -->
<dependency>
  <groupId>org.glassfish.jersey.inject</groupId>
  <artifactId>jersey-hk2</artifactId>
  <version>2.26</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.glassfish.jersey.containers/jersey-container-servlet -->
<dependency>
  <groupId>org.glassfish.jersey.containers</groupId>
  <artifactId>jersey-container-servlet</artifactId>
  <version>2.26</version>
</dependency>

Le JAX-RS2 côté client utilise également Jersey 2, qui est une implémentation de référence.

<!-- https://mvnrepository.com/artifact/org.glassfish.jersey.core/jersey-client -->
<dependency>
  <groupId>org.glassfish.jersey.core</groupId>
  <artifactId>jersey-client</artifactId>
  <version>2.26</version>
</dependency>

Les applications Web écrites en Java sont généralement exécutées par Tomcat, Glassfish, Jetty, etc., mais par souci de simplicité, utilisez `` jersey-container-jdk-http '' pour implémenter le serveur Http. Incorporer directement dans l'application.

<!-- https://mvnrepository.com/artifact/org.glassfish.jersey.containers/jersey-container-jdk-http -->
<dependency>
  <groupId>org.glassfish.jersey.containers</groupId>
  <artifactId>jersey-container-jdk-http</artifactId>
  <version>2.26</version>
</dependency>

Bibliothèque JAX-RS2 Zipkin Instrumentation pour les applications Java qui vous permet d'effectuer le suivi sur les serveurs / clients JAX-RS.

<!-- https://mvnrepository.com/artifact/io.zipkin.brave/brave-instrumentation-jaxrs2 -->
<dependency>
  <groupId>io.zipkin.brave</groupId>
  <artifactId>brave-instrumentation-jaxrs2</artifactId>
  <version>4.3.1</version>
</dependency>

Les données de traçage collectées doivent être envoyées au serveur Zipkin. Cette bibliothèque les enverra vers n'importe quelle destination.

<!-- https://mvnrepository.com/artifact/io.zipkin.reporter/zipkin-sender-urlconnection -->
<dependency>
  <groupId>io.zipkin.reporter</groupId>
  <artifactId>zipkin-sender-urlconnection</artifactId>
  <version>1.1.2</version>
</dependency>

Code Java

JAX-RS2 vous permet de brancher une bibliothèque externe qui implémente javax.ws.rs.core.Feature IF.

Brave, une bibliothèque Zipkin pour les applications Java, prend en charge différents frameworks Java. Cette fois, nous utiliserons brave-instrumentation-jaxrs2 pour JAX-RS2.

• `` brave.jaxrs2.TracingFeature '' est une instrumentation de traçage pour JAX-RS2 qui crée des données de traçage (https://zipkin.io/pages/architecture.html)
• zipkin.reporter.AsyncReporter envoie les données de traçage collectées sur l'application au serveur Zipkin.

package zipkin;

import brave.Tracing;
import brave.jaxrs2.TracingFeature;
import brave.sampler.Sampler;
import zipkin.reporter.AsyncReporter;
import zipkin.reporter.urlconnection.URLConnectionSender;
import javax.ws.rs.core.Feature;

public class ZipkinFeature {

    /**
     * @param localServiceName Nom du service affiché dans l'interface utilisateur Web Zipkin
     */
    public static Feature create(String localServiceName) {
        // create a zipkin reporter.
        AsyncReporter<Span> asyncReporter = AsyncReporter
                .builder(URLConnectionSender.create("http://localhost:9411/api/v1/spans"))
                .build();

        // create a zipkin tracing.
        Tracing tracing = Tracing.newBuilder()
                .reporter(asyncReporter)
                .localServiceName(localServiceName)
                .sampler(Sampler.ALWAYS_SAMPLE)
                .build();

        // create a JAX-RS feature.
        Feature tracingFeature = TracingFeature.create(tracing);

        return tracingFeature;
    }
}

Créez une classe qui implémente le point d'entrée JAX-RS2 côté serveur javax.ws.rs.core.Application IF. Ici, la fonction de traçage brave.jaxrs2.TracingFeature générée précédemment Enregistrez-vous avec JAX-RS2 côté serveur.

package app;

import zipkin.ZipkinFeature;
import javax.ws.rs.ApplicationPath;
import javax.ws.rs.core.Application;
import javax.ws.rs.core.Feature;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;

@ApplicationPath("")
public class MyApplication extends Application {

    @Override
    public Set<Object> getSingletons() {
        // create a JAX-RS feature.
        Feature tracingFeature = ZipkinFeature.create("server");

        return new LinkedHashSet<>(Arrays.asList(tracingFeature));
    }
}

Créez une classe de ressources (définition d'API) pour JAX-RS2 côté serveur. À l'origine, je voudrais déployer plusieurs services et vérifier le fonctionnement de Zipkin, mais par souci de simplicité, définissez 3 API et le client JAX. -Appelés dans l'ordre par RS2. Ici aussi, la fonction de traçage `` brave.jaxrs2.TracingFeature '' générée précédemment est enregistrée dans le client JAX-RS2.

• /front --> /mid --> /back

package resource;

import zipkin.ZipkinFeature;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.core.Feature;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

@Path("")
public class MyResource {

    /**
     * /front --> /mid --> /back
     *
     * @return String that will be returned as a text/plain response.
     */
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    @Path("front")
    public Response front() {
        // create a JAX-RS feature.
        Feature tracingFeature = ZipkinFeature.create("client");

        // http client: GET /mid
        Response r = ClientBuilder.newClient()
                .register(tracingFeature)
                .target("http://localhost:8080/myapp/mid")
                .request()
                .get();

        return Response.fromResponse(r).build();
    }

    /**
     * /mid --> /back
     *
     * @return String that will be returned as a text/plain response.
     */
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    @Path("mid")
    public Response mid() {
        // create a JAX-RS feature.
        Feature tracingFeature = ZipkinFeature.create("client");

        // http client: GET /back
        Response r = ClientBuilder.newClient()
                .register(tracingFeature)
                .target("http://localhost:8080/myapp/back")
                .request()
                .get();

        return Response.fromResponse(r).build();
    }

    /**
     * /back
     *
     * @return String that will be returned as a text/plain response.
     */
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    @Path("back")
    public String back() {
        return "hello";
    }
}

Nous utilisons jersey-container-jdk-http pour l'implémentation du serveur Http car nous voulons que cela fonctionne facilement.

package main;

import app.MyApplication;
import com.sun.net.httpserver.HttpServer;
import org.glassfish.jersey.jdkhttp.JdkHttpServerFactory;
import org.glassfish.jersey.server.ResourceConfig;
import java.net.URI;

public class Main {

    public static void main(String[] args) {
        // register JAX-RS Application class.
        ResourceConfig rc = ResourceConfig.forApplicationClass(MyApplication.class);

        // register a path of REST resources.
        rc.packages(true, "resource");

        // run a jersey server.
        URI uri = URI.create("http://localhost:8080/myapp/");
        HttpServer httpServer = JdkHttpServerFactory.createHttpServer(uri, rc);
        Runtime.getRuntime().addShutdownHook(new Thread(() -> httpServer.stop(0)));
    }
}

Exécutez l'application. Vous pouvez y accéder à l'URL suivante.

• http://localhost:8080/myapp/front

Accédons à l'interface utilisateur Web Zipkin. Vous devriez pouvoir voir les données de traçage de l'accès précédent.

• http://localhost:9411