Questo documento mostra come instrumentare automaticamente le applicazioni Java in esecuzione su Google Kubernetes Engine (GKE) utilizzando l'instrumentazione zero-code di OpenTelemetry. L'instrumentazione senza codice offre un'osservabilità completa dei tuoi workload Java con il minimo sforzo manuale.
Questa procedura dettagliata fornisce i passaggi dettagliati per il deployment di un'applicazione Java di esempio in GKE, l'instrumentazione automatica dell'applicazione utilizzando OpenTelemetry e la visualizzazione dei segnali di telemetria generati utilizzando Google Cloud Observability.
La procedura dettagliata descrive l'instrumentazione automatica dei workload Java in esecuzione su GKE, ma puoi estendere queste istruzioni ad altri linguaggi supportati.
Perché utilizzare l'instrumentazione zero-code?
L'instrumentazione zero-code (chiamata anche instrumentazione automatica) in OpenTelemetry è un potente strumento che consente agli sviluppatori di applicazioni di aggiungere l'osservabilità configurabile al proprio codice senza dover scrivere codice aggiuntivo o modificare il codice esistente. L'instrumentazione zero-code funziona aggiungendo automaticamente l'instrumentazione alle librerie di applicazioni distribuite attivamente, fornendo informazioni affidabili sul rendimento delle applicazioni tramite l'emissione di indicatori dorati. Ciò rende l'instrumentazione zero-code un ottimo punto di partenza per il percorso di osservabilità di un'applicazione.
L'instrumentazione senza codice in Java emette metriche e intervalli di traccia instrumentando librerie popolari ampiamente utilizzate nell'ecosistema del linguaggio. Per Java, le metriche includono:
- Metriche di runtime JVM emesse dalla piattaforma Java
- Metriche HttpClient e intervalli HttpClient emessi da librerie come la libreria client HTTP Java e la libreria client HTTP Google.
- Metriche del client di database e intervalli del client di database emessi da librerie come JDBC e Lettuce.
Il set di metriche emesse dipende dall'applicazione instrumentata e dalle librerie utilizzate dall'applicazione. Per un elenco completo delle librerie e dei framework che possono essere instrumentati dall'agente di instrumentazione zero-code Java, consulta Librerie e framework supportati.
Con la strumentazione automatica puoi:
- Ottieni il monitoraggio dei Golden Signals senza dover apportare modifiche al codice.
- Correlare la latenza p99.9 elevata alle tracce dei singoli utenti, che coprono ogni chiamata RPC.
- Ottieni una telemetria coerente per metriche, log e tracce da un'ampia varietà di librerie e framework comuni.
Per saperne di più sull'instrumentazione zero-code, consulta la pagina Zero-code di OpenTelemetry.
Panoramica
L'aggiunta dell'osservabilità a un carico di lavoro Java in esecuzione su GKE richiede il deployment dei seguenti componenti:
- Strumentazione zero-code OpenTelemetry, che genera la telemetria dalla tua applicazione.
- OpenTelemetry Collector, che raccoglie i dati di telemetria generati dalla tua applicazione, li arricchisce con metadati e contesto critici e li indirizza a Google Cloud per il consumo.
In questa procedura dettagliata, esegui il deployment di un'applicazione Java strumentata su GKE che emette metriche e tracce in Google Cloud. Puoi quindi visualizzare questi indicatori di telemetria utilizzando le offerte di osservabilità di Google Cloud, comeMetrics Explorere, Esplora log ed Esplora tracce. Per informazioni su come visualizzare e utilizzare la telemetria generata, consulta Visualizzare la telemetria.
Questa procedura dettagliata utilizza i seguenti servizi a pagamento per scrivere segnali:
- Managed Service per Prometheus di Cloud Monitoring
- Cloud Logging
- Cloud Trace
- Google Kubernetes Engine
- Cloud Build
- Artifact Registry
Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.
Prima di iniziare
Questa sezione descrive come configurare l'ambiente per il deployment e l'instrumentazione dell'app e poi eseguirla.
Seleziona o crea un Google Cloud progetto
Scegli un Google Cloud progetto per questa procedura dettagliata. Se non hai ancora un progetto Google Cloud , creane uno:
- 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 theresourcemanager.projects.createpermission. Learn how to grant roles.
-
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 theresourcemanager.projects.createpermission. Learn how to grant roles.
-
Verify that billing is enabled for your Google Cloud project.
Installare gli strumenti a riga di comando
Questo documento utilizza i seguenti strumenti a riga di comando:
gcloudkubectl
Gli strumenti gcloud e kubectl fanno parte di
Google Cloud CLI. Per informazioni sulla loro installazione, vedi
Gestione dei componenti di Google Cloud CLI. Per visualizzare i componenti di gcloud CLI installati, esegui questo comando:
gcloud components list
Imposta le variabili di ambiente
Per ridurre la digitazione di valori frequenti, evitare errori di digitazione e rendere eseguibili i comandi in questo documento, imposta le seguenti variabili di ambiente:
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
export CLUSTER_NAME=CLUSTER_NAME
export CLUSTER_REGION=us-east1
export ARTIFACT_REGISTRY=opentelemetry-autoinstrument-registry
export REGISTRY_LOCATION=us-east4
Prima di eseguire i comandi, sostituisci le seguenti variabili o utilizza i valori predefiniti:
- PROJECT_ID: l'identificatore del progetto.
- CLUSTER_NAME: il nome del cluster. Può fare riferimento a un cluster nuovo o esistente.
- us-east1: la regione del cluster. Se utilizzi un cluster esistente, utilizza la regione del cluster.
- opentelemetry-autoinstrument-registry: il nome del repository Artifact Registry. Può trattarsi di un repository nuovo o esistente.
- us-east4: la regione del repository Artifact Registry. Se utilizzi un repository esistente, utilizza la regione del repository.
Se riscontri errori durante l'esecuzione dei comandi in questo documento, verifica che queste variabili siano impostate correttamente nell'ambiente del terminale.
Abilita API
Per utilizzare i servizi descritti in questo documento, devi abilitare le seguenti API nel tuo progetto Google Cloud :
- API Artifact Registry:
artifactregistry.googleapis.com - API Cloud Build:
cloudbuild.googleapis.com - Google Kubernetes Engine:
container.googleapis.com - API Identity and Access Management:
iam.googleapis.com - API Cloud Logging:
logging.googleapis.com - API Cloud Monitoring:
monitoring.googleapis.com - API Telemetry:
telemetry.googleapis.com
Queste API, con la probabile eccezione dell'API Telemetry, potrebbero essere già abilitate nel tuo progetto Google Cloud . Esegui il comando seguente per elencare le API abilitate:
gcloud services list
Abilita le API che non sono ancora abilitate.
Presta particolare attenzione all'API Telemetry, telemetry.googleapis.com; questo documento
potrebbe essere la prima volta che incontri questa API.
Per abilitare le API che non sono ancora abilitate, esegui i comandi per le API corrispondenti:
gcloud services enable artifactregistry.googleapis.com
gcloud services enable cloudbuild.googleapis.com
gcloud services enable container.googleapis.com
gcloud services enable iam.googleapis.com
gcloud services enable logging.googleapis.com
gcloud services enable monitoring.googleapis.com
gcloud services enable telemetry.googleapis.com
Configura il cluster
Configura un cluster GKE per l'applicazione di esempio e il raccoglitore:
Accedi a Google Cloud eseguendo i seguenti comandi:
gcloud auth login gcloud config set project PROJECT_IDSe non hai ancora un cluster GKE, crea un cluster Autopilot eseguendo il seguente comando:
gcloud container clusters create-auto --region us-east1 CLUSTER_NAME --project PROJECT_IDPer interagire con il cluster, connetti l'utilità
kubectllocale eseguendo questo comando:gcloud container clusters get-credentials CLUSTER_NAME --region us-east1 --project PROJECT_ID
Esegui il deployment dell'applicazione Java
I passaggi descritti in questa sezione eseguono il deployment di un'applicazione Java di esempio non instrumentata, l'esempio di instrumentazione OpenTelemetry Spring Boot, sul tuo cluster. Questa sezione utilizza Cloud Build e Artifact Registry per creare e archiviare l'immagine dell'applicazione.
Se non hai ancora un repository Artifact Registry, creane uno eseguendo il seguente comando:
gcloud artifacts repositories create opentelemetry-autoinstrument-registry --repository-format=docker --location=us-east4 --description="GKE Autoinstrumentation sample app"Clona l'applicazione di esempio eseguendo questo comando:
git clone https://github.com/GoogleCloudPlatform/opentelemetry-operations-java.gitImposta le seguenti variabili di ambiente:
export GOOGLE_CLOUD_PROJECT=PROJECT_ID export ARTIFACT_REGISTRY=opentelemetry-autoinstrument-registry export REGISTRY_LOCATION=us-east4Crea l'immagine dell'applicazione ed esegui il push nel repository Artifact Registry eseguendo questi comandi:
pushd opentelemetry-operations-java/examples/instrumentation-quickstart && \ gcloud builds submit --config <(envsubst < cloudbuild-uninstrumented-app.yaml) . && \ popdCrea un file di configurazione del deployment Kubernetes per l'applicazione. Copia la seguente configurazione e salvala in un file denominato
deployment.yaml:apiVersion: v1 kind: Service metadata: name: quickstart-app labels: app: quickstart-app app.kubernetes.io/part-of: gke-autoinstrument-guide spec: ports: - port: 8080 targetPort: 8080 name: quickstart-app selector: app: quickstart-app --- apiVersion: apps/v1 kind: Deployment metadata: name: quickstart-app labels: app: quickstart-app app.kubernetes.io/part-of: gke-autoinstrument-guide spec: replicas: 2 selector: matchLabels: app: quickstart-app template: metadata: labels: app: quickstart-app spec: containers: - name: quickstart-app image: us-east4-docker.pkg.dev/PROJECT_ID/opentelemetry-autoinstrument-registry/java-quickstart:latest ports: - containerPort: 8080 name: quickstart-appCrea uno spazio dei nomi per la tua applicazione eseguendo questo comando:
kubectl create namespace APPLICATION_NAMESPACEApplica la configurazione del deployment al tuo cluster eseguendo il comando seguente:
kubectl apply -f deployment.yaml -n APPLICATION_NAMESPACEDopo aver creato il deployment, potrebbe essere necessario un po' di tempo prima che i pod vengano creati e inizino a essere eseguiti. Per controllare lo stato dei pod, esegui questo comando:
kubectl get po -n APPLICATION_NAMESPACE -wPer interrompere il monitoraggio dello stato del pod, premi Ctrl+C per interrompere il comando.
Configura un'istanza di OpenTelemetry Collector
In questa sezione, creerai un altro deployment che esegue un'istanza di Google-Built OpenTelemetry Collector nel tuo cluster GKE. L'agente di raccolta è configurato per esportare i dati utilizzando i seguenti esportatori:
- Metriche utilizzando l'esportatore HTTP OTLP
- Tracce utilizzando l'esportatore HTTP OTLP
- Log utilizzando Google Cloud Exporter
Anziché seguire i passaggi manuali descritti in questo documento per eseguire il deployment di OpenTelemetry Collector, puoi seguire la guida OpenTelemetry gestito per GKE, che utilizza Google-Built OpenTelemetry Collector in un ambiente gestito.
Autorizza il account di servizio Kubernetes per il deployment di OpenTelemetry Collector eseguendo questi comandi:
export PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)") gcloud projects add-iam-policy-binding projects/PROJECT_ID \ --role=roles/logging.logWriter \ --member=principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector \ --condition=None gcloud projects add-iam-policy-binding projects/PROJECT_ID \ --role=roles/monitoring.metricWriter \ --member=principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector \ --condition=None gcloud projects add-iam-policy-binding projects/PROJECT_ID \ --role=roles/telemetry.tracesWriter \ --member=principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector \ --condition=None
Esegui il deployment dell'istanza del raccoglitore OpenTelemetry integrato in Google sul cluster GKE con la configurazione predefinita consigliata eseguendo questo comando:
kubectl kustomize https://github.com/GoogleCloudPlatform/otlp-k8s-ingest//k8s/base?ref=otlpmetric | envsubst | kubectl apply -f -Questa configurazione esegue il deployment del raccoglitore nello spazio dei nomi
opentelemetry.Dopo aver creato il deployment, potrebbe essere necessario un po' di tempo prima che i pod vengano creati e inizino a essere eseguiti. Per controllare lo stato dei pod, esegui questo comando:
kubectl get po -n opentelemetry -wPer interrompere il monitoraggio dello stato del pod, premi Ctrl+C per interrompere il comando.
Configurare l'instrumentazione zero-code di OpenTelemetry
Per configurare la strumentazione zero-code di OpenTelemetry per un'applicazione di cui è stato eseguito il deployment su GKE, installa l'operatore OpenTelemetry sul tuo cluster GKE. L'operatore OpenTelemetry fornisce l'accesso a una definizione di risorsa personalizzata (CRD) di Kubernetes, la risorsa di strumentazione, che viene utilizzata per inserire la strumentazione automatica nelle risorse Kubernetes in esecuzione all'interno di un cluster.
La risorsa di strumentazione viene "inserita" o "applicata" a workload specifici utilizzando annotazioni speciali. L'operatore OpenTelemetry osserva queste annotazioni sulle risorse in esecuzione all'interno del cluster e inserisce la strumentazione appropriata nelle applicazioni gestite da queste risorse.
Se non hai ancora installato l'interfaccia a riga di comando Helm, installa Helm eseguendo i seguenti comandi:
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 chmod 700 get_helm.sh ./get_helm.shSe non hai ancora installato
cert-managersul cluster, installalo eseguendo i seguenti comandi:helm repo add jetstack https://charts.jetstack.io helm repo update helm install \ --create-namespace \ --namespace cert-manager \ --set installCRDs=true \ --set global.leaderElection.namespace=cert-manager \ --set extraArgs={--issuer-ambient-credentials=true} \ cert-manager jetstack/cert-managerInstalla l'operatore OpenTelemetry eseguendo questo comando e utilizzando la versione 0.140.0 o successive:
kubectl apply -f https://github.com/open-telemetry/opentelemetry-operator/releases/download/v0.140.0/opentelemetry-operator.yamlCrea un file di configurazione per la risorsa personalizzata di strumentazione creando un file denominato
instrumentation.yamlcon il seguente contenuto:apiVersion: opentelemetry.io/v1alpha1 kind: Instrumentation metadata: name: sample-java-auto-instrumentation spec: exporter: endpoint: http://opentelemetry-collector.opentelemetry.svc.cluster.local:4317 sampler: type: parentbased_traceidratio # Adjust the sampling rate to control cost argument: "0.01" java: env: - name: OTEL_EXPORTER_OTLP_PROTOCOL value: grpc - name: OTEL_LOGS_EXPORTER value: noneCrea uno spazio dei nomi per l'operatore. Puoi utilizzare lo stesso valore che hai utilizzato per lo spazio dei nomi dell'applicazione, APPLICATION_NAMESPACE.
kubectl create namespace INSTRUMENTATION_NAMESPACECrea la risorsa personalizzata Instrumentation nel cluster e applica il file
instrumentation.yamleseguendo il seguente comando:kubectl apply -f instrumentation.yaml -n INSTRUMENTATION_NAMESPACEApplica l'annotazione di strumentazione automatica all'applicazione Java di esempio di cui è stato eseguito il deployment in precedenza. Applica la patch al deployment originale con l'annotazione eseguendo questo comando:
kubectl patch deployment.apps/quickstart-app -n APPLICATION_NAMESPACE -p '{"spec":{"template":{"metadata":{"annotations":{"instrumentation.opentelemetry.io/inject-java": "'"INSTRUMENTATION_NAMESPACE"'/sample-java-auto-instrumentation"}}}}}'Dopo aver applicato la patch al deployment, che causa il riavvio del deployment dell'applicazione, puoi controllare lo stato dei pod nell'applicazione eseguendo il comando seguente:
kubectl get po -n APPLICATION_NAMESPACE -wPer interrompere il monitoraggio dello stato del pod, premi Ctrl+C per interrompere il comando.
Ora l'applicazione Java di cui è stato eseguito il deployment nel cluster GKE è strumentata automaticamente.
Genera dati di telemetria dall'applicazione di cui è stato eseguito il deployment
Per generare dati di telemetria dall'applicazione strumentata automaticamente, devi inviare richieste all'applicazione per simulare l'attività utentel'utente. Puoi generare un flusso costante di traffico eseguendo un simulatore di traffico. Questa sezione descrive come scaricare il simulatore, crearlo utilizzando Cloud Build, archiviare l'immagine in Artifact Registry ed eseguire il deployment del simulatore:
Scarica l'applicazione di simulazione del traffico eseguendo questi comandi:
mkdir traffic-simulator && pushd traffic-simulator && \ curl -O https://raw.githubusercontent.com/GoogleCloudPlatform/opentelemetry-operator-sample/refs/heads/main/recipes/self-managed-otlp-ingest/traffic/hey.Dockerfile && \ curl -O https://raw.githubusercontent.com/GoogleCloudPlatform/opentelemetry-operator-sample/refs/heads/main/recipes/self-managed-otlp-ingest/traffic/cloudbuild-hey.yaml && \ popdI comandi precedenti eseguono le seguenti operazioni:
- Crea una directory separata per la creazione di un'applicazione di simulazione del traffico.
- Scarica il Dockerfile per l'applicazione.
- Scarica la configurazione di Cloud Build per creare l'immagine dell'applicazione.
Crea l'immagine dell'applicazione con Cloud Build e trasferiscila ad Artifact Registry eseguendo i seguenti comandi:
pushd traffic-simulator && \ gcloud builds submit --config <(envsubst < cloudbuild-hey.yaml) . && \ popdCrea un file di configurazione della distribuzione per il simulatore copiando il seguente contenuto in un file nella directory
traffic-simulatordenominatoquickstart-traffic.yaml:apiVersion: apps/v1 kind: Deployment metadata: name: traffic-simulator labels: app.kubernetes.io/part-of: gke-autoinstrument-guide spec: replicas: 1 selector: matchLabels: app: traffic-simulator template: metadata: labels: app: traffic-simulator spec: containers: - name: traffic-simulator image: us-east4-docker.pkg.dev/PROJECT_ID/opentelemetry-autoinstrument-registry/hey:latest args: - -c=2 - -q=1 - -z=1h - http://quickstart-app:8080/multiEsegui il deployment del simulatore di traffico eseguendo questi comandi:
pushd traffic-simulator && \ kubectl apply -f quickstart-traffic.yaml -n APPLICATION_NAMESPACE && \ popdDopo aver creato il deployment, potrebbe essere necessario un po' di tempo prima che i pod vengano creati e inizino a essere eseguiti. Per controllare lo stato dei pod, esegui questo comando:
kubectl get po -n APPLICATION_NAMESPACE -wPer interrompere il monitoraggio dello stato del pod, premi Ctrl+C per interrompere il comando.
Visualizzare la telemetria
Dopo che il simulatore di traffico inizia a inviare richieste all'applicazione, l'applicazione Java di cui è stato eseguito il deployment genera dati di telemetria. Potrebbero essere necessari alcuni minuti prima che le metriche e le tracce inizino a essere visualizzate in Google Cloud.
L'instrumentazione inserita dall'operatore OpenTelemetry si basa sull'agente Java OpenTelemetry. L'agente Java OpenTelemetry contiene strumentazione integrata per molte librerie e framework Java che emettono metriche.
Lo strumento di monitoraggio inserito acquisisce automaticamente anche le tracce per tutte le chiamate effettuate a qualsiasi endpoint esposto dall'applicazione di esempio. Il simulatore di traffico invia costantemente richieste all'endpoint
/multiesposto dall'applicazione Java a una velocità fissa. L'endpoint/multia sua volta invia richieste all'endpoint/singleper generare la risposta finale. Queste interazioni vengono visualizzate come tracce che possono essere visualizzate utilizzando Esplora tracce.
Visualizza metriche
Puoi visualizzare le metriche strumentate automaticamente in Metrics Explorer di Cloud Monitoring. Questa sezione include query di esempio scritte in PromQL.
Nella console Google Cloud , vai alla pagina leaderboard Esplora metriche:
Se utilizzi la barra di ricerca per trovare questa pagina, seleziona il risultato con il sottotitolo Monitoring.
Alcune delle metriche che puoi visualizzare per l'applicazione di esempio includono quanto segue:
Metriche di runtime JVM: l'agente Java OpenTelemetry genera metriche sulla JVM sottostante. Queste metriche espongono informazioni su memoria JVM, garbage collection, classi, thread e altri concetti correlati. Per un elenco completo delle metriche JVM supportate, consulta la pagina Convenzioni semantiche delle metriche di runtime JVM.
Utilizzo della memoria JVM: incolla la seguente query PromQL in Metrics Explorer:
sum(avg_over_time({"process.runtime.jvm.memory.usage"}[${__interval}]))Utilizzo CPU JVM: incolla la seguente query PromQL in Metrics Explorer:
sum(avg_over_time({"process.runtime.jvm.cpu.utilization"}[${__interval}]))Il seguente grafico mostra la metrica di utilizzo della CPU JVM:
Metriche Spring Boot: l'applicazione di esempio utilizza il framework Spring Boot, supportato anche dalla strumentazione zero-code OpenTelemetry per Java.
Durata media del client HTTP: incolla la seguente query PromQL in Metrics Explorer:
sum(rate({"http.client.duration_sum"}[${__interval}])) by (cluster, job) / sum(rate({"http.client.duration_count"}[${__interval}])) by (cluster, job)Durata media del server HTTP: incolla la seguente query PromQL in Metrics Explorer:
sum(rate({"http.server.duration_sum"}[${__interval}])) by (cluster, job) / sum(rate({"http.server.duration_count"}[${__interval}])) by (cluster, job)Il seguente grafico mostra la metrica Durata media server HTTP di Spring Boot:
Per ulteriori informazioni sull'utilizzo di Metrics Explorer, consulta Selezionare le metriche durante l'utilizzo di Esplora metriche.
Visualizza tracce
Puoi visualizzare le tracce strumentate automaticamente in Esplora tracce di Cloud Trace. Puoi filtrare queste tracce in Esplora tracce filtrando in base a "Nome servizio" e impostando il nome del servizio su quickstart-app.
Nella console Google Cloud , vai alla pagina
Esplora tracce:
Puoi trovare questa pagina anche utilizzando la barra di ricerca.
Il seguente screenshot mostra le tracce generate dal deployment di OpenTelemetry
quickstart-app:
Per saperne di più sull'utilizzo di Esplora tracce, vedi Trovare ed esplorare le tracce.
Esegui la pulizia
Se hai creato un nuovo progetto Google Cloud e non ti serve più, puoi eliminarlo eseguendo questo comando:
gcloud projects delete PROJECT_ID
Se hai utilizzato un progetto esistente, puoi eliminare le risorse che hai creato nell'ambito di questa procedura dettagliata per risparmiare sui costi:
Elimina il cluster GKE eseguendo questo comando:
gcloud container clusters delete CLUSTER_NAME --location=us-east1Elimina il repository Artifact Registry eseguendo questo comando:
gcloud artifacts repositories delete opentelemetry-autoinstrument-registry --location=us-east4