Questa pagina è stata tradotta dall'API Cloud Translation.

Scrivere metriche OTLP utilizzando un sidecar OpenTelemetry Collector

Questo tutorial mostra come scrivere, eseguire il deployment e chiamare un servizio Cloud Run che segnala metriche OTLP personalizzate a Google Cloud Managed Service per Prometheus utilizzando Google-Built OpenTelemetry Collector 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.

Configurazione dei valori predefiniti di gcloud

Per configurare gcloud con i valori predefiniti per il tuo servizio Cloud Run:

Imposta il progetto predefinito:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con il nome del progetto che hai creato per questo tutorial.
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à sono fattori primari 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 Cloud prodotti utilizzati dal tuo servizio Cloud Run. L'utilizzo combinato dei 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)
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) A basse emissioni 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 Cloud Run nella consoleGoogle Cloud .

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:

Clona il repository dell'app di esempio sulla tua macchina locale:
Vai
```
git clone https://github.com/GoogleCloudPlatform/golang-samples.git
```
In alternativa, puoi scaricare il campione come file ZIP ed estrarlo.
Passa alla directory che contiene il codice campione di Cloud Run:
Vai
```
cd golang-samples/run/custom-metrics/
```

Revisione del codice

Il codice di 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.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"]

Il campione include anche file nella sottodirectory collector per la creazione di un raccoglitore personalizzato:

Un file di configurazione per il raccoglitore.

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 raccoglitore 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

Invio 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:

Crea il contenitore del servizio di esempio e pubblicalo su 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.
Crea il contenitore 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.

Esegui il deployment dell'applicazione:

YAML

Crea un nuovo file denominato service.yaml con i seguenti contenuti:

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

Sostituisci quanto segue:
- CONTAINER_PORT con la porta su cui il container di ingresso del servizio rimane in ascolto. Per impostazione predefinita, questo valore è 8080.
- Sostituisci SERVICE-NAME con un nome per il tuo servizio, ad esempio custom-metrics-sample-service.

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.

Metrica personalizzata mostrata nell'interfaccia utente di Esplora metriche

Puoi anche eseguire query sulle metriche con PromQL. Ad esempio, la query riportata di seguito 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:

Metrica personalizzata sottoposta a query da PromQL