[GO] Verwendung der GCP-Ablaufverfolgung mit offener Telemetrie

In diesem Artikel wird beschrieben, wie Sie Open Source mit dem Namen openTelemetry verwenden, um mit der Trace-Funktion von Google Cloud Platform (GCP) zu messen. Dieses Trace-Ziel wird in CloudRun ausgeführt.

Was ist offene Telemetrie?

openTelemetry ist eine Open Source zur Analyse des Verhaltens immer komplexerer Systeme. Durch Messen der Zeit der ausgeführten Verarbeitung kann nach der Ursache gesucht werden, die zum Engpass oder Fehler führt. Es gibt eine Open Source für verteilte Ablaufverfolgung namens openCensus, und openTelemetry ist der Nachfolger. openTelemetry

Trace-Struktur

Erstellen Sie beim Starten von Trace zunächst eine Identifikations-ID mit dem Namen TraceID. Diese ID macht das Trace-Ziel eindeutig und verknüpft es mit dem Messbereich namens Span. Span hat eine Eltern-Kind-Beziehung und kann die Messung unterteilen. Die folgende Abbildung hat eine Struktur, die die obere übergeordnete Spanne in drei Bereiche unterteilt und die mittlere untergeordnete Spanne2 detaillierter nachzeichnet.

Implementiert mit Go

Terminal: MacBook PRO Go : go1.15.2 Cloud: GCP

Installation

1. Download go https://golang.org/doc/install
2. Installieren Sie von der heruntergeladenen Datei
3. Fügen Sie die PATH-Einstellung hinzu

$ export PATH=/usr/local/go/bin:$PATH

Initialisieren

Initialisieren Sie, um das Modul mit ** go mod ** zu verwalten. Durch Ausführen des folgenden Befehls wird eine Datei mit dem Namen ** go.mod ** erstellt.

$ go mod init example.com/trace

Anschließend wird durch Festlegen des zu ladenden Moduls im Code und Erstellen des Moduls die Einstellung des automatisch in go.mod zu ladenden Moduls hinzugefügt.

Verfassung

Die endgültige Konfiguration sieht folgendermaßen aus:

.
├── Dockerfile
├── go.mod
├── go.sum
└── main.go

Quellcode

main.go

Ich erstelle eine API, die HTTP-Anforderungen empfängt. Laden Sie das Paket für die Ablaufverfolgung und nehmen Sie erste Einstellungen vor, z. B. Projekteinstellungen. In diesem Code

1. Erstellen Sie einen Tracer mit dem Namen ** example.com/trace **
2. Starten Sie eine Spanne mit dem Namen ** sample **
3. Messen Sie die Verarbeitungszeit bei jedem Schritt tun.

package main

import (
        "context"
        "fmt"
        "log"
        "net/http"
        "os"
        "time"

        texporter "github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/trace"
        "go.opentelemetry.io/otel/api/global"
        sdktrace "go.opentelemetry.io/otel/sdk/trace"
)

func handler(w http.ResponseWriter, r *http.Request) {

        exporter, err := texporter.NewExporter(texporter.WithProjectID("{project id}"))
        if err != nil {
                log.Fatalf("texporter.NewExporter: %v", err)
        }

        tp, err := sdktrace.NewProvider(sdktrace.WithSyncer(exporter))
        if err != nil {
                log.Fatal(err)
        }

        global.SetTraceProvider(tp)
        tracer := global.TraceProvider().Tracer("example.com/trace")

        ctx, span := tracer.Start(context.Background(), "sample")
	    defer span.End()

	    _, step1 := tracer.Start(ctx, "step1")
        time.Sleep(time.Second * 1)
	    step1.End()

	    _, step2 := tracer.Start(ctx, "step2")
        time.Sleep(time.Second * 2)
	    step2.End()

        fmt.Fprintf(w, "Done\n")
}

func main() {

        http.HandleFunc("/", handler)

        port := os.Getenv("PORT")
        if port == "" {
                port = "8080"
        }

        log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), nil))
}

Dockerfile Erstellen Sie oben eine ausführbare Datei mit einem mehrstufigen Build. Erstellen Sie ein Image für die Bereitstellung, indem Sie nur die erstellte ausführbare Datei in das alpine Image kopieren.

FROM golang:1.15 as builder

WORKDIR /app

COPY go.* ./
RUN go mod download
COPY . ./

RUN CGO_ENABLED=0 GOOS=linux go build -v -o server


FROM alpine:3
RUN apk add --no-cache ca-certificates

COPY --from=builder /app/server /server

CMD ["/server"]

Bauen

Bereitstellung auf Cloud Run. Verwenden Sie ** gcloud Builds Submit **, um das Image zu erstellen und in der Container-Registrierung zu speichern. Verwenden Sie dann ** gcloud run deploy **, um das gespeicherte Image bereitzustellen.

$ gcloud builds submit --tag gcr.io/$1/{Bildname}
$ gcloud run deploy {Dienstname} --image gcr.io/$1/{Bildname} --platform managed --memory 256M --region {region} --allow-unauthenticated

Ergebnis

Wenn Sie die bereitgestellte API ausführen und den GCP-Trace anzeigen, wird Folgendes angezeigt:

Die Ausführungszeiten von Schritt 1 und Schritt 2 werden visualisiert und im Bereich der Probe angezeigt. Ich konnte die Zeit leicht messen, indem ich einen Tracer erstellte und den Teil umgab, den ich messen wollte. Durch Ausführen eines Tracers für das Kontextargument ist es auch möglich, verschachtelt zu messen, sodass überprüft werden kann, welcher Teil der API die Verarbeitungszeit benötigt. Durch das Sammeln der Trace-Ergebnisse kann später überprüft werden, ob die Geschwindigkeit konstant langsam ist oder die Verarbeitung nur zu diesem Zeitpunkt langsam ist, und ich denke, dass es einen großen Vorteil gibt.