Menggunakan Zipkin dan Jaeger untuk melaksanakan pengesanan teragih dalam Beego

Menggunakan Zipkin dan Jaeger untuk melaksanakan pengesanan teragih dalam Beego

Dengan populariti perkhidmatan mikro, pembangunan sistem teragih telah menjadi semakin biasa. Walau bagaimanapun, sistem yang diedarkan juga membawa cabaran baharu, seperti cara menjejak aliran permintaan antara pelbagai perkhidmatan, cara menganalisis dan mengoptimumkan prestasi perkhidmatan, dsb. Dalam hal ini, penyelesaian pengesanan yang diedarkan telah menjadi komponen yang semakin penting. Artikel ini akan memperkenalkan cara menggunakan Zipkin dan Jaeger untuk melaksanakan pengesanan teragih dalam Beego.

Permintaan pengesanan merentas berbilang perkhidmatan ialah matlamat utama pengesanan teragih. Aliran log berpusat atau aliran metrik tidak dapat menyelesaikan masalah ini kerana aliran ini tidak dapat memberikan korelasi antara perkhidmatan. Permintaan mungkin memerlukan berbilang perkhidmatan untuk berfungsi bersama, dan perkhidmatan ini mesti mengetahui masa tindak balas dan gelagat perkhidmatan lain. Pendekatan tradisional adalah untuk mencatat pelbagai metrik dan kemudian melonggarkan ambang untuk mengelakkan sekatan apabila menerima permintaan. Tetapi pendekatan ini boleh menyembunyikan masalah seperti gangguan dan isu prestasi. Pengesanan teragih ialah penyelesaian untuk pengesanan permintaan silang perkhidmatan. Dalam pendekatan ini, apabila permintaan mengalir antara perkhidmatan, setiap perkhidmatan menjana satu siri ID yang akan menjejaki keseluruhan permintaan.

Mari lihat cara melaksanakan pengesanan teragih dalam Beego.

Zipkin dan Jaeger kini merupakan penyelesaian pengesanan teragih yang paling popular. Kedua-dua alatan menyokong OpenTracing API, membolehkan pembangun log dan mengesan permintaan merentas perkhidmatan dengan cara yang konsisten.

Pertama, kita perlu memasang dan memulakan Zipkin atau Jaeger, dan kemudian mengkonfigurasi pengesanan teragih dalam aplikasi Beego. Dalam artikel ini, kami akan menggunakan Zipkin.

Pasang Zipkin:

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

Setelah Zipkin dilancarkan, anda boleh mengakses UI webnya melalui http://localhost:9411.

Seterusnya, kami perlu menambah sokongan untuk OpenTracing API dalam Beego. Kami boleh menggunakan pakej opentracing-go dan log permintaan silang perkhidmatan dan acara lain menggunakan API yang disediakannya. Contoh kod penjejakan adalah seperti berikut:

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
}

Dalam contoh di atas, kami mula-mula memulakan penjejak Zipkin dan kemudian menggunakannya untuk merekodkan beberapa acara. Kita boleh menambah teg dan pasangan nilai kunci dan menamatkan span dengan memanggil span.Finish().

Sekarang, mari tambahkan pengesanan teragih pada aplikasi Beego kami.

Pertama, mari tambahkan kebergantungan opentracing-go dan zipkin-go-opentracing. Kita boleh melakukan ini menggunakan mod go atau memasang pakej secara manual.

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

Kemudian, kita perlu memulakan perisian tengah penjejak Zipkin dan penjejak Beego dalam aplikasi Beego. Berikut ialah kod sampel untuk perisian tengah pengesan Beego:

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
}

Dalam kod sampel di atas, kami mentakrifkan perisian tengah bernama TraceMiddleware. Perisian tengah ini akan mengekstrak konteks penjejakan sedia ada daripada pengepala HTTP (jika ada) dan menggunakannya untuk mencipta penjejak baharu untuk permintaan tersebut. Kami juga menetapkan rentang dalam konteks permintaan supaya semua perisian tengah dan pengendali lain boleh mengaksesnya. Akhir sekali, selepas pelaksanaan pengendali tamat, kami memanggil kaedah finish() pada span supaya Zipkin boleh merekodkan penjejakan saling bergantung merentas semua perkhidmatan yang diminta.

Kami juga perlu melampirkan perisian tengah ini pada penghala Beego kami. Kita boleh melakukan ini menggunakan kod berikut dalam kod permulaan penghala:

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

Sekarang, lancarkan aplikasi Beego anda dan lawati http://localhost:9411 untuk membuka UI Zipkin untuk melihat data penjejakan.

Melaksanakan pengesanan teragih dalam aplikasi Beego mungkin kelihatan rumit, tetapi dengan menggunakan perpustakaan opentracing-go dan zipkin-go-opentracing, kami boleh menambah fungsi ini dengan mudah. Ini menjadi semakin penting apabila kami terus meningkatkan bilangan dan kerumitan perkhidmatan kami, membolehkan kami memahami cara perkhidmatan kami berfungsi bersama dan memastikan ia berfungsi dengan baik sepanjang proses pengendalian permintaan.

Atas ialah kandungan terperinci Menggunakan Zipkin dan Jaeger untuk melaksanakan pengesanan teragih dalam Beego. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!