[GO] Comment utiliser la trace GCP avec la télémétrie ouverte

Cet article explique comment utiliser l'open source appelé openTelemetry pour mesurer avec la fonction Trace de Google Cloud Platform (GCP). Cette cible Trace est exécutée sur CloudRun.

Qu'est-ce que la télémétrie ouverte?

openTelemetry est une open source pour analyser le comportement de systèmes de plus en plus complexes. En mesurant le temps du traitement exécuté, vous pouvez rechercher la cause qui conduit au goulot d'étranglement ou à l'échec. Il existe une source ouverte pour le traçage distribué appelé openCensus, et openTelemetry est le successeur. openTelemetry

Structure de trace

Au démarrage de Trace, créez d'abord un ID d'identification appelé TraceID. Cet ID rend la cible Trace unique et la relie à la section de mesure appelée Span. Span a une relation parent-enfant et peut subdiviser la mesure. La figure ci-dessous a une structure qui divise le parent supérieur Span en trois et trace le centre enfant Span2 plus en détail.

Mis en œuvre avec Go

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

Installation

1. Téléchargez go https://golang.org/doc/install
2. Installez à partir du fichier téléchargé
3. Ajouter le paramètre PATH

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

Initialiser

Initialisez pour gérer le module en utilisant ** go mod **. L'exécution de la commande suivante créera un fichier appelé ** go.mod **.

$ go mod init example.com/trace

Après cela, en définissant le module à charger dans le code et en le construisant, le paramètre du module à charger automatiquement dans go.mod sera ajouté.

Constitution

La configuration finale ressemble à ceci:

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

Code source

main.go

Je crée une API qui reçoit des requêtes HTTP. Chargez le package pour le traçage et définissez les paramètres initiaux tels que les paramètres du projet. Dans ce code

1. Créez un traceur appelé ** example.com/trace **
2. Démarrez une étendue nommée ** sample **
3. Mesurez le temps de traitement à chaque étape Faire.

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 Créez un fichier exécutable en haut à l'aide d'une construction en plusieurs étapes. Créez une image à déployer en copiant uniquement le fichier exécutable créé dans l'image alpine.

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"]

Construire

Déployez sur Cloud Run. Utilisez ** gcloud builds submit ** pour créer l'image et l'enregistrer dans Container Registry. Utilisez ensuite ** gcloud run deploy ** pour déployer à partir de l'image enregistrée.

$ gcloud builds submit --tag gcr.io/$1/{Nom de l'image}
$ gcloud run deploy {Nom du service} --image gcr.io/$1/{Nom de l'image} --platform managed --memory 256M --region {region} --allow-unauthenticated

résultat

Si vous exécutez l'API déployée et examinez le suivi GCP, vous verrez quelque chose comme ceci:

Les temps d'exécution de l'étape 1 et de l'étape 2 sont visualisés et affichés dans la plage de l'échantillon. J'ai pu mesurer facilement le temps en créant un traceur et en entourant la partie que je voulais mesurer. De plus, en exécutant un traceur sur l'argument de contexte, il est possible de mesurer de manière imbriquée, il est donc possible de vérifier quelle partie de l'API prend le temps de traitement. En collectant les résultats de la trace, il est possible de vérifier plus tard si la vitesse est constamment lente ou si le traitement n'est lent qu'à ce moment-là, et je pense qu'il y a un grand mérite.