Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui il deployment della scansione automatica del malware per i file caricati su Cloud Storage

Last reviewed 2023-06-20 UTC

Questo documento descrive come eseguire il deployment dell'architettura in Automatizza la scansione di malware per i file caricati su Cloud Storage.

Questa guida all'implementazione presuppone che tu abbia familiarità con le funzionalità di base delle seguenti tecnologie:

Architettura

Il seguente diagramma mostra l'architettura di deployment creata in documento:

Architettura della pipeline di scansione del malware.

Il diagramma mostra le due seguenti pipeline gestite da questo dell'architettura:

Pipeline di analisi dei file, che controlla se un file caricato contiene malware.
Pipeline di aggiornamento del mirror del database del malware ClamAV, che mantiene una speculare del database del malware utilizzato da ClamAV.

Per ulteriori informazioni sull'architettura, vedi Automatizza la scansione di malware per i file caricati su Cloud Storage.

Obiettivi

Crea un mirroring del database delle definizioni di malware ClamAV in un nel bucket Cloud Storage.
Crea un servizio Cloud Run con le funzioni seguenti:
- Analizzare i file in un bucket Cloud Storage alla ricerca di malware utilizzando ClamAV e spostamento dei file analizzati nei bucket puliti o messi in quarantena in base a il risultato della scansione.
- Mantenere uno specchio del database delle definizioni di malware ClamAV nella di archiviazione ideale in Cloud Storage.
Crea un trigger Eventarc per attivare la scansione del malware quando un file viene caricato su Cloud Storage.
Crea un job Cloud Scheduler per attivare la scansione del malware di aggiornamento del database delle definizioni di malware di archiviazione ideale in Cloud Storage.

Costi

Questa architettura utilizza i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza Calcolatore prezzi.

Prima di iniziare

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

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

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Abilita le API Artifact Registry, Cloud Run, Eventarc, Logging, Cloud Scheduler, Pub/Sub, and Cloud Build.
Abilita le API

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Configura l'ambiente

In questa sezione, assegni le impostazioni per i valori che vengono utilizzati durante il deployment, ad esempio region and zone. In questo deployment, utilizzerai us-central1 come regione per servizio Cloud Run e us come località Trigger Eventarc e bucket Cloud Storage.

In Cloud Shell, imposta variabili shell comuni, tra cui regione e località:

REGION=us-central1
LOCATION=us
PROJECT_ID=PROJECT_ID
SERVICE_NAME="malware-scanner"
SERVICE_ACCOUNT="${SERVICE_NAME}@${PROJECT_ID}.iam.gserviceaccount.com"

Sostituisci PROJECT_ID con l'ID progetto.

Inizializza l'ambiente gcloud con il tuo ID progetto:
```
gcloud config set project "${PROJECT_ID}"
```
Crea tre bucket Cloud Storage con nomi univoci:
```
gcloud storage buckets create "gs://unscanned-${PROJECT_ID}" --location="${LOCATION}"
gcloud storage buckets create "gs://quarantined-${PROJECT_ID}" --location="${LOCATION}"
gcloud storage buckets create "gs://clean-${PROJECT_ID}" --location="${LOCATION}"
```
${PROJECT_ID} viene utilizzato per assicurarsi che i nomi dei bucket siano univoci.

Questi tre bucket contengono i file caricati in varie fasi durante pipeline di scansione dei file:
- unscanned-PROJECT_ID: archiviazioni a fini legali prima della scansione. Caricamento degli utenti i propri file in questo bucket.
- quarantined-PROJECT_ID: archiviazioni a fini legali che il servizio di scansione di malware ha scansionato e ritenuto contenere malware.
- clean-PROJECT_ID: conserva i file che il servizio di scansione di malware ha analizzato e che risulta essere non infetto.
Crea un quarto bucket Cloud Storage:
```
gcloud storage buckets create "gs://cvd-mirror-${PROJECT_ID}" --location="${LOCATION}"
```
${PROJECT_ID} viene utilizzato per assicurarsi che il nome del bucket sia univoco.

Questo bucket cvd-mirror-PROJECT_ID viene usato per mantenere un mirroring locale del database delle definizioni di malware, che impedisce che la limitazione di frequenza venga attivata dalla CDN ClamAV.

Configurare un account di servizio per il servizio di scansione di malware

In questa sezione, creerai un account di servizio da utilizzare per lo scanner di malware. completamente gestito di Google Cloud. Quindi concedi i ruoli appropriati all'account di servizio dispone delle autorizzazioni di lettura e scrittura nei bucket Cloud Storage. La in modo che l'account disponga di autorizzazioni minime e dispone di e l'accesso alle risorse di cui ha bisogno.

Crea l'account di servizio malware-scanner:

gcloud iam service-accounts create ${SERVICE_NAME}

Concedi il ruolo Amministratore oggetti ai bucket. Il ruolo consente al servizio leggere ed eliminare file dal bucket non analizzato e scrivere nei bucket messi in quarantena e puliti.

gcloud storage buckets add-iam-policy-binding "gs://unscanned-${PROJECT_ID}" \
    --member="serviceAccount:${SERVICE_ACCOUNT}" --role=roles/storage.objectAdmin
gcloud storage buckets add-iam-policy-binding "gs://clean-${PROJECT_ID}" \
    --member="serviceAccount:${SERVICE_ACCOUNT}" --role=roles/storage.objectAdmin
gcloud storage buckets add-iam-policy-binding "gs://quarantined-${PROJECT_ID}" \
    --member="serviceAccount:${SERVICE_ACCOUNT}" --role=roles/storage.objectAdmin
gcloud storage buckets add-iam-policy-binding "gs://cvd-mirror-${PROJECT_ID}" \
    --member="serviceAccount:${SERVICE_ACCOUNT}" --role=roles/storage.objectAdmin

Concedi il ruolo Writer metriche, che consente al servizio di scrivere metriche in Monitoraggio:

gcloud projects add-iam-policy-binding \
      "${PROJECT_ID}" \
      --member="serviceAccount:${SERVICE_ACCOUNT}" \
      --role=roles/monitoring.metricWriter

Crea il servizio di scansione di malware in Cloud Run

In questa sezione eseguirai il deployment del servizio di scansione di malware in Cloud Run. Il servizio viene eseguito in un container Docker che contiene quanto segue:

R Dockerfile per creare un'immagine container con il servizio, il runtime Node.js, Google Cloud SDK e file binari ClamAV.
La File Node.js per il servizio Cloud Run di scansione di malware.
R config.json di configurazione del Cloud Storage per specificare i nomi dei bucket.
R updateCvdMirror.sh per aggiornare il mirror del database delle definizioni di malware ClamAV di archiviazione ideale in Cloud Storage.
R cloud-run-proxy dal servizio al proxy delle richieste HTTP freshclam, che forniscono e l'accesso alle API Cloud Storage.
R bootstrap.sh per eseguire i servizi necessari all'avvio dell'istanza.

Per eseguire il deployment del servizio, segui questi passaggi:

In Cloud Shell, clona il repository GitHub che contiene di codice:

git clone https://github.com/GoogleCloudPlatform/docker-clamav-malware-scanner.git

Passa alla directory cloudrun-malware-scanner:

cd docker-clamav-malware-scanner/cloudrun-malware-scanner

Modifica il file di configurazione config.json per specificare ai bucket Cloud Storage che hai creato. Poiché i nomi dei bucket si basano sull'ID progetto, puoi utilizzare un'operazione di ricerca e sostituzione:
```
sed "s/-bucket-name/-${PROJECT_ID}/" config.json.tmpl > config.json
```
Puoi visualizzare il file di configurazione aggiornato:
```
cat config.json
```
Eseguire un popolamento iniziale del mirror del database del malware ClamAV in Cloud Storage:
```
python3 -m venv pyenv
. pyenv/bin/activate
pip3 install crcmod cvdupdate
./updateCvdMirror.sh "cvd-mirror-${PROJECT_ID}"
deactivate
```
Il comando esegue un'installazione locale dello strumento CVDUpdate e la utilizza per scaricare il database del malware. Il comando quindi carica il database cvd-mirror-PROJECT_ID bucket che creati in precedenza.

Puoi controllare i contenuti del bucket di mirroring:
```
gcloud storage ls "gs://cvd-mirror-${PROJECT_ID}/cvds"
```
Il bucket deve contenere diversi file CVD che contengono il malware completo database, diversi file .cdiff che contengono il differenziale giornaliero e due file .json con informazioni sulla configurazione e sullo stato.
Crea ed esegui il deployment del servizio Cloud Run utilizzando il servizio creato in precedenza:
```
gcloud beta run deploy "${SERVICE_NAME}" \
  --source . \
  --region "${REGION}" \
  --no-allow-unauthenticated \
  --memory 4Gi \
  --cpu 1 \
  --concurrency 20 \
  --min-instances 1 \
  --max-instances 5 \
  --no-cpu-throttling \
  --cpu-boost \
  --service-account="${SERVICE_ACCOUNT}"
```
Il comando crea un'istanza Cloud Run con 1 vCPU e utilizza 4 GiB di di RAM. Queste dimensioni sono accettabili per questo deployment. Tuttavia, in un ambiente di produzione dell'ambiente di rete, potresti scegliere una CPU e una dimensione di memoria più grandi per e un parametro --max-instances più grande. Le dimensioni delle risorse potresti aver bisogno di dipendere dal volume di traffico che il servizio deve gestire.

Il comando include le seguenti specifiche:
- Il parametro --concurrency specifica il numero di simultanei che ogni istanza può elaborare.
- Il parametro --no-cpu-throttling consente all'istanza di eseguire operazioni in background, come l'aggiornamento delle definizioni del malware.
- Il parametro --cpu-boost raddoppia il numero di vCPU sull'istanza per ridurre la latenza all'avvio.
- Il parametro --min-instances 1 mantiene almeno un'istanza attiva, perché il tempo di avvio per ogni istanza è relativamente elevato.
- Il parametro --max-instances 5 impedisce la scalabilità del servizio troppo in alto.
Quando richiesto, inserisci Y per creare il servizio ed eseguirne il deployment. La build richiede circa 10 minuti. Al termine, verrà visualizzato il seguente messaggio è visualizzato:
```
Service [malware-scanner] revision [malware-scanner-UNIQUE_ID] has been deployed and is serving 100 percent of traffic.
Service URL: https://malware-scanner-UNIQUE_ID.a.run.app
```
Archivia il valore Service URL dall'output del comando deployment in un la variabile shell. Potrai utilizzare questo valore in un secondo momento, quando crei Job Cloud Scheduler.
```
SERVICE_URL="SERVICE_URL"
```

Per verificare il servizio in esecuzione e la versione di ClamAV, esegui questo comando:

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

Il servizio Cloud Run richiede che tutte le chiamate siano autenticati e le identità di autenticazione devono avere i Autorizzazione run.routes.invoke per il servizio. Aggiungi l'autorizzazione nella sezione successiva.

Crea un trigger di Cloud Storage Eventarc

In questa sezione, aggiungerai le autorizzazioni per consentire a Eventarc di acquisire eventi Cloud Storage e creare un trigger per inviarli al servizio Cloud Run malware-scanner.

Se utilizzi un progetto esistente creato prima dell'8 aprile 2021, aggiungi il ruolo iam.serviceAccountTokenCreator a Account di servizio Pub/Sub:

PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
PUBSUB_SERVICE_ACCOUNT="service-${PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com"
gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member="serviceAccount:${PUBSUB_SERVICE_ACCOUNT}"\
    --role='roles/iam.serviceAccountTokenCreator'

Questa aggiunta di ruoli è necessaria solo per i progetti meno recenti e consente a Pub/Sub di richiamare il servizio Cloud Run.

In Cloud Shell, concedi il ruolo Publisher Pub/Sub alla Account di servizio Cloud Storage:

STORAGE_SERVICE_ACCOUNT=$(gcloud storage service-agent --project="${PROJECT_ID}")

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
  --member "serviceAccount:${STORAGE_SERVICE_ACCOUNT}" \
  --role "roles/pubsub.publisher"

Consenti all'account di servizio malware-scanner di richiamare il metodo servizio Cloud Run e agiscono da Eventarc destinatario dell'evento:

gcloud run services add-iam-policy-binding "${SERVICE_NAME}" \
  --region="${REGION}" \
  --member "serviceAccount:${SERVICE_ACCOUNT}" \
  --role roles/run.invoker
gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
  --member "serviceAccount:${SERVICE_ACCOUNT}" \
  --role "roles/eventarc.eventReceiver"

Crea un trigger Eventarc per acquisire l'oggetto finalizzato nel bucket Cloud Storage non scansionato e invialo al tuo dal servizio Cloud Run. Il trigger utilizza il parametro Account di servizio malware-scanner per l'autenticazione:

BUCKET_NAME="unscanned-${PROJECT_ID}"
gcloud eventarc triggers create "trigger-${BUCKET_NAME}-${SERVICE_NAME}" \
  --destination-run-service="${SERVICE_NAME}" \
  --destination-run-region="${REGION}" \
  --location="${LOCATION}" \
  --event-filters="type=google.cloud.storage.object.v1.finalized" \
  --event-filters="bucket=${BUCKET_NAME}" \
  --service-account="${SERVICE_ACCOUNT}"

Se viene visualizzato uno dei seguenti errori, attendi un minuto ed esegui esegui di nuovo il comando:

ERROR: (gcloud.eventarc.triggers.create) INVALID_ARGUMENT: The request was invalid: Bucket "unscanned-PROJECT_ID" was not found. Please verify that the bucket exists.

ERROR: (gcloud.eventarc.triggers.create) FAILED_PRECONDITION: Invalid resource state for "": Permission denied while using the Eventarc Service Agent. If you recently started to use Eventarc, it may take a few minutes before all necessary permissions are propagated to the Service Agent. Otherwise, verify that it has Eventarc Service Agent role.

Modifica la scadenza della conferma dei messaggi in due minuti nella parte sottostante la sottoscrizione Pub/Sub utilizzata Trigger Eventarc. Anche il valore predefinito di 10 secondi è è l'abbreviazione di file di grandi dimensioni o carichi elevati.
```
SUBSCRIPTION_NAME=$(gcloud eventarc triggers describe \
    "trigger-${BUCKET_NAME}-${SERVICE_NAME}" \
    --location="${LOCATION}" \
    --format="get(transport.pubsub.subscription)")
gcloud pubsub subscriptions update "${SUBSCRIPTION_NAME}" --ack-deadline=120
```
Anche se il trigger viene creato immediatamente, può richiedere fino a 10 minuti per consentire a un trigger di propagare e filtrare gli eventi.

Crea un job Cloud Scheduler per attivare gli aggiornamenti del mirror del database ClamAV

Crea un job Cloud Scheduler che esegue una richiesta HTTP POST sul servizio Cloud Run con un comando per aggiornare il del database delle definizioni del malware. Per evitare che troppi client usino la stessa fascia oraria, ClamAV richiede la pianificazione del job a un minuto casuale tra 3 e 57, evitando multipli di 10.
```
while : ; do
  # set MINUTE to a random number between 3 and 57
  MINUTE="$((RANDOM%55 + 3))"
  # exit loop if MINUTE isn't a multiple of 10
  [[ $((MINUTE % 10)) != 0 ]] && break
done

gcloud scheduler jobs create http \
    "${SERVICE_NAME}-mirror-update" \
    --location="${REGION}" \
    --schedule="${MINUTE} */2 * * *" \
    --oidc-service-account-email="${SERVICE_ACCOUNT}" \
    --uri="${SERVICE_URL}" \
    --http-method=post \
    --message-body='{"kind":"schedule#cvd_update"}' \
    --headers="Content-Type=application/json"
```
L'argomento della riga di comando --schedule definisce quando viene eseguito il job utilizzando il formato stringa unix-cron. Il valore indicato indica che il job deve essere eseguito all'indirizzo generato in modo casuale ogni due ore.

Questo job aggiorna solo il mirror ClamAV in Cloud Storage. La Daemon ClamAV a molla fresco di Cloud Run esegue il controllo del mirroring ogni 30 minuti per le nuove definizioni e l'aggiornamento del daemon ClamAV.

Testa la pipeline caricando i file

Per testare la pipeline, carica un file pulito (senza malware) e un file di test che riproduce un file infetto:

Crea un file di testo di esempio o utilizza un file pulito esistente per testare dei processi della pipeline.
In Cloud Shell, copia il file di dati di esempio nel bucket non analizzato:
```
gcloud storage cp FILENAME "gs://unscanned-${PROJECT_ID}"
```
Sostituisci FILENAME con il nome del testo chiaro . Il servizio di scansione del malware ispeziona ogni file e lo sposta in una nel bucket appropriato. Questo file viene spostato nel bucket pulito.
Concedi alla pipeline alcuni secondi per elaborare il file, quindi controlla tuo bucket pulito per vedere se il file elaborato è al suo interno:
```
gcloud storage ls "gs://clean-${PROJECT_ID}" --recursive
```
Puoi verificare che il file sia stato rimosso dal bucket non analizzato:
```
gcloud storage ls "gs://unscanned-${PROJECT_ID}" --recursive
```
Carica un file denominato eicar-infected.txt che contiene Firma di test antimalware standard EICAR al bucket non scansionato:
```
echo -e 'X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*' \
    | gcloud storage cp - "gs://unscanned-${PROJECT_ID}/eicar-infected.txt"
```
Questa stringa di testo ha una firma che attiva i rilevatori di malware per i test scopi. Questo file di test è un test ampiamente utilizzato, non è un vero malware ed è innocuo per la tua workstation. Se provi a creare un file contiene questa stringa su un computer su cui è installato un programma per la scansione di malware, puoi attivare un avviso.
Attendi qualche secondo, quindi controlla il bucket in quarantena per vedere se file è stato esaminato correttamente per la pipeline:
```
gcloud storage ls "gs://quarantined-${PROJECT_ID}" --recursive
```
Il servizio registra anche una voce di log di Logging anche quando un malware viene rilevato il file infetto.

Puoi verificare che il file sia stato rimosso dal bucket non analizzato:
```
gcloud storage ls "gs://unscanned-${PROJECT_ID}" --recursive
```

Testare il meccanismo di aggiornamento del database delle definizioni di malware

In Cloud Shell, attiva il controllo della disponibilità di aggiornamenti forzando il Job Cloud Scheduler da eseguire:
```
gcloud scheduler jobs run "${SERVICE_NAME}-mirror-update" --location="${REGION}"
```
I risultati di questo comando sono mostrati solo nei log dettagliati.

Monitorare il servizio

Puoi monitorare il servizio utilizzando Cloud Logging e Cloud Monitoring.

Visualizza log dettagliati

Nella console Google Cloud, vai a Esplora log di Cloud Logging .

Vai a Esplora log
Se il filtro Campi log non viene visualizzato, fai clic su Campi log.
Nel filtro Campi log, fai clic su Revisione Cloud Run.
Nella sezione Nome servizio del filtro Campi log, fai clic su scanner per malware.

I risultati della query sui log mostrano i log del servizio, tra cui diversi che mostrano le richieste di scansione e lo stato dei due file che caricato:

Scan request for gs://unscanned-PROJECT_ID/FILENAME, (##### bytes) scanning with clam ClamAV CLAMAV_VERSION_STRING
Scan status for gs://unscanned-PROJECT_ID/FILENAME: CLEAN (##### bytes in #### ms)
...
Scan request for gs://unscanned-PROJECT_ID/eicar-infected.txt, (69 bytes) scanning with clam ClamAV CLAMAV_VERSION_STRING
Scan status for gs://unscanned-PROJECT_ID/eicar-infected.txt: INFECTED stream: Eicar-Signature FOUND (69 bytes in ### ms)

L'output mostra la versione di ClamAV e la revisione della firma del database del malware. insieme al nome del malware relativo al file di test infetto. Puoi utilizzare questi log messaggi per configurare avvisi per il rilevamento di malware o per gli errori durante la scansione.

L'output mostra anche che le definizioni del malware rispecchiano i log di aggiornamento:

Starting CVD Mirror update
CVD Mirror update check complete. output: ...

Se il mirroring è stato aggiornato, l'output mostra altre righe:

CVD Mirror updated: DATE_TIME - INFO: Downloaded daily.cvd. Version: VERSION_INFO

I log di aggiornamento di Freshclam vengono visualizzati ogni 30 minuti:

DATE_TIME -> Received signal: wake up
DATE_TIME -> ClamAV update process started at DATE_TIME
DATE_TIME -> daily.cvd database is up-to-date (version: VERSION_INFO)
DATE_TIME -> main.cvd database is up-to-date (version: VERSION_INFO)
DATE_TIME -> bytecode.cvd database is up-to-date (version: VERSION_INFO)

Se il database è stato aggiornato, le righe del log di freschezza sono invece simili alla seguenti:

DATE_TIME -> daily.cld updated (version: VERSION_INFO)

Visualizza metriche

Il servizio genera le seguenti metriche a scopo di monitoraggio e avviso:

Numero di file puliti elaborati:
custom.googleapis.com/opencensus/malware-scanning/clean_files
Numero di file infetti elaborati:
custom.googleapis.com/opencensus/malware-scanning/infected_files
Tempo impiegato per la scansione dei file:
custom.googleapis.com/opencensus/malware-scanning/scan_duration
Numero totale di byte analizzati:
custom.googleapis.com/opencensus/malware-scanning/bytes_scanned
Numero di scansioni di malware non riuscite:
custom.googleapis.com/opencensus/malware-scanning/scans_failed
Numero di controlli di aggiornamento di CVD Mirror:
custom.googleapis.com/opencensus/malware-scanning/cvd-mirror-updates

Puoi visualizzare queste metriche in Esplora metriche di Cloud Monitoring:

Nella console Google Cloud, vai a Cloud Monitoring pagina Metrics Explorer.

Vai a Esplora metriche
Fai clic sul campo Seleziona una metrica e inserisci la stringa del filtro malware.
Seleziona la metrica OpenCensus/malware-scanning/clean_files. Il grafico mostra un punto dati che indica quando il file pulito è stato scansionato.

Puoi utilizzare le metriche per monitorare la pipeline e creare avvisi per il momento in cui quando viene rilevato malware o quando l'elaborazione dei file non riesce.

Le metriche generate hanno le seguenti caratteristiche: etichette, che puoi utilizzare per applicare filtri e aggregazioni al fine di visualizzare e più dettagliati Esplora metriche:

source_bucket
destination_bucket
clam_version
cloud_run_revision

Gestire più bucket

Il servizio di scansione del malware può analizzare i file da più bucket di origine e inviarli per separare i bucket puliti e messi in quarantena. Sebbene questo approccio avanzato non rientra nell'ambito di questo deployment, di seguito è riportato un riepilogo dei passaggi richiesti:

Crea elementi non scansionati, puliti e messi in quarantena Bucket Cloud Storage con nomi univoci.
Assegna i ruoli appropriati alle malware-scanner account di servizio per ogni bucket.

Modifica il file di configurazione config.json per specificare i nomi dei bucket per ogni configurazione:

{
  "buckets": [
    {
      "unscanned": "unscanned-bucket-1-name",
      "clean": "clean-bucket-1-name",
      "quarantined": "quarantined-bucket-1-name"
    },
    {
      "unscanned": "unscanned-bucket-2-name",
      "clean": "clean-bucket-2-name",
      "quarantined": "quarantined-bucket-2-name"
    }
  ]
  "ClamCvdMirrorBucket": "cvd-mirror-bucket-name"
}

Per ciascuno dei bucket non analizzati, crea un trigger Eventarc. Assicurati di un nome trigger univoco per ogni bucket.

Il bucket Cloud Storage deve trovarsi nello stesso progetto come trigger Eventarc.

Esegui la pulizia

La sezione seguente spiega come evitare addebiti futuri per progetto Google Cloud che hai utilizzato in questo deployment.

Elimina il progetto Google Cloud

Per evitare che al tuo account Google Cloud vengano addebitati costi per utilizzate in questo deployment, puoi eliminare il progetto Google Cloud.

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à in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro 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.

Nella console Google Cloud, vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi

Esplora la documentazione di Cloud Storage.
Per altre architetture di riferimento, diagrammi e best practice, esplora il Centro architetture cloud.