Tutorial: debug di un servizio Cloud Run utilizzando Eventarc

Questo tutorial ti insegna come risolvere gli errori di runtime riscontrati durante il deployment degli eventi da Cloud Storage utilizzando Cloud Audit Logs in un servizio Cloud Run non autenticato.

Obiettivi

  • Creare un bucket Cloud Storage da utilizzare come origine dell'evento.
  • Crea, carica ed esegui il deployment di un'immagine container in Cloud Run.
  • Crea trigger Eventarc.
  • Caricare un file nel bucket Cloud Storage.
  • Correggere e correggere gli errori di runtime.

Costi

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

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

Segui i prerequisiti riportati in Ricevere un evento Cloud Audit Logs.

Crea un bucket Cloud Storage

Crea due bucket di archiviazione in due regioni come origine evento per il servizio Cloud Run:

us-east1

export BUCKET1="troubleshoot-bucket1-PROJECT_ID"
gsutil mb -l us-east1 gs://${BUCKET1}

us-west1

export BUCKET2="troubleshoot-bucket2-$PROJECT_ID"
gsutil mb -l us-west1 gs://${BUCKET2}

Dopo aver creato l'origine evento, esegui il deployment del servizio di ricezione di eventi su Cloud Run.

Recupera l'esempio di codice

Clona il repository:

Go

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

Java

git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
cd java-docs-samples/eventarc/audit-storage

.NET

git clone https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git
cd dotnet-docs-samples/eventarc/audit-storage

Node.js

git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git
cd nodejs-docs-samples/eventarc/audit-storage

Python

git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
cd python-docs-samples/eventarc/audit-storage

Rivedi il codice

Il codice di questo tutorial è costituito da:

  • Un gestore di eventi che riceve l'evento in entrata come CloudEvent all'interno della richiesta HTTP POST:

    Go

    eventarc/audit_storage/main.go 
    
// Processes CloudEvents containing Cloud Audit Logs for Cloud Storage
package main

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

	cloudevent "github.com/cloudevents/sdk-go/v2"
)

// HelloEventsStorage receives and processes a Cloud Audit Log event with Cloud Storage data.
func HelloEventsStorage(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "Expected HTTP POST request with CloudEvent payload", http.StatusMethodNotAllowed)
		return
	}

	event, err := cloudevent.NewEventFromHTTPRequest(r)
	if err != nil {
		log.Printf("cloudevent.NewEventFromHTTPRequest: %v", err)
		http.Error(w, "Failed to create CloudEvent from request.", http.StatusBadRequest)
		return
	}
	s := fmt.Sprintf("Detected change in Cloud Storage bucket: %s", event.Subject())
	fmt.Fprintln(w, s)
}

    Java

    eventarc/audit-storage/src/main/java/com/example/cloudrun/EventController.java 
    import io.cloudevents.CloudEvent;
import io.cloudevents.rw.CloudEventRWException;
import io.cloudevents.spring.http.CloudEventHttpUtils;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class EventController {

  @RequestMapping(value = "/", method = RequestMethod.POST, consumes = "application/json")
  public ResponseEntity<String> receiveMessage(
      @RequestBody String body, @RequestHeader HttpHeaders headers) {
    CloudEvent event;
    try {
      event =
          CloudEventHttpUtils.fromHttp(headers)
              .withData(headers.getContentType().toString(), body.getBytes())
              .build();
    } catch (CloudEventRWException e) {
      return new ResponseEntity<>(e.getMessage(), HttpStatus.BAD_REQUEST);
    }

    String ceSubject = event.getSubject();
    String msg = "Detected change in Cloud Storage bucket: " + ceSubject;
    System.out.println(msg);
    return new ResponseEntity<>(msg, HttpStatus.OK);
  }
}

    .NET

    eventarc/audit-storage/Startup.cs 
    
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILogger<Startup> logger)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        logger.LogInformation("Service is starting...");

        app.UseRouting();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapPost("/", async context =>
            {
                logger.LogInformation("Handling HTTP POST");

                var ceSubject = context.Request.Headers["ce-subject"];
                logger.LogInformation($"ce-subject: {ceSubject}");

                if (string.IsNullOrEmpty(ceSubject))
                {
                    context.Response.StatusCode = 400;
                    await context.Response.WriteAsync("Bad Request: expected header Ce-Subject");
                    return;
                }

                await context.Response.WriteAsync($"GCS CloudEvent type: {ceSubject}");
            });
        });
    }
}

    Node.js

    eventarc/audit-storage/app.js 
    const express = require('express');
const app = express();

app.use(express.json());
app.post('/', (req, res) => {
  if (!req.header('ce-subject')) {
    return res
      .status(400)
      .send('Bad Request: missing required header: ce-subject');
  }

  console.log(
    `Detected change in Cloud Storage bucket: ${req.header('ce-subject')}`
  );
  return res
    .status(200)
    .send(
      `Detected change in Cloud Storage bucket: ${req.header('ce-subject')}`
    );
});

module.exports = app;

    Python

    eventarc/audit-storage/main.py 
    @app.route("/", methods=["POST"])
def index():
    # Create a CloudEvent object from the incoming request
    event = from_http(request.headers, request.data)
    # Gets the GCS bucket name from the CloudEvent
    # Example: "storage.googleapis.com/projects/_/buckets/my-bucket"
    bucket = event.get("subject")

    print(f"Detected change in Cloud Storage bucket: {bucket}")
    return (f"Detected change in Cloud Storage bucket: {bucket}", 200)

  • Un server che utilizza il gestore riportato sopra:

    Go

    eventarc/audit_storage/main.go 
    
func main() {
	http.HandleFunc("/", HelloEventsStorage)
	// Determine port for HTTP service.
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}
	// Start HTTP server.
	log.Printf("Listening on port %s", port)
	if err := http.ListenAndServe(":"+port, nil); err != nil {
		log.Fatal(err)
	}
}

    Java

    eventarc/audit-storage/src/main/java/com/example/cloudrun/Application.java 
    
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}

    .NET

    eventarc/audit-storage/Program.cs 
        public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }
    public static IHostBuilder CreateHostBuilder(string[] args)
    {
        var port = Environment.GetEnvironmentVariable("PORT") ?? "8080";
        var url = $"http://0.0.0.0:{port}";

        return Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>().UseUrls(url);
            });
    }

    Node.js

    eventarc/audit-storage/index.js 
    const app = require('./app.js');
const PORT = parseInt(process.env.PORT) || 8080;

app.listen(PORT, () =>
  console.log(`nodejs-events-storage listening on port ${PORT}`)
);

    Python

    eventarc/audit-storage/main.py 
    import os

from cloudevents.http import from_http

from flask import Flask, request

app = Flask(__name__)
if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))

  • Un Dockerfile che definisce l'ambiente operativo del servizio. I contenuti del Dockerfile variano in base alla lingua:

    Go

    eventarc/audit_storage/Dockerfile 
    
# Use the offical golang image to create a binary.
# This is based on Debian and sets the GOPATH to /go.
# https://hub.docker.com/_/golang
FROM golang:1.17-buster as builder

# Create and change to the app directory.
WORKDIR /app

# Retrieve application dependencies.
# This allows the container build to reuse cached dependencies.
# Expecting to copy go.mod and if present go.sum.
COPY go.* ./
RUN go mod download

# Copy local code to the container image.
COPY . ./

# Build the binary.
RUN go build -v -o server

# Use the official Debian slim image for a lean production container.
# https://hub.docker.com/_/debian
# https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
FROM debian:buster-slim
RUN set -x && apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
    ca-certificates && \
    rm -rf /var/lib/apt/lists/*

# Copy the binary to the production image from the builder stage.
COPY --from=builder /app/server /server

# Run the web service on container startup.
CMD ["/server"]

    Java

    eventarc/audit-storage/Dockerfile 
    
# Use the official maven image to create a build artifact.
# https://hub.docker.com/_/maven
FROM maven:3-eclipse-temurin-17-alpine as builder

# Copy local code to the container image.
WORKDIR /app
COPY pom.xml .
COPY src ./src

# Build a release artifact.
RUN mvn package -DskipTests

# Use Eclipse Temurin for base image.
# https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
FROM eclipse-temurin:17.0.9_9-jre-alpine

# Copy the jar to the production image from the builder stage.
COPY --from=builder /app/target/audit-storage-*.jar /audit-storage.jar

# Run the web service on container startup.
CMD ["java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/audit-storage.jar"]

    .NET

    eventarc/audit-storage/Dockerfile 
    
# Use Microsoft's official build .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-sdk/
FROM mcr.microsoft.com/dotnet/core/sdk:3.1-alpine AS build
WORKDIR /app

# Install production dependencies.
# Copy csproj and restore as distinct layers.
COPY *.csproj ./
RUN dotnet restore

# Copy local code to the container image.
COPY . ./
WORKDIR /app

# Build a release artifact.
RUN dotnet publish -c Release -o out

# Use Microsoft's official runtime .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-aspnet/
FROM mcr.microsoft.com/dotnet/core/aspnet:3.1-alpine AS runtime
WORKDIR /app
COPY --from=build /app/out ./

# Run the web service on container startup.
ENTRYPOINT ["dotnet", "AuditStorage.dll"]

    Node.js

    eventarc/audit-storage/Dockerfile 
    
# Use the official lightweight Node.js image.
# https://hub.docker.com/_/node
FROM node:18-slim

# Create and change to the app directory.
WORKDIR /usr/src/app

# Copy application dependency manifests to the container image.
# A wildcard is used to ensure both package.json AND package-lock.json are copied.
# Copying this separately prevents re-running npm install on every code change.
COPY package*.json ./

# Install dependencies.
# If you add a package-lock.json speed your build by switching to 'npm ci'.
# RUN npm ci --only=production
RUN npm install --production

# Copy local code to the container image.
COPY . .

# Run the web service on container startup.
CMD [ "npm", "start" ]

    Python

    eventarc/audit-storage/Dockerfile 
    
# Use the official Python image.
# https://hub.docker.com/_/python
FROM python:3.11-slim

# Allow statements and log messages to immediately appear in the Cloud Run logs
ENV PYTHONUNBUFFERED True

# Copy application dependency manifests to the container image.
# Copying this separately prevents re-running pip install on every code change.
COPY requirements.txt ./

# Install production dependencies.
RUN pip install -r requirements.txt

# Copy local code to the container image.
ENV APP_HOME /app
WORKDIR $APP_HOME
COPY . ./

# Run the web service on container startup.
# Use gunicorn webserver with one worker process and 8 threads.
# For environments with multiple CPU cores, increase the number of workers
# to be equal to the cores available.
CMD exec gunicorn --bind :$PORT --workers 1 --threads 8 --timeout 0 main:app

Spedisci il codice

Per spedire il codice:

  1. Crea la tua immagine container con Cloud Build e caricala in Container Registry:

    Go

     gcloud builds submit --tag gcr.io/PROJECT_ID/audit-storage

    Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.

    In caso di esito positivo, viene visualizzato un messaggio di SUCCESSO con l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Container Registry e può essere riutilizzata, se vuoi.

    Java

    1. Utilizza l'helper delle credenziali gcloud per autorizzare Docker a eseguire il push del container in Container Registry. 
      gcloud auth configure-docker

    2. Utilizza il plug-in Jib Maven per creare il container ed eseguirne il push in Container Registry. 

      mvn compile jib:build -Dimage=gcr.io/PROJECT_ID/audit-storage

      Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.

      audit-storage è il nome del contenitore. In caso di esito positivo, viene visualizzato un messaggio di SUCCESSO. L'immagine è archiviata in Container Registry e, se vuoi, può essere riutilizzata.

    .NET

     gcloud builds submit --tag gcr.io/PROJECT_ID/audit-storage

    Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.

    In caso di esito positivo, viene visualizzato un messaggio di SUCCESSO con l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Container Registry e può essere riutilizzata, se vuoi.

    Node.js

     gcloud builds submit --tag gcr.io/PROJECT_ID/audit-storage

    Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.

    In caso di esito positivo, viene visualizzato un messaggio di SUCCESSO con l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Container Registry e può essere riutilizzata, se vuoi.

    Python

     gcloud builds submit --tag gcr.io/PROJECT_ID/audit-storage

    Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.

    In caso di esito positivo, viene visualizzato un messaggio di SUCCESSO con l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Container Registry e può essere riutilizzata, se vuoi.

  2. Esegui il deployment dell'immagine container in Cloud Run:

    gcloud run deploy troubleshoot-service --image gcr.io/PROJECT_ID/audit-storage \
  --allow-unauthenticated

    Sostituisci PROJECT_ID con l'ID progetto.
    audit-storage è il nome del container e troubleshoot-service è il nome del servizio Cloud Run.

    Tieni presente che è stato eseguito il deployment dell'immagine container nel servizio e nella regione che hai configurato in precedenza durante la configurazione di gcloud.

  3. Quando esegui il deployment in Cloud Run, rispondi y, "Yes", alla richiesta di consentire gli utenti non autenticati. Per ulteriori dettagli sull'autenticazione basata su IAM, consulta Ruoli e autorizzazioni Eventarc.

    Una volta eseguito il deployment, la riga di comando mostra l'URL del servizio.

Crea un trigger

Ora che hai eseguito il deployment di un servizio Cloud Run, configura un trigger per ascoltare gli eventi da Cloud Storage tramite audit log.

  1. Crea un trigger di audit log per rimanere in ascolto degli eventi di Cloud Storage:

    gcloud eventarc triggers create troubleshoot-trigger \
  --destination-run-service=troubleshoot-service \
  --event-filters="type=google.cloud.audit.log.v1.written" \
  --event-filters="serviceName=storage.googleapis.com" \
  --event-filters="methodName=storage.objects.create" \
  --service-account=PROJECT_NUMBER-compute@developer.gserviceaccount.com

    Viene creato un trigger denominato troubleshoot-trigger.

  2. Per confermare la creazione di troubleshoot-trigger, esegui questo comando:

    gcloud eventarc triggers list

    Il valore troubleshoot-trigger viene visualizzato nell'elenco con un target troubleshoot-service.

Generare e visualizzare un evento

Per verificare di aver eseguito correttamente il deployment del servizio e di poter ricevere eventi da Cloud Storage:

  1. Crea e carica un file nel primo bucket di archiviazione:

     echo "Hello World" > random.txt
 gsutil cp random.txt gs://${BUCKET1}/random.txt

  2. Monitora i log per verificare se il servizio ha ricevuto un evento. I log del servizio mostrano che il servizio è in ascolto di eventi, indicando un problema di configurazione:

    Now listening on: http://0.0.0.0:8080

Esaminare il problema

Ora puoi esaminare il motivo per cui il servizio non riceve eventi.

Audit log

In questo tutorial, gli eventi di Cloud Storage vengono emessi tramite audit log e inviati a Cloud Run. Verificare se gli audit log sono abilitati per Cloud Storage.

  1. Nella console Google Cloud, vai alla pagina Audit log e seleziona la casella di controllo Google Cloud Storage.

    Vai agli audit log

  2. Assicurati che i tipi di log Lettura amministratore, Lettura dati e Scrittura dati di Cloud Audit Logs siano selezionati.

Dopo aver abilitato Cloud Audit Logs, carica di nuovo il file e controlla i log. Il servizio continua a non ricevere eventi e questo potrebbe essere correlato alla località dell'attivatore.

Località attivatore

Potrebbero esserci più risorse in località diverse ed è necessario filtrare gli eventi da origini che si trovano nella stessa regione del target di Cloud Run. Per saperne di più, consulta le località supportate da Eventarc.

In questo tutorial hai eseguito il deployment del servizio Cloud Run in us-central1. Hai anche creato un trigger nella stessa località perché il criterio eventarc/location era impostato su us-central1.

Per elencare la posizione dell'attivatore, descrivilo:

gcloud eventarc triggers describe troubleshoot-trigger

Tuttavia, hai creato due bucket nelle località us-east1 e us-west1. Per ricevere eventi da queste località, devi creare attivatori in quelle località. Creiamo un attivatore in us-east1.

  1. Elimina l'attivatore esistente nella posizione us-central1:

    gcloud eventarc triggers delete troubleshoot-trigger

  2. Imposta la località e la regione su us-east1:

    gcloud config set eventarc/location us-east1
gcloud config set run/region us-east1

  3. Invia nuovamente il codice.

  4. Crea un nuovo attivatore nella località us-east1:

     gcloud eventarc triggers create troubleshoot-trigger \
   --destination-run-service=troubleshoot-service \
   --event-filters="type=google.cloud.audit.log.v1.written" \
   --event-filters="serviceName=storage.googleapis.com" \
   --event-filters="methodName=storage.objects.create" \
   --service-account=PROJECT_NUMBER-compute@developer.gserviceaccount.com

  5. Verifica che l'attivatore sia stato creato:

    gcloud eventarc triggers list

L'inizializzazione di un trigger può richiedere fino a due minuti prima di iniziare a pubblicare eventi.

Tempo di inizializzazione

Una volta creati i trigger, sono necessari fino a due minuti di tempo di inizializzazione prima che gli eventi inizino a scorrere. Esegui questo comando per confermare che i trigger sono attivi:

gcloud eventarc triggers list

Viene visualizzato un output simile che indica lo stato dell'attivatore:

NAME                   TYPE                               DESTINATION_RUN_SERVICE  DESTINATION_RUN_PATH  ACTIVE
troubleshoot-trigger3  google.cloud.audit.log.v1.written  troubleshoot-service2                          By 14:16:56
troubleshoot-trigger   google.cloud.audit.log.v1.written  troubleshoot-service                           Yes

Dopo 10 minuti, carica di nuovo un file in ciascun bucket. Gli eventi per ogni file vengono scritti nei log del servizio Cloud Run. Se il servizio non riceve eventi, il problema potrebbe essere legato alle dimensioni degli eventi.

Dimensione dell'evento

Gli eventi inviati non devono superare i limiti di dimensione degli eventi (512 kB).

Un trigger che gli eventi pubblicati in precedenza hanno smesso di funzionare

  1. Verifica che l'origine stia generando eventi. Controlla gli audit log di Cloud e assicurati che il servizio monitorato stia emettendo log. Se i log vengono registrati, ma gli eventi non vengono recapitati, contatta l'assistenza.

  2. Verifica che esista un argomento Pub/Sub con lo stesso nome del trigger.

    1. Per elencare i trigger, vedi gcloud eventarc trigger list.

    2. Per elencare gli argomenti Pub/Sub, esegui:

      gcloud pubsub topics list

    Verifica che il nome dell'argomento Pub/Sub includa il nome del trigger creato. Se l'argomento Pub/Sub non è presente, crea un argomento quando crei il trigger per un provider, un tipo di evento e una destinazione Cloud Run specifici.

  3. Verifica l'integrità dell'argomento Pub/Sub:

    1. Assicurati che sia presente un segno di spunta nella scheda Trigger: nella console Cloud, vai a Cloud Run, seleziona il servizio che hai creato e vai alla scheda Trigger.

    2. Nella console Google Cloud, vai alla pagina Argomenti e fai clic sull'argomento Pub/Sub.

      Vai ad Argomenti

    3. Monitora se i messaggi vengono pubblicati nell'argomento con la metrica: topic/send_message_operation_count. Se i messaggi non vengono pubblicati nell'argomento, controlla gli audit log di Cloud e assicurati che il servizio monitorato stia emettendo log. Se i log vengono registrati, ma gli eventi non vengono recapitati, contatta l'assistenza.

      Metrica relativa all'argomento

    4. Monitora se il push dei messaggi a Cloud Run viene eseguito correttamente con la metrica subscription/push_request_count da response_code.

      1. Nella console Google Cloud, vai alla pagina Panoramica di Cloud Monitoring.

        Vai a Panoramica

      2. Aggiungi il progetto a una nuova area di lavoro.

      3. Fai clic su Dashboard e seleziona la dashboard Cloud Pub/Sub.

      4. Nella dashboard Cloud Pub/Sub, fai clic sull'argomento Pub/Sub che hai creato.

      5. Nella sezione Incidenti, fai clic su Crea criterio.

      6. Nella pagina Crea criterio di avviso, fai clic su Aggiungi condizione.

      7. Nella scheda Metrica, specifica le seguenti condizioni:

        • Sottoscrizione Cloud Pub/Sub come Tipo di risorsa.
        • Richieste push come Metrica.
        • response_code come Raggruppa per.
        • 0 come Soglia di configurazione. Metrica relativa agli abbonamenti Per ulteriori informazioni sulle metriche di utilizzo per Pub/Sub, consulta il monitoraggio delle sottoscrizioni push.

      8. Fai clic su Aggiungi per andare alla pagina Crea criterio di avviso.

      9. Nella sezione Quali sono i passaggi per risolvere il problema?, fornisci un nome per l'avviso, ad esempio samplealert, e fai clic su Salva.

      10. Per visualizzare l'avviso, vai a Monitoring > Dashboard > Cloud Pub/Sub. Fai clic sull'argomento Pub/Sub e poi sulla scheda Subscription (Sottoscrizione).

      Se vengono segnalati errori di push, controlla i log del servizio Cloud Run. Se l'endpoint ricevente restituisce un codice di stato non OK, significa che il codice Cloud Run non funziona come previsto e che devi contattare l'assistenza.

Esegui la pulizia

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

Elimina il progetto

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

Per eliminare il progetto:

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

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto 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 risorse tutorial

  1. Elimina il servizio Cloud Run di cui hai eseguito il deployment in questo tutorial:

    gcloud run services delete SERVICE_NAME

    Dove SERVICE_NAME è il nome del servizio che hai scelto.

    Puoi anche eliminare i servizi Cloud Run dalla console Google Cloud.

  2. Rimuovi tutte le configurazioni predefinite dell'interfaccia a riga di comando gcloud aggiunte durante la configurazione del tutorial.

    Ad esempio:

    gcloud config unset run/region

    o

    gcloud config unset project

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

    • Elimina il trigger Eventarc: 
      gcloud eventarc triggers delete TRIGGER_NAME
      Sostituisci TRIGGER_NAME con il nome del tuo attivatore.

    • Elimina l'immagine container denominata gcr.io/PROJECT_ID/audit-storage da Container Registry. Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.

Passaggi successivi

  • Per risolvere altri problemi che potresti riscontrare quando utilizzi Eventarc, vedi Risolvere i problemi.