Utiliser Zipkin et Jaeger pour implémenter le traçage distribué dans Beego

Utiliser Zipkin et Jaeger pour implémenter le traçage distribué dans Beego

Avec la prévalence des microservices, le développement de systèmes distribués est devenu de plus en plus courant. Cependant, les systèmes distribués apportent également de nouveaux défis, comme comment suivre le flux de demandes entre différents services, comment analyser et optimiser les performances des services, etc. À cet égard, les solutions de traçage distribuées sont devenues un élément de plus en plus important. Cet article explique comment utiliser Zipkin et Jaeger pour implémenter le traçage distribué dans Beego.

Demander un traçage sur plusieurs services est l'objectif principal du traçage distribué. Les flux de journaux ou de métriques centralisés ne peuvent pas résoudre ce problème car ces flux ne peuvent pas assurer la corrélation entre les services. Une demande peut nécessiter la collaboration de plusieurs services, et ces services doivent être conscients des temps de réponse et du comportement des autres services. L'approche traditionnelle consiste à enregistrer diverses métriques, puis à assouplir les seuils pour éviter le blocage lors de la réception de demandes. Mais cette approche peut cacher des problèmes tels que des problèmes et des problèmes de performances. Le traçage distribué est une solution de traçage des demandes interservices. Dans cette approche, lorsqu'une requête circule entre les services, chaque service génère une série d'identifiants qui suivront l'intégralité de la requête.

Voyons comment implémenter le traçage distribué dans Beego.

Zipkin et Jaeger sont actuellement les solutions de traçage distribuées les plus populaires. Les deux outils prennent en charge l'API OpenTracing, permettant aux développeurs de consigner et de tracer les requêtes entre les services de manière cohérente.

Tout d'abord, nous devons installer et démarrer Zipkin ou Jaeger, puis configurer le traçage distribué dans l'application Beego. Dans cet article, nous utiliserons Zipkin.

Installez Zipkin :

curl -sSL https://zipkin.io/quickstart.sh | bash -s
java -jar zipkin.jar

Une fois Zipkin lancé, vous pouvez accéder à son interface utilisateur Web via http://localhost:9411.

Ensuite, nous devons ajouter la prise en charge de l'API OpenTracing dans Beego. Nous pouvons utiliser le package opentracing-go et enregistrer les demandes interservices et autres événements à l'aide de l'API qu'il fournit. Un exemple de code de suivi est le suivant :

import (
    "github.com/opentracing/opentracing-go"
)

func main() {
    // Initialize the tracer
    tracer, closer := initTracer()
    defer closer.Close()

    // Start a new span
    span := tracer.StartSpan("example-span")

    // Record some events
    span.SetTag("example-tag", "example-value")
    span.LogKV("example-key", "example-value")

    // Finish the span
    span.Finish()
}

func initTracer() (opentracing.Tracer, io.Closer) {
    // Initialize the tracer
    tracer, closer := zipkin.NewTracer(
        zipkin.NewReporter(httpTransport.NewReporter("http://localhost:9411/api/v2/spans")),
        zipkin.WithLocalEndpoint(zipkin.NewEndpoint("example-service", "localhost:80")),
        zipkin.WithTraceID128Bit(true),
    )

    // Set the tracer as the global tracer
    opentracing.SetGlobalTracer(tracer)

    return tracer, closer
}

Dans l'exemple ci-dessus, nous initialisons d'abord le tracker Zipkin, puis nous l'utilisons pour enregistrer certains événements. Nous pouvons ajouter des balises et des paires clé-valeur et terminer la période en appelant span.Finish().

Maintenant, ajoutons le traçage distribué à notre application Beego.

Tout d’abord, ajoutons les dépendances opentracing-go et zipkin-go-opentracing. Nous pouvons le faire en utilisant go mod ou en installant manuellement des packages.

go get github.com/opentracing/opentracing-go
go get github.com/openzipkin/zipkin-go-opentracing

Ensuite, nous devons initialiser le middleware Zipkin tracker et Beego tracker dans l'application Beego. Voici un exemple de code pour le middleware Beego tracer :

import (
    "net/http"

    "github.com/astaxie/beego"
    opentracing "github.com/opentracing/opentracing-go"
    "github.com/openzipkin/zipkin-go-opentracing"
)

func TraceMiddleware() func(http.ResponseWriter, *http.Request, http.HandlerFunc) {
    return func(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
        // Initialize the tracer
        tracer, closer := initTracer()
        defer closer.Close()

        // Extract the span context from the HTTP headers
        spanCtx, err := tracer.Extract(opentracing.HTTPHeaders,
            opentracing.HTTPHeadersCarrier(r.Header))
        if err != nil && err != opentracing.ErrSpanContextNotFound {
            beego.Error("failed to extract span context:", err)
        }

        // Start a new span
        span := tracer.StartSpan(r.URL.Path, ext.RPCServerOption(spanCtx))

        // Set some tags
        span.SetTag("http.method", r.Method)
        span.SetTag("http.url", r.URL.String())

        // Inject the span context into the HTTP headers
        carrier := opentracing.HTTPHeadersCarrier(r.Header)
        if err := tracer.Inject(span.Context(),
            opentracing.HTTPHeaders, carrier); err != nil {
            beego.Error("failed to inject span context:", err)
        }

        // Set the span as a variable in the request context
        r = r.WithContext(opentracing.ContextWithSpan(r.Context(), span))

        // Call the next middleware/handler
        next(w, r)

        // Finish the span
        span.Finish()
    }
}

func initTracer() (opentracing.Tracer, io.Closer) {
    // Initialize the Zipkin tracer
    report := zipkinhttp.NewReporter("http://localhost:9411/api/v2/spans")
    defer report.Close()

    endpoint, err := zipkin.NewEndpoint("example-service", "localhost:80")
    if err != nil {
        beego.Error("failed to create Zipkin endpoint:", err)
    }

    nativeTracer, err := zipkin.NewTracer(
        report, zipkin.WithLocalEndpoint(endpoint),
        zipkin.WithTraceID128Bit(true))
    if err != nil {
        beego.Error("failed to create Zipkin tracer:", err)
    }

    // Initialize the OpenTracing API tracer
    tracer := zipkinopentracing.Wrap(nativeTracer)

    // Set the tracer as the global tracer
    opentracing.SetGlobalTracer(tracer)

    return tracer, report
}

Dans l'exemple de code ci-dessus, nous définissons un middleware appelé TraceMiddleware. Ce middleware extraira le contexte de suivi existant de l'en-tête HTTP (le cas échéant) et l'utilisera pour créer un nouveau tracker pour la requête. Nous définissons également la durée dans le contexte de la requête afin que tous les autres middlewares et gestionnaires puissent y accéder. Enfin, une fois l'exécution du gestionnaire terminée, nous appelons la méthode finish() sur le span afin que Zipkin puisse enregistrer le suivi des interdépendances entre tous les services demandés.

Nous devons également connecter ce middleware à notre routeur Beego. Nous pouvons le faire en utilisant le code suivant dans le code d'initialisation du routeur :

beego.InsertFilter("*", beego.BeforeRouter, TraceMiddleware())

Maintenant, lancez votre application Beego et visitez http://localhost:9411 pour ouvrir l'interface utilisateur Zipkin et afficher les données de suivi.

Implémenter le traçage distribué dans les applications Beego peut paraître compliqué, mais en utilisant les bibliothèques opentracing-go et zipkin-go-opentracing, nous pouvons facilement ajouter cette fonctionnalité. Cela devient de plus en plus important à mesure que nous continuons à augmenter le nombre et la complexité de nos services, ce qui nous permet de comprendre comment nos services fonctionnent ensemble et de garantir leur bon fonctionnement tout au long du processus de traitement des demandes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!