Se usó la API de Cloud Translation para traducir esta página.

Escribe métricas de OTLP mediante un archivo adicional del recopilador de OpenTelemetry

En este instructivo, se muestra cómo escribir, implementar y llamar a un servicio de Cloud Run que informa métricas de OTLP personalizadas a Google Cloud Managed Service para Prometheus con el recopilador de OpenTelemetry integrado en Google como archivo adicional. Para obtener información sobre el recopilador integrado en Google, consulta Descripción general del recopilador de OpenTelemetry integrado en Google.

Si tienes un servicio de Cloud Run que informa las métricas de Prometheus, usa el sidecar de Prometheus para Cloud Run en su lugar.

Configura los valores predeterminados de gcloud

A fin de configurar gcloud con los valores predeterminados para el servicio de Cloud Run, sigue estos pasos:

Configura el proyecto predeterminado:
```
gcloud config set project PROJECT_ID
```
Reemplaza PROJECT_ID por el nombre del proyecto que creaste para este instructivo.
Configura gcloud en la región que elegiste:
```
gcloud config set run/region REGION
```
Reemplaza REGION por la región de Cloud Run compatible que prefieras.

Ubicaciones de Cloud Run

Cloud Run es regional, lo que significa que la infraestructura que ejecuta los servicios se ubica en una región específica, y Google la administra para que esté disponible de manera redundante en todas las zonas de esa región.

El cumplimiento de los requisitos de latencia, disponibilidad o durabilidad es el factor principal para seleccionar la región en la que se ejecutan los servicios de Cloud Run. Por lo general, puedes seleccionar la región más cercana a tus usuarios, pero debes considerar la ubicación de los otros Google Cloud productos que usa tu servicio de Cloud Run. Si usas Google Cloud productos en varias ubicaciones, la latencia y el costo del servicio pueden verse afectados.

Cloud Run está disponible en las siguientes regiones:

Sujetas a los Precios del nivel 1

asia-east1 (Taiwán)
asia-northeast1 (Tokio)
asia-northeast2 (Osaka)
asia-south1 (Bombay, India)
europe-north1 (Finlandia) Bajo nivel de CO₂
europe-north2 (Estocolmo) Bajo nivel de CO₂
europe-southwest1 (Madrid) Bajo nivel de CO₂
europe-west1 (Bélgica) Bajo nivel de CO₂
europe-west4 (Países Bajos) Bajo nivel de CO₂
europe-west8 (Milán)
europe-west9 (París) Bajo nivel de CO₂
me-west1 (Tel Aviv)
northamerica-south1 (México)
us-central1 (Iowa) Bajo nivel de CO₂
us-east1 (Carolina del Sur)
us-east4 (Virginia del Norte)
us-east5 (Columbus)
us-south1 (Dallas) Bajo nivel de CO₂
us-west1 (Oregón) Bajo nivel de CO₂

Sujetas a los Precios del nivel 2

africa-south1 (Johannesburgo)
asia-east2 (Hong Kong)
asia-northeast3 (Seúl, Corea del Sur)
asia-southeast1 (Singapur)
asia-southeast2 (Yakarta)
asia-south2 Delhi (India)
australia-southeast1 (Sídney)
australia-southeast2 (Melbourne)
europe-central2 (Varsovia, Polonia)
europe-west10 (Berlín)
europe-west12 (Turín)
europe-west2 (Londres, Reino Unido) Bajo nivel de CO₂
europe-west3 (Fráncfort, Alemania)
europe-west6 (Zúrich, Suiza) Bajo nivel de CO₂
me-central1 (Doha)
me-central2 (Dammam)
northamerica-northeast1 (Montreal) Bajo nivel de CO₂
northamerica-northeast2 (Toronto) Bajo nivel de CO₂
southamerica-east1 (São Paulo, Brasil) Bajo nivel de CO₂
southamerica-west1 (Santiago, Chile) Bajo nivel de CO₂
us-west2 (Los Ángeles)
us-west3 (Salt Lake City)
us-west4 (Las Vegas)

Si ya creaste un servicio de Cloud Run, puedes ver la región en el panel de Cloud Run en la consola.Google Cloud

Crea un repositorio de imágenes de Artifact Registry

Crea un repositorio de Docker de Artifact Registry para alojar la imagen del servicio de muestra:

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

Reemplaza lo siguiente:

PROJECT_ID por el nombre del proyecto que creaste para este instructivo.
REGION por la región de Cloud Run compatible que prefieras.

Recupera la muestra de código

A fin de recuperar la muestra de código para su uso, haz lo siguiente:

Clona el repositorio de la app de muestra en tu máquina local:
Go
```
git clone https://github.com/GoogleCloudPlatform/golang-samples.git
```
De manera opcional, puedes descargar la muestra como un archivo ZIP y extraerla.
Ve al directorio que contiene el código de muestra de Cloud Run:
Go
```
cd golang-samples/run/custom-metrics/
```

Revisa el código

El código de este instructivo consta de los siguientes elementos:

Un servidor que controla las solicitudes entrantes y genera una métrica llamada sidecar_sample_counter_total

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_total 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(
			resource.Default().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
}

Un Dockerfile que define el entorno operativo del servicio.

FROM golang:1.24 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"]

En la muestra, también se incluyen archivos en el subdirectorio collector para compilar un recopilador personalizado:

Es un archivo de configuración para el recopilador.

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:
    endpoint: 0.0.0.0:13133
service:
  extensions: [health_check]
  pipelines:
    metrics:
      receivers: [otlp]
      processors: [batch, memory_limiter, resourcedetection, resource]
      exporters: [googlemanagedprometheus]

Un Dockerfile que agrupa el archivo de configuración proporcionado en una imagen ascendente de recopilador.

FROM us-docker.pkg.dev/cloud-ops-agents-artifacts/google-cloud-opentelemetry-collector/otelcol-google:0.121.0

COPY collector-config.yaml /etc/otelcol-google/config.yaml

Envía el código

El código de envío consta de tres pasos: compilar una imagen de contenedor con Cloud Build, subir la imagen de contenedor a Artifact Registry y, luego, implementar la imagen de contenedor en Cloud Run.

Para enviar el código, haz lo siguiente:

Compila el contenedor de servicio de muestra y publica en Artifact Registry:
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/run-otel/sample-metrics-app
```
Si la operación se completa de manera correcta, deberías ver un mensaje de ÉXITO con el ID, la hora de creación y el nombre de la imagen. La imagen se almacena en Artifact Registry y puede volver a usarse si así se desea.
Compila el contenedor del recopilador y publica en Artifact Registry:
```
gcloud builds submit collector --tag REGION-docker.pkg.dev/PROJECT_ID/run-otel/otel-collector-metrics
```
Si la operación se completa de manera correcta, deberías ver un mensaje de ÉXITO con el ID, la hora de creación y el nombre de la imagen. La imagen se almacena en Artifact Registry y puede volver a usarse si así se desea.

Implementa tu aplicación:

YAML

Crea un nuevo archivo llamado service.yaml con el siguiente contenido:

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

Reemplaza lo siguiente:
- CONTAINER_PORT por el puerto en el que escucha el contenedor de entrada de tu servicio. El valor predeterminado es 8080.
- SERVICE-NAME por cualquier nombre para tu servicio, como custom-metrics-sample-service.

Crea el Service nuevo con el siguiente comando:
```
gcloud run services replace service.yaml
```
Este comando muestra una URL de servicio. Usa esta URL para probar la aplicación de muestra en Prueba.

Prueba

Usa la URL del comando gcloud run en Envía el código para conectarte al servicio y generar algunas métricas de muestra (puedes ejecutar este comando varias veces para generar datos más interesantes):

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

Reemplaza SERVICE_URL por la URL de tu servicio.

A continuación, navega al Explorador de métricas dentro de la sección Cloud Monitoring de la consola de Google Cloud y selecciona la métrica sidecar_sample_counter_total.

Métrica personalizada que se muestra en la IU del Explorador de métricas

También puedes consultar las métricas con PromQL. Por ejemplo, la siguiente consulta filtrará las métricas según el ID de instancia de Cloud Run:

sidecar_sample_counter_total{instance="INSTANCE_ID"}

Reemplaza INSTANCE_ID por el ID de cualquier instancia de tu servicio (disponible en los registros de la instancia o desde el servidor de metadatos).

Esta consulta genera un gráfico como el que se muestra a continuación:

Métrica personalizada consultada por PromQL