Esegui il deployment della scansione automatica dei malware per i file caricati in Cloud Storage

Last reviewed 2023-06-20 UTC

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

Questa guida al deployment presuppone che tu conosca le funzionalità di base delle seguenti tecnologie:

Architettura

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

Architettura della pipeline di analisi dei malware.

Il diagramma mostra le seguenti due pipeline gestite da questa architettura:

Pipeline di analisi dei file, che verifica se un file caricato contiene malware.
Il database di malware ClamAV esegue il mirroring della pipeline di aggiornamento, che mantiene un mirroring aggiornato del database del malware utilizzato da ClamAV.

Per ulteriori informazioni sull'architettura, consulta Automatizzare la scansione antimalware per i file caricati su Cloud Storage.

Obiettivi

Crea un mirror del database delle definizioni di malware ClamAV in un bucket Cloud Storage.
Crea un servizio Cloud Run con le seguenti funzioni:
- Analizzare i file in un bucket Cloud Storage alla ricerca di malware utilizzando ClamAV e spostare i file scansionati in bucket puliti o messi in quarantena in base al risultato dell'analisi.
- Mantenimento di un mirror del database delle definizioni di malware ClamAV in Cloud Storage.
Crea un trigger Eventarc per attivare il servizio di analisi dei malware quando un file viene caricato in Cloud Storage.
Crea un job Cloud Scheduler per attivare il servizio di scansione antimalware in modo che aggiorni il mirroring del database delle definizioni di malware in Cloud Storage.

Costi

Questa architettura utilizza i seguenti componenti fatturabili di Google Cloud:

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

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 gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

In the Google Cloud console, on the project selector page, select or create a Google Cloud 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, on the project selector page, select or create a Google Cloud 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

Nella console Google Cloud, attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell che mostra un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installato e con valori già impostati per il progetto attuale. L'inizializzazione della sessione può richiedere alcuni secondi.

Configura l'ambiente

In questa sezione assegnerai le impostazioni per i valori utilizzati durante il deployment, ad esempio regione e zona. In questo deployment, utilizzerai us-central1 come regione per il servizio Cloud Run e us come località per il trigger Eventarc e i bucket Cloud Storage.

In Cloud Shell, imposta le 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:
```
gsutil mb -l "${LOCATION}" "gs://unscanned-${PROJECT_ID}"
gsutil mb -l "${LOCATION}" "gs://quarantined-${PROJECT_ID}"
gsutil mb -l "${LOCATION}" "gs://clean-${PROJECT_ID}"
```
${PROJECT_ID} viene utilizzato per assicurarsi che i nomi dei bucket siano univoci.

Questi tre bucket contengono i file caricati in varie fasi durante la pipeline di analisi dei file:
- unscanned-PROJECT_ID: conserva i file prima che vengano scansionati. Gli utenti caricano i propri file in questo bucket.
- quarantined-PROJECT_ID: contiene i file scansionati dal servizio di scansione malware e ritenuti contenenti malware.
- clean-PROJECT_ID: contiene i file che il servizio di scansione malware ha analizzato e che non sono stati infettati.
Crea un quarto bucket Cloud Storage:
```
gsutil mb -l "${LOCATION}" "gs://cvd-mirror-${PROJECT_ID}"
```
${PROJECT_ID} viene utilizzato per assicurarsi che il nome del bucket sia univoco.

Questo bucket cvd-mirror-PROJECT_ID viene utilizzato per mantenere un mirroring locale del database delle definizioni di malware, che impedisce l'attivazione limitazione di frequenza da parte di CDN ClamAV.

Configura un account di servizio per il servizio di scansione malware

In questa sezione creerai un account di servizio da utilizzare per il servizio di scansione dei malware. Assegna quindi i ruoli appropriati all'account di servizio in modo che disponga delle autorizzazioni di lettura e scrittura nei bucket Cloud Storage. I ruoli assicurano che l'account disponga di autorizzazioni minime e che abbia accesso solo 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 di leggere ed eliminare i file dal bucket non analizzato e di scrivere file nei bucket puliti e in quarantena.

gsutil iam ch \
    "serviceAccount:${SERVICE_ACCOUNT}:objectAdmin" \
    "gs://unscanned-${PROJECT_ID}"
gsutil iam ch \
    "serviceAccount:${SERVICE_ACCOUNT}:objectAdmin" \
    "gs://clean-${PROJECT_ID}"
gsutil iam ch \
    "serviceAccount:${SERVICE_ACCOUNT}:objectAdmin" \
    "gs://quarantined-${PROJECT_ID}"
gsutil iam ch \
    "serviceAccount:${SERVICE_ACCOUNT}:objectAdmin" \
    "gs://cvd-mirror-${PROJECT_ID}"

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

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

Crea il servizio di analisi dei malware in Cloud Run

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

Un Dockerfile per creare un'immagine container con il servizio, il runtime Node.js, Google Cloud SDK e i programmi binari ClamAV.
I file Node.js per il servizio Cloud Run di scansione dei malware.
Un file di configurazione config.json per specificare i nomi dei bucket Cloud Storage.
Uno script shell di updateCvdMirror.sh per aggiornare il mirroring del database delle definizioni di malware ClamAV in Cloud Storage.
Un servizio cloud-run-proxy per eseguire il proxy delle richieste HTTP freshclam, che forniscono accesso autenticato alle API Cloud Storage.
Uno script shell di bootstrap.sh per eseguire i servizi necessari all'avvio dell'istanza.

Per eseguire il deployment del servizio:

In Cloud Shell, clona il repository GitHub che contiene i file 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 i 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
```
Esegui un completamento iniziale del mirroring del database di 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 lo utilizza per scaricare il database del malware. Il comando carica quindi il database nel bucket cvd-mirror-PROJECT_ID che hai creato in precedenza.

Puoi controllare i contenuti del bucket mirror:
```
gsutil ls "gs://cvd-mirror-${PROJECT_ID}/cvds"
```
Il bucket deve contenere diversi file CVD che contengono l'intero database di malware, diversi file .cdiff che contengono gli aggiornamenti differenziali giornalieri e due file .json con informazioni sulla configurazione e sullo stato.
Crea ed esegui il deployment del servizio Cloud Run utilizzando l'account di 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 RAM. Queste dimensioni sono accettabili per questo deployment. Tuttavia, in un ambiente di produzione, ti consigliamo di scegliere dimensioni di CPU e memoria più elevate per l'istanza e un parametro --max-instances più grande. Le dimensioni delle risorse di cui potresti aver bisogno dipendono dalla quantità di traffico che il servizio deve gestire.

Il comando include le seguenti specifiche:
- Il parametro --concurrency specifica il numero di richieste simultanee che ogni istanza può elaborare.
- Il parametro --no-cpu-throttling consente all'istanza di eseguire operazioni in background, come l'aggiornamento delle definizioni di malware.
- Il parametro --cpu-boost raddoppia il numero di vCPU all'avvio dell'istanza per ridurre la latenza di 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 che il servizio venga fatto lo scale up troppo elevato.
Quando richiesto, inserisci Y per creare il servizio ed eseguirne il deployment. La build e il deployment richiedono circa 10 minuti. Una volta completata, viene visualizzato il seguente messaggio:
```
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 dell'output del comando di deployment in una variabile della shell. Puoi utilizzare il valore in un secondo momento, quando crei un 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 vengano autenticate e le identità di autenticazione devono disporre dell'autorizzazione run.routes.invoke per il servizio. Puoi aggiungere l'autorizzazione nella sezione successiva.

Crea un trigger di Eventarc Cloud Storage

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

Se utilizzi un progetto esistente creato prima dell'8 aprile 2021, aggiungi il ruolo iam.serviceAccountTokenCreator all'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'

L'aggiunta di ruoli è obbligatoria 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 all'account di servizio Cloud Storage:

STORAGE_SERVICE_ACCOUNT=$(gsutil kms serviceaccount -p "${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 servizio Cloud Run e agire come ricevitore di eventi Eventarc:

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'evento dell'oggetto finalizzato nel bucket Cloud Storage non analizzato e inviarlo al servizio Cloud Run. Il trigger utilizza l'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 ricevi uno dei seguenti errori, attendi un minuto ed 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 per la conferma dei messaggi in due minuti nella sottoscrizione Pub/Sub sottostante utilizzata dal trigger Eventarc. Il valore predefinito di 10 secondi è troppo breve per 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, la propagazione e il filtro degli eventi possono richiedere fino a 10 minuti.

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

Crea un job Cloud Scheduler che esegue una richiesta HTTP POST sul servizio Cloud Run con un comando per aggiornare il mirroring del database delle definizioni di malware. Per evitare che troppi client utilizzino la stessa fascia oraria, ClamAV richiede di pianificare il job in un minuto casuale compreso 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 il job viene eseguito utilizzando il formato stringa unix-cron. Il valore specificato indica che il job deve essere eseguito al minuto specifico generato in modo casuale ogni due ore.

Questo job aggiorna solo il mirror ClamAV in Cloud Storage. Il daemon refreshclam ClamAV in ogni istanza di Cloud Run controlla il Mirror ogni 30 minuti per verificare la presenza di nuove definizioni e aggiorna il daemon ClamAV.

Testa la pipeline caricando 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 i processi della pipeline.
In Cloud Shell, copia il file dei dati di esempio nel bucket non analizzato:
```
gsutil cp FILENAME "gs://unscanned-${PROJECT_ID}"
```
Sostituisci FILENAME con il nome del file di testo pulito. Il servizio di scansione malware esamina ogni file e lo sposta in un bucket appropriato. Questo file viene spostato nel bucket pulito.
Concedi alla pipeline alcuni secondi per elaborare il file, quindi controlla il bucket pulito per verificare se il file elaborato è presente:
```
gsutil ls -r "gs://clean-${PROJECT_ID}"
```
Puoi verificare che il file sia stato rimosso dal bucket non analizzato:
```
gsutil ls -r "gs://unscanned-${PROJECT_ID}"
```
Carica un file denominato eicar-infected.txt contenente la firma per il test antimalware standard EICAR nel bucket non analizzato:
```
echo -e 'X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*' \
    | gsutil cp - "gs://unscanned-${PROJECT_ID}/eicar-infected.txt"
```
Questa stringa di testo ha una firma che attiva gli scanner di malware per scopi di test. Questo file di test è un test ampiamente utilizzato: non si tratta di malware effettivo e non è innocuo per la tua workstation. Se provi a creare un file contenente questa stringa su un computer su cui è installato uno scanner malware, puoi attivare un avviso.
Attendi qualche secondo, quindi controlla il bucket in quarantena per vedere se il file è passato correttamente attraverso la pipeline:
```
gsutil ls -r "gs://quarantined-${PROJECT_ID}"
```
Il servizio registra anche una voce di log di Logging quando viene rilevato un file infetto da malware.

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

Testare il meccanismo di aggiornamento del database delle definizioni di malware.

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

Monitora il servizio

Puoi monitorare il servizio utilizzando Cloud Logging e Cloud Monitoring.

Visualizza log dettagliati

Nella console Google Cloud, vai alla pagina Esplora log di Cloud Logging.

Vai a Esplora log
Se il filtro Campi log non è 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 malware-scanner.

I risultati della query sui log mostrano i log del servizio, incluse diverse righe che mostrano le richieste di scansione e lo stato dei due file caricati:

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 di malware, insieme al nome del malware per il file di test infetto. Puoi utilizzare questi messaggi di log per configurare avvisi relativi al rilevamento di malware o a quando si sono verificati errori durante l'analisi.

L'output mostra anche le definizioni di malware che eseguono il mirroring dei log di aggiornamento:

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

Se il mirror è stato aggiornato, l'output mostra righe aggiuntive:

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 di log refreshclam sono invece simili alle seguenti:

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

Visualizza metriche

Il servizio genera le seguenti metriche per scopi 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 analisi di malware non riuscite:
custom.googleapis.com/opencensus/malware-scanning/scans_failed
Numero di controlli della disponibilità di aggiornamenti CVD Mirror:
custom.googleapis.com/opencensus/malware-scanning/cvd-mirror-updates

Puoi visualizzare queste metriche in Cloud Monitoring Metrics Explorer:

Nella console Google Cloud, vai alla pagina Metrics Explorer di Cloud Monitoring.

Vai a Metrics Explorer
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 è stata eseguita la scansione del file pulito.

Puoi utilizzare le metriche per monitorare la pipeline e creare avvisi per sapere quando vengono rilevati malware o quando i file non vengono elaborati.

Le metriche generate hanno le seguenti etichette, che puoi utilizzare per filtri e aggregazioni in modo da visualizzare dettagli più granulari con Metrics Explorer:

source_bucket
destination_bucket
clam_version
cloud_run_revision

Gestire più bucket

Il servizio di scansione dei malware può analizzare i file da più bucket di origine e inviarli a bucket separati, puliti e in quarantena. Sebbene questa configurazione avanzata non rientri nell'ambito di questo deployment, di seguito è riportato un riepilogo dei passaggi richiesti:

Creare bucket Cloud Storage non analizzati, puliti e in quarantena con nomi univoci.
Concedi i ruoli appropriati all'account di servizio malware-scanner in ciascun 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 creare un nome trigger univoco per ogni bucket.

Il bucket Cloud Storage deve trovarsi nello stesso progetto e nella stessa regione del trigger Eventarc.

Esegui la pulizia

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

Elimina il progetto Google Cloud

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

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 ulteriori architetture di riferimento, diagrammi e best practice, esplora il Cloud Architecture Center.