OTLP-Messwerte mit einem OpenTelemetry-Sidecar schreiben

gcloud-Standardeinstellungen einrichten

So konfigurieren Sie gcloud mit Standardeinstellungen für den Cloud Run-Dienst:

1. Legen Sie ein Standardprojekt fest:

   gcloud config set project PROJECT_ID

   Ersetzen Sie PROJECT_ID durch den Namen des Projekts, das Sie für diese Anleitung erstellt haben.

2. Konfigurieren Sie gcloud für die von Ihnen ausgewählte Region:

   gcloud config set run/region REGION

   Ersetzen Sie REGION durch die unterstützte Cloud Run-Region Ihrer Wahl.

Artifact Registry-Image-Repository erstellen

Erstellen Sie ein Artifact Registry-Docker-Repository zum Hosten des Beispieldienst-Images:

gcloud artifacts repositories create run-otel \
    --repository-format=docker \
    --location=REGION \
    --project=PROJECT_ID

Dabei gilt:

• PROJECT_ID: Der Name des Projekts, das Sie für diese Anleitung erstellt haben.
• REGION: Unterstützte Cloud Run-Region Ihrer Wahl.

Codebeispiel abrufen

So rufen Sie das gewünschte Codebeispiel ab:

1. Klonen Sie das Repository der Beispiel-App auf Ihren lokalen Computer:

   Go

   git clone https://github.com/GoogleCloudPlatform/golang-samples.git

   Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.

2. Wechseln Sie in das Verzeichnis, das den Cloud Run-Beispielcode enthält:

   Go

   cd golang-samples/run/custom-metrics/

Code prüfen

Der Code dieser Anleitung besteht aus folgenden Elementen:

• Ein Server, der eingehende Anfragen verarbeitet und einen Messwert mit dem Namen sidecar_sample_counter generiert.

package main

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

	"go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc"
	"go.opentelemetry.io/otel/metric"
	sdkmetric "go.opentelemetry.io/otel/sdk/metric"
	"go.opentelemetry.io/otel/sdk/resource"
	semconv "go.opentelemetry.io/otel/semconv/v1.24.0"
)

var counter metric.Int64Counter

func main() {
	ctx := context.Background()
	shutdown := setupCounter(ctx)
	defer shutdown(ctx)

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
		log.Printf("defaulting to port %s", port)
	}

	http.HandleFunc("/", handler)
	log.Fatal(http.ListenAndServe(":"+port, nil))
}

func handler(w http.ResponseWriter, r *http.Request) {
	counter.Add(context.Background(), 100)
	fmt.Fprintln(w, "Incremented sidecar_sample_counter metric!")
}

func setupCounter(ctx context.Context) func(context.Context) error {
	serviceName := os.Getenv("K_SERVICE")
	if serviceName == "" {
		serviceName = "sample-cloud-run-app"
	}
	r, err := resource.Merge(
		resource.Default(),
		resource.NewWithAttributes(
			semconv.SchemaURL,
			semconv.ServiceName(serviceName),
		),
	)
	if err != nil {
		log.Fatalf("Error creating resource: %v", err)
	}

	exporter, err := otlpmetricgrpc.New(ctx,
		otlpmetricgrpc.WithInsecure(),
	)
	if err != nil {
		log.Fatalf("Error creating exporter: %s", err)
	}
	provider := sdkmetric.NewMeterProvider(
		sdkmetric.WithReader(sdkmetric.NewPeriodicReader(exporter)),
		sdkmetric.WithResource(r),
	)

	meter := provider.Meter("example.com/metrics")
	counter, err = meter.Int64Counter("sidecar-sample-counter")
	if err != nil {
		log.Fatalf("Error creating counter: %s", err)
	}
	return provider.Shutdown
}

• Einem Dockerfile, das die Betriebsumgebung für den Dienst definiert.

FROM golang:1.21 as builder
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o sample-app

FROM alpine:3
RUN apk add --no-cache ca-certificates
COPY --from=builder /app/sample-app /sample-app
CMD ["/sample-app"]

Das Beispiel enthält auch Dateien im Unterverzeichnis collector zum Erstellen eines benutzerdefinierten OpenTelemetry Collector:

• Eine Konfigurationsdatei für den OpenTelemetry Collector.

  receivers:
    otlp:
      protocols:
        grpc:
        http:
  
  processors:
    batch:
      # batch metrics before sending to reduce API usage
      send_batch_max_size: 200
      send_batch_size: 200
      timeout: 5s
  
    memory_limiter:
      # drop metrics if memory usage gets too high
      check_interval: 1s
      limit_percentage: 65
      spike_limit_percentage: 20
  
    # automatically detect Cloud Run resource metadata                                                                                                                                               
    resourcedetection:
      detectors: [env, gcp]
      timeout: 2s
      override: false
  
    resource:
      attributes:
        # add instance_id as a resource attribute                                                                                                                                                    
      - key: service.instance.id
        from_attribute: faas.id
        action: upsert
        # parse service name from K_SERVICE Cloud Run variable                                                                                                                                       
      - key: service.name
        value: ${env:K_SERVICE}
        action: insert
  
  exporters:
    googlemanagedprometheus: # Note: this is intentionally left blank   
  
  extensions:
    health_check:
  
  service:
    extensions: [health_check]
    pipelines:
      metrics:
        receivers: [otlp]
        processors: [batch, memory_limiter, resourcedetection, resource]
        exporters: [googlemanagedprometheus]

• Ein Dockerfile, das die bereitgestellte Konfiguration in einem vorgelagerten Collector-Image bündelt.

  FROM otel/opentelemetry-collector-contrib:0.101.0
  
  COPY collector-config.yaml /etc/otelcol-contrib/config.yaml

Code versenden

Das Versenden von Code erfolgt in drei Schritten: ein Container-Image mit Cloud Build erstellen, in Artifact Registry hochladen und in Cloud Run bereitstellen.

So versenden Sie den Code:

1. Erstellen Sie Ihren Beispieldienst-Container und veröffentlichen Sie ihn in Artifact Registry.

   gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/run-otel/sample-metrics-app

   Bei Erfolg sollte eine Bestätigungsmeldung mit der ID, der Erstellungszeit und dem Image-Namen angezeigt werden. Das Image wird in Container Registry gespeichert und kann bei Bedarf wiederverwendet werden.

2. Erstellen Sie einen Container und veröffentlichen Sie ihn in Artifact Registry.

   gcloud builds submit collector --tag REGION-docker.pkg.dev/PROJECT_ID/run-otel/otel-collector-metrics

   Bei Erfolg sollte eine Bestätigungsmeldung mit der ID, der Erstellungszeit und dem Image-Namen angezeigt werden. Das Image wird in Container Registry gespeichert und kann bei Bedarf wiederverwendet werden.

3. Stellen Sie Ihre Anwendung bereit:

   YAML

   1. Erstellen Sie eine neue Datei mit dem Namen service.yaml und folgendermaßen:

      apiVersion: serving.knative.dev/v1
      kind: Service
      metadata:
        name: SERVICE-NAME
        annotations:
          run.googleapis.com/launch-stage: BETA
      spec:
        template:
          metadata:
            annotations:
              run.googleapis.com/container-dependencies: "{app:[collector]}"
          spec:
            containers:
            - image: REGION-docker.pkg.dev/PROJECT_ID/run-otel/sample-metrics-app
              name: app
              ports:
              - containerPort: CONTAINER_PORT
              env:
              - name: "OTEL_EXPORTER_OTLP_ENDPOINT"
                value: "http://localhost:4317"
            - image: REGION-docker.pkg.dev/PROJECT_ID/run-otel/otel-collector-metrics
              name: collector
              startupProbe:
                httpGet:
                  path: /
                  port: 13133
      

   2. Dabei gilt:
      • CONTAINER_PORT: Der Port des Ingress-Containers Ihres Dienstes. Der Standardwert ist 8080.
      • SERVICE-NAME: Ein beliebiger Name für den Dienst, z. B. custom-metrics-sample-service.

4. Erstellen Sie den Dienst mit dem folgenden Befehl:

   gcloud run services replace service.yaml

   Dieser Befehl gibt eine Dienst-URL zurück. Mit dieser URL können Sie die Beispielanwendung unter Testen ausprobieren.

Testen

Stellen Sie über die URL aus dem Befehl gcloud run unter Code senden eine Verbindung zum Dienst her, um Beispielmesswerte zu generieren. Sie können diesen Befehl mehrmals ausführen, um interessantere Daten zu generieren:

curl -H \
"Authorization: Bearer $(gcloud auth print-identity-token)" \
SERVICE_URL

Ersetzen Sie SERVICE_URL durch die URL Ihres Dienstes.

Rufen Sie als Nächstes im Cloud Monitoring-Bereich der Google Cloud Console den Metrics Explorer auf und wählen Sie den Messwert sidecar_sample_counter aus.

Sie können die Messwerte auch mit PromQL abfragen. Die folgende Abfrage filtert beispielsweise Messwerte anhand der Cloud Run-Instanz-ID:

sidecar_sample_counter{instance="INSTANCE_ID"}

Ersetzen Sie INSTANCE_ID durch die ID einer beliebigen Instanz für Ihren Dienst (verfügbar in den Instanzlogs oder vom Metadatenserver).

Mit dieser Abfrage wird ein Diagramm wie das folgende erstellt: