Scrivere metriche OTLP utilizzando un sidecar OpenTelemetry Collector

Questo tutorial mostra come scrivere, eseguire il deployment e chiamare un servizio Cloud Run che riporta metriche OTLP personalizzate a Google Cloud Managed Service per Prometheus utilizzando l'agente di raccolta OpenTelemetry integrato in Google come sidecar. Per informazioni sul raccoglitore creato da Google, vedi Panoramica del raccoglitore OpenTelemetry creato da Google.

Se hai un servizio Cloud Run che segnala metriche Prometheus, utilizza invece il file collaterale Prometheus per Cloud Run.

Obiettivi

• Scrivi, crea ed esegui il deployment di un servizio in Cloud Run con l'agente di raccolta OpenTelemetry integrato in Google come file collaterale.
• Genera metriche personalizzate e segnalale a Google Cloud Managed Service per Prometheus.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

• Cloud Build
• Artifact Registry
• Google Cloud Managed Service For Prometheus
• Cloud Run

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Prima di iniziare

Accedi al tuo account Google Cloud . Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei workload.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

1. Abilita le API Cloud Run, Cloud Monitoring, Artifact Registry e Cloud Build.

   Ruoli richiesti per abilitare le API

   Per abilitare le API, devi disporre del ruolo IAM Amministratore utilizzo dei servizi (roles/serviceusage.serviceUsageAdmin), che include l'autorizzazione serviceusage.services.enable. Scopri come concedere i ruoli.

   Abilita le API

2. Installa e inizializza gcloud CLI.
3. Aggiorna Google Cloud CLI: gcloud components update

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per completare il tutorial, chiedi all'amministratore di concederti i seguenti ruoli IAM nel progetto:

• Editor Cloud Build (roles/cloudbuild.builds.editor)
• Cloud Run Admin (roles/run.admin)
• Crea service account (roles/iam.serviceAccountCreator)
• Project IAM Admin (roles/resourcemanager.projectIamAdmin)
• Monitoring Metric Writer (roles/monitoring.metricWriter)
• Utente Service Account (roles/iam.serviceAccountUser)
• Consumer Service Usage (roles/serviceusage.serviceUsageConsumer)
• Storage Admin (roles/storage.admin)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Nota:i ruoli di base IAM potrebbero contenere anche autorizzazioni per completare il tutorial. Non devi concedere ruoli di base in un ambiente di produzione, ma puoi concederli in un ambiente di sviluppo o test.

Tieni presente inoltre che l'identità del servizio Cloud Run richiede il ruolo Writer metriche Monitoring (roles/monitoring.metricWriter). Il service account predefinito di Compute Engine potrebbe avere questo ruolo per impostazione predefinita, ma potresti doverlo aggiungere se hai modificato le sue autorizzazioni o se utilizzi un account di servizio diverso.

Configurazione dei valori predefiniti di gcloud

Per configurare gcloud con le impostazioni predefinite per il tuo servizio Cloud Run:

1. Imposta il progetto predefinito:

   gcloud config set project PROJECT_ID

   Sostituisci PROJECT_ID con il nome del progetto che hai creato per questo tutorial.

2. Configura gcloud per la regione scelta:

   gcloud config set run/region REGION

   Sostituisci REGION con la regione Cloud Run supportata che preferisci.

Località Cloud Run

Cloud Run è regionale, il che significa che l'infrastruttura che esegue i tuoi servizi Cloud Run si trova in una regione specifica ed è gestita da Google per essere disponibile in modo ridondante in tutte le zone all'interno di quella regione.

Il rispetto dei requisiti di latenza, disponibilità o durabilità è un fattore primario per la selezione della regione in cui vengono eseguiti i servizi Cloud Run. In genere puoi selezionare la regione più vicina ai tuoi utenti, ma devi considerare la posizione degli altri Google Cloudprodotti utilizzati dal tuo servizio Cloud Run. L'utilizzo combinato di prodotti Google Cloud in più località può influire sulla latenza e sui costi del servizio.

Cloud Run è disponibile nelle seguenti regioni:

Soggetto ai prezzi di Livello 1

• asia-east1 (Taiwan)
• asia-northeast1 (Tokyo)
• asia-northeast2 (Osaka)
• asia-south1 (Mumbai, India)
• asia-southeast3 (Bangkok)
• europe-north1 (Finlandia) Bassi livelli di CO₂
• europe-north2 (Stoccolma) Bassi livelli di CO₂
• europe-southwest1 (Madrid) Bassi livelli di CO₂
• europe-west1 (Belgio) Bassi livelli di CO₂
• europe-west4 (Paesi Bassi) Bassi livelli di CO₂
• europe-west8 (Milano)
• europe-west9 (Parigi) Bassi livelli di CO₂
• me-west1 (Tel Aviv)
• northamerica-south1 (Messico)
• us-central1 (Iowa) Bassi livelli di CO₂
• us-east1 (Carolina del Sud)
• us-east4 (Virginia del Nord)
• us-east5 (Columbus)
• us-south1 (Dallas) Bassi livelli di CO₂
• us-west1 (Oregon) Bassi livelli di CO₂

Soggetto ai prezzi di Livello 2

• africa-south1 (Johannesburg)
• asia-east2 (Hong Kong)
• asia-northeast3 (Seul, Corea del Sud)
• asia-southeast1 (Singapore)
• asia-southeast2 (Giacarta)
• asia-south2 (Delhi, India)
• australia-southeast1 (Sydney)
• australia-southeast2 (Melbourne)
• europe-central2 (Varsavia, Polonia)
• europe-west10 (Berlino)
• europe-west12 (Torino)
• europe-west2 (Londra, Regno Unito) Bassi livelli di CO₂
• europe-west3 (Francoforte, Germania)
• europe-west6 (Zurigo, Svizzera) Bassi livelli di CO₂
• me-central1 (Doha)
• me-central2 (Dammam)
• northamerica-northeast1 (Montreal) Bassi livelli di CO₂
• northamerica-northeast2 (Toronto) Bassi livelli di CO₂
• southamerica-east1 (San Paolo, Brasile) Bassi livelli di CO₂
• southamerica-west1 (Santiago, Cile) Bassi livelli di CO₂
• us-west2 (Los Angeles)
• us-west3 (Salt Lake City)
• us-west4 (Las Vegas)

Se hai già creato un servizio Cloud Run, puoi visualizzare la regione nella dashboard di Cloud Run nella consoleGoogle Cloud .

Ok

Creazione di un repository di immagini Artifact Registry

Crea un repository Docker in Artifact Registry per ospitare l'immagine del servizio di esempio:

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

Sostituisci quanto segue:

• PROJECT_ID con il nome del progetto che hai creato per questo tutorial.
• REGION REGION con la regione Cloud Run supportata che preferisci.

Recupero dell'esempio di codice

Per recuperare l'esempio di codice da utilizzare:

1. Clona il repository dell'app di esempio sulla tua macchina locale:

   Go

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

   In alternativa puoi scaricare l'esempio come file ZIP ed estrarlo.

2. Passa alla directory che contiene il codice campione di Cloud Run:

   Go

   cd golang-samples/run/custom-metrics/

Revisione del codice

Il codice per questo tutorial è costituito da quanto segue:

• Un server che gestisce le richieste in entrata e genera una metrica denominata 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 che definisce l'ambiente operativo per il servizio.

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

L'esempio include anche i file nella sottodirectory collector per la creazione di un agente di raccolta personalizzato:

• Un file di configurazione per l'agente di raccolta.

  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 che raggruppa la configurazione fornita in un'immagine del collettore upstream.

  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

Spedizione del codice in corso…

La spedizione del codice è composta da tre passaggi: la creazione di un'immagine container con Cloud Build, il caricamento dell'immagine container in Artifact Registry e il deployment dell'immagine container in Cloud Run.

Per spedire il codice:

1. Crea il contenitore del servizio di esempio e pubblicalo in Artifact Registry:

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

   In caso di esito positivo, dovresti visualizzare un messaggio di operazione riuscita contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e può essere riutilizzata se lo desideri.

2. Crea il container del raccoglitore e pubblicalo su Artifact Registry:

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

   In caso di esito positivo, dovresti visualizzare un messaggio di operazione riuscita contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e può essere riutilizzata se lo desideri.

3. Esegui il deployment dell'applicazione:

   YAML

   1. Crea un nuovo file denominato service.yaml con quanto segue:

      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. Sostituisci quanto segue:
      • CONTAINER_PORT con la porta su cui il container in entrata del servizio rimane in ascolto. Per impostazione predefinita, questo valore è 8080.
      • SERVICE-NAME con un nome per il tuo servizio, ad esempio custom-metrics-sample-service.

4. Crea il nuovo servizio con il seguente comando:

   gcloud run services replace service.yaml

   Questo comando restituisce un URL del servizio. Utilizza questo URL per provare l'applicazione di esempio in Prova.

Prova

Utilizzando l'URL del comando gcloud run in Invio del codice�, connettiti al servizio per generare alcune metriche di esempio (puoi eseguire questo comando più volte per generare dati più interessanti):

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

Sostituisci SERVICE_URL con l'URL del tuo servizio.

Successivamente, vai a Esplora metriche nella sezione Cloud Monitoring della console Google Cloud e seleziona la metrica sidecar_sample_counter_total.

Puoi anche eseguire query sulle metriche con PromQL. Ad esempio, la query seguente filtra le metriche in base all'ID istanza Cloud Run:

sidecar_sample_counter_total{instance="INSTANCE_ID"}

Sostituisci INSTANCE_ID con l'ID di qualsiasi istanza per il tuo servizio (disponibile nei log delle istanze o dal server di metadati).

Questa query produce un grafico come quello riportato di seguito:

Operazione riuscita: hai eseguito il deployment di un servizio Cloud Run che segnala metriche OTLP personalizzate a Google Cloud Managed Service per Prometheus.

Esegui la pulizia

Per evitare addebiti aggiuntivi al tuo account Google Cloud , elimina tutte le risorse che hai implementato con questo tutorial.

Elimina il progetto

Se hai creato un nuovo progetto per questo tutorial, eliminalo. Se hai utilizzato un progetto esistente e devi conservarlo senza le modifiche aggiunte in questo tutorial, elimina le risorse che hai creato per il tutorial.

Il modo più semplice per eliminare la fatturazione è eliminare il progetto creato per il tutorial.

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per, le attività descritte in questo documento, eliminerai anche tutto il lavoro che hai svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

1. Nella console Google Cloud , vai alla pagina Gestisci risorse.

   Vai a Gestisci risorse

2. Nell'elenco dei progetti, seleziona quello che vuoi eliminare, quindi fai clic su Elimina.
3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Elimina le risorse del tutorial

1. Elimina il servizio Cloud Run di cui hai eseguito il deployment in questo tutorial. I servizi Cloud Run non comportano costi finché non ricevono richieste.

   Per eliminare il servizio Cloud Run, esegui questo comando:

   gcloud run services delete SERVICE-NAME

   Sostituisci SERVICE-NAME con il nome del servizio.

   Puoi eliminare i servizi Cloud Run anche dalla consoleGoogle Cloud .

2. Rimuovi la configurazione della regione predefinita gcloud che hai aggiunto durante la configurazione del tutorial:

    gcloud config unset run/region
   

3. Rimuovi la configurazione del progetto:

    gcloud config unset project
   

4. Elimina le altre Google Cloud risorse create in questo tutorial:

   • Elimina il repository Docker di Artifact Registry

Passaggi successivi

Altri esempi, inclusi quelli per tracce e log, sono disponibili su GitHub.