Implementa un análisis de software malicioso automatizado para los archivos subidos a Cloud Storage

Last reviewed 2024-07-16 UTC

En este documento, se describe cómo implementar la arquitectura en Automatiza el análisis de software malicioso para archivos subidos a Cloud Storage.

En esta guía de implementación, se supone que conoces la funcionalidad básica de las siguientes tecnologías:

Arquitectura

En el siguiente diagrama, se muestra la arquitectura de implementación que crearás en este documento:

Arquitectura de la canalización del análisis de software malicioso.

En el diagrama, se muestran las siguientes dos canalizaciones que administra esta arquitectura:

Canalización de análisis de archivos, que verifica si un archivo subido contiene software malicioso
Canalización de actualización duplicada de la base de datos de software malicioso de ClamAV, que mantiene una duplicación actualizada de la base de datos de software malicioso que usa ClamAV.

Para obtener más información sobre la arquitectura, consulta Automatiza el análisis de software malicioso para archivos subidos a Cloud Storage.

Objetivos

Crear una duplicación de la base de datos de definiciones de software malicioso de ClamAV en un bucket de Cloud Storage
Compila un servicio de Cloud Run con las siguientes funciones:
- Analiza los archivos de un bucket de Cloud Storage en busca de software malicioso con ClamAV y mueve los archivos analizados a depósitos limpios o en cuarentena según el resultado del análisis.
- Mantener una duplicación de la base de datos de definiciones de software malicioso de ClamAV en Cloud Storage
Crea un activador de Eventarc para activar el servicio de análisis de software malicioso cuando se suba un archivo a Cloud Storage.
Crea un trabajo de Cloud Scheduler para activar el servicio de análisis de software malicioso y actualizar la duplicación de la base de datos de definiciones de software malicioso en Cloud Storage.

Costos

En esta arquitectura, se utilizan los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios.

Antes de comenzar

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Artifact Registry, Cloud Run, Eventarc, Logging, Cloud Scheduler, Pub/Sub, and Cloud Build APIs.

Enable the APIs

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Artifact Registry, Cloud Run, Eventarc, Logging, Cloud Scheduler, Pub/Sub, and Cloud Build APIs.

Enable the APIs

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.

Configure su entorno

En esta sección, debes asignar parámetros de configuración a los valores que se usan en la implementación, como la región y la zona. En esta implementación, debes usar us-central1 como la región para el servicio de Cloud Run y us como la ubicación para el activador de Eventarc y los buckets de Cloud Storage.

En Cloud Shell, configura las variables de shell comunes, incluidas la región y la ubicación:

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

Reemplaza PROJECT_ID con el ID del proyecto.

Inicializa el entorno gcloud con el ID de tu proyecto:
```
gcloud config set project "${PROJECT_ID}"
```
Crea tres depósitos de Cloud Storage con nombres únicos:
```
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} se usa para garantizar que los nombres de los buckets sean únicos.

Estos tres buckets contienen los archivos subidos en varias etapas durante la canalización de análisis de archivos:
- unscanned-PROJECT_ID: Contiene los archivos antes de que se analicen. Tus usuarios suben sus archivos a este bucket.
- quarantined-PROJECT_ID: Contiene los archivos que el servicio de análisis de software malicioso analizó y considera que contienen software malicioso.
- clean-PROJECT_ID: Contiene los archivos que el servicio de análisis de software malicioso analizó y descubrió que no están infectados.
Crea un cuarto bucket de Cloud Storage:
```
gcloud storage buckets create "gs://cvd-mirror-${PROJECT_ID}" --location="${LOCATION}"
```
${PROJECT_ID} se usa para garantizar que el nombre del bucket sea único.

Este bucket cvd-mirror-PROJECT_ID se usa para mantener una duplicación local de la base de datos de definiciones de software malicioso, que evita que la CDN de ClamAV active el límite de frecuencia.

Configura una cuenta de servicio para el servicio de análisis de software malicioso

En esta sección, crearás una cuenta de servicio para usar en el servicio de análisis de software malicioso. Luego, otorgas lo roles correspondientes a la cuenta de servicio a fin de que tenga permisos para leer y escribir en los buckets de Cloud Storage. Los roles garantizan que la cuenta tenga permisos mínimos y que solo tenga acceso a los recursos que necesita.

Crea la cuenta de servicio malware-scanner:

gcloud iam service-accounts create ${SERVICE_NAME}

Otorga el rol de administrador de objetos a los buckets. Este rol permite que el servicio lea y borre archivos del bucket no analizado y escriba archivos en los buckets en cuarentena y limpios.

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

Otorga el rol de escritor de métricas, que permite que el servicio escriba métricas en Monitoring:

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

Crea el servicio de análisis de software malicioso en Cloud Run

En esta sección, implementarás el servicio de análisis de software malicioso en Cloud Run. El servicio se ejecuta en un contenedor de Docker que contiene lo siguiente:

Un Dockerfile para compilar una imagen de contenedor con el servicio, el entorno de ejecución de Node.js, el SDK de Google Cloud y los objetos binarios de ClamAV.
Los archivos Node.js para el servicio de análisis de software malicioso de Cloud Run.
Un archivo de configuración config.json para especificar los nombres de tus buckets de Cloud Storage.
Una secuencia de comandos de shell updateCvdMirror.sh para actualizar la duplicación de la base de datos de definiciones de software malicioso de ClamAV en Cloud Storage.
Un servicio cloud-run-proxy para usar un proxy en las solicitudes HTTP freshclam, que proporcionan acceso autenticado a las APIs de Cloud Storage
Una secuencia de comandos de shell bootstrap.sh para ejecutar los servicios necesarios cuando se inicia la instancia.

Para implementar el servicio, haz lo siguiente:

En Cloud Shell, clona el repositorio de GitHub que contiene los archivos de código:

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

Cambia al directorio cloudrun-malware-scanner:

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

Edita el archivo de configuración config.json para especificar los buckets de Cloud Storage que creaste. Debido a que los nombres de los buckets se basan en el ID del proyecto, puedes usar una operación de búsqueda y reemplazo:
```
sed "s/-bucket-name/-${PROJECT_ID}/" config.json.tmpl > config.json
```
Puedes ver el archivo de configuración actualizado:
```
cat config.json
```
Realiza una propagación inicial de la duplicación de la base de datos de software malicioso de ClamAV en Cloud Storage:
```
python3 -m venv pyenv
. pyenv/bin/activate
pip3 install crcmod cvdupdate
./updateCvdMirror.sh "cvd-mirror-${PROJECT_ID}"
deactivate
```
El comando realiza una instalación local de la herramienta CVDUpdate y la usa para descargar la base de datos de software malicioso. Luego, el comando sube la base de datos al bucket cvd-mirror-PROJECT_ID que creaste antes.

Puedes verificar el contenido del bucket de duplicación:
```
gcloud storage ls "gs://cvd-mirror-${PROJECT_ID}/cvds"
```
El bucket debe contener varios archivos CVD que contengan la base de datos completa de software malicioso, varios archivos .cdiff que contengan las actualizaciones diferenciales diarias y dos archivos .json con información de configuración y estado.
Crea y, luego, implementa el servicio de Cloud Run mediante la cuenta de servicio que creaste antes:
```
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}"
```
El comando crea una instancia de Cloud Run que tiene 1 CPU virtual y usa 4 GiB de RAM. Este tamaño es aceptable para esta implementación. Sin embargo, en un entorno de producción, puedes elegir un tamaño de CPU y memoria más grande para la instancia, y un parámetro --max-instances más grande. Los tamaños de recursos que podrías necesitar dependen de la cantidad de tráfico que el servicio necesite manejar.

El comando incluye las siguientes especificaciones:
- El parámetro --concurrency especifica la cantidad de solicitudes simultáneas que puede procesar cada instancia.
- El parámetro --no-cpu-throttling permite que la instancia realice operaciones en segundo plano, como la actualización de las definiciones de software malicioso.
- El parámetro --cpu-boost duplica la cantidad de CPU virtuales en el inicio de la instancia para reducir la latencia de inicio.
- El parámetro --min-instances 1 mantiene al menos una instancia activa, ya que el tiempo de inicio de cada instancia es relativamente alto.
- El parámetro --max-instances 5 evita que el servicio escale demasiado verticalmente.
Cuando se te solicite, ingresa Y para compilar y, luego, implementar el servicio. La compilación y la implementación tardan unos 10 minutos. Cuando se complete, se mostrará el siguiente mensaje:
```
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
```
Almacena el valor Service URL del resultado del comando de implementación en una variable de shell. Usarás el valor más adelante cuando crees un trabajo de Cloud Scheduler.
```
SERVICE_URL="SERVICE_URL"
```

Para verificar el servicio en ejecución y la versión de ClamAV, ejecuta el siguiente comando:

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

El servicio de Cloud Run requiere que se autentiquen todas las invocaciones, y las identidades que se autentican deben tener el permiso run.routes.invoke en el servicio. Agrega el permiso en la siguiente sección.

Crea un activador de Eventarc en Cloud Storage

En esta sección, agregarás permisos para permitir que Eventarc capture eventos de Cloud Storage y cree un activador a fin de enviar estos eventos al servicio malware-scanner de Cloud Run.

Si usas un proyecto existente que se creó antes del 8 de abril de 2021, agrega el rol iam.serviceAccountTokenCreator a la cuenta de servicio de 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'

Esta adición de roles solo es necesaria para proyectos más antiguos y permite que Pub/Sub invoque el servicio de Cloud Run.

En Cloud Shell, otorga el rol de publicador de Pub/Sub a la cuenta de servicio de 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"

Permite que la cuenta de servicio malware-scanner invoque el servicio de Cloud Run y actúe como un receptor de eventos de 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 activador de Eventarc para capturar el evento de objeto final en el bucket no analizado de Cloud Storage y envíalo a tu servicio de Cloud Run. El activador usa la cuenta de servicio malware-scanner para la autenticación:

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}"

Si recibes uno de los siguientes errores, espera un minuto y vuelve a ejecutar el 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.

Cambia el plazo de confirmación de mensaje a dos minutos en la suscripción subyacente de Pub/Sub que usa el activador de Eventarc. El valor predeterminado de 10 segundos es demasiado corto para archivos grandes o cargas altas.
```
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
```
Aunque tu activador se crea de inmediato, puede tardar hasta 10 minutos en propagarse y filtrar los eventos.

Crea un trabajo de Cloud Scheduler para activar las actualizaciones de la duplicación de la base de datos de ClamAV

Crea un trabajo de Cloud Scheduler que ejecute una solicitud HTTP POST en el servicio de Cloud Run con un comando para actualizar la duplicación de la base de datos de definiciones de software malicioso. Para evitar que demasiados clientes usen la misma ranura de tiempo, ClamAV requiere que programes el trabajo en un minuto aleatorio entre 3 y 57, evitando múltiplos de 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"

El argumento de línea de comandos --schedule define cuándo se ejecuta el trabajo con el formato de cadena unix-cron. El valor proporcionado indica que el trabajo debe ejecutarse en el minuto específico generado de forma aleatoria cada dos horas.

Este trabajo solo actualiza la duplicación de ClamAV en Cloud Storage. El daemon de freshclam de ClamAV en cada instancia de Cloud Run verifica la duplicación cada 30 minutos para detectar definiciones nuevas y actualiza el daemon de ClamAV.

Sube archivos para probar la canalización

Para probar la canalización, sube un archivo limpio (libre de software malicioso) y un archivo de prueba que imite un archivo infectado:

Crea un archivo de texto de muestra o usa un archivo limpio existente para probar los procesos de canalización.
En Cloud Shell, copia el archivo de datos de muestra en el bucket no analizado:
```
gcloud storage cp FILENAME "gs://unscanned-${PROJECT_ID}"
```
Reemplaza FILENAME con el nombre del archivo de texto limpio. El servicio de análisis de software malicioso inspecciona cada archivo y lo mueve a un bucket adecuado. Este archivo se mueve al bucket limpio.
Espera unos segundos mientras la canalización procesa el archivo y, luego, verifica el bucket limpio para ver si el archivo procesado está allí:
```
gcloud storage ls "gs://clean-${PROJECT_ID}" --recursive
```
Puedes verificar que el archivo se haya quitado del bucket no analizado:
```
gcloud storage ls "gs://unscanned-${PROJECT_ID}" --recursive
```
Sube un archivo denominado eicar-infected.txt que contenga la firma de prueba de software malicioso estándar de EICAR en el bucket no analizado:
```
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"
```
Esta cadena de texto tiene una firma que activa el analizador de software malicioso con fines de prueba. Este archivo de prueba es una prueba muy usada, no es software malicioso real y es inofensivo para tu estación de trabajo. Si intentas crear un archivo que contenga esta cadena en una computadora que tenga instalado un analizador de software malicioso, puedes activar una alerta.
Espera unos segundos y, luego, verifica el bucket en cuarentena para ver si el archivo pasó por la canalización de forma correcta:
```
gcloud storage ls "gs://quarantined-${PROJECT_ID}" --recursive
```
El servicio también registra una entrada de registro de Logging cuando se detecta un archivo infectado con software malicioso.

Puedes verificar que el archivo se haya quitado del bucket no analizado:
```
gcloud storage ls "gs://unscanned-${PROJECT_ID}" --recursive
```

Prueba el mecanismo de actualización de la base de datos de definiciones de software malicioso

En Cloud Shell, puedes activar la verificación de actualizaciones si fuerzas la ejecución del trabajo de Cloud Scheduler:
```
gcloud scheduler jobs run "${SERVICE_NAME}-mirror-update" --location="${REGION}"
```
Los resultados de este comando solo se muestran en los registros detallados.

Supervisa el servicio

Puedes supervisar el servicio mediante Cloud Logging y Cloud Monitoring.

Ve registros detallados

En la consola de Google Cloud, ve a la página Explorador de registros de Cloud Logging.

Ir al Explorador de registros
Si el filtro Campos de registro no se muestra, haz clic en Campos de registro.
En el filtro Campos de registro, haz clic en Revisión de Cloud Run.
En la sección Nombre del servicio del filtro Campos de registro, haz clic en malware-scanner

Los resultados de la consulta de registros muestran los registros del servicio, incluidas varias líneas que muestran las solicitudes de análisis y el estado de los dos archivos que subiste:

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)

El resultado muestra la versión de ClamAV y la revisión de la firma de la base de datos de software malicioso, junto con el nombre del software malicioso del archivo de prueba infectado. Puedes usar estos mensajes de registro a fin de configurar alertas para cuando se haya encontrado software malicioso o cuando se hayan producido errores durante el análisis.

En el resultado, también se muestran los registros de actualización de la duplicación de software malicioso:

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

Si se actualizó la duplicación, el resultado muestra líneas adicionales:

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

Los registros de actualización de freshclam aparecen cada 30 minutos:

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)

Si se actualizó la base de datos, las líneas de registro de freshclam son similares a las siguientes:

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

Ver métricas

El servicio genera las siguientes métricas para fines de supervisión y alertas:

Cantidad de archivos limpios procesados:
custom.googleapis.com/opencensus/malware-scanning/clean_files
Cantidad de archivos infectados procesados:
custom.googleapis.com/opencensus/malware-scanning/infected_files
Tiempo de análisis de archivos:
custom.googleapis.com/opencensus/malware-scanning/scan_duration
Cantidad total de bytes analizados:
custom.googleapis.com/opencensus/malware-scanning/bytes_scanned
Cantidad de análisis de software malicioso con errores:
custom.googleapis.com/opencensus/malware-scanning/scans_failed
Cantidad de verificaciones de actualización de la duplicación de CVD:
custom.googleapis.com/opencensus/malware-scanning/cvd-mirror-updates

Puedes ver estas métricas en el Explorador de métricas de Cloud Monitoring:

En la consola de Google Cloud, ve a la página Explorador de métricas de Cloud Monitoring.

Ir al Explorador de métricas
Haz clic en el campo Seleccionar una métrica y, luego, ingresa la string de filtro malware.
Selecciona la métrica OpenCensus/malware-scanning/clean_files. El gráfico muestra un dato que indica cuándo se analizó el archivo limpio.

Puedes usar métricas para supervisar la canalización y crear alertas cuando se detecte software malicioso o cuando el procesamiento de archivos falle.

Las métricas generadas tienen las siguientes etiquetas, que puedes usar para filtrar y agregar a fin de ver detalles más precisos con el Explorador de métricas:

source_bucket
destination_bucket
clam_version
cloud_run_revision

Administra varios buckets

El servicio de análisis de software malicioso puede analizar archivos de varios buckets de origen y enviarlos a buckets limpios y en cuarentena. Aunque esta configuración avanzada está fuera del alcance de esta implementación, el siguiente es un resumen de los pasos requeridos:

Crea buckets de Cloud Storage no analizados, limpios y en cuarentena con nombres únicos.
Otorga los roles correspondientes a la cuenta de servicio malware-scanner en cada bucket.

Edita el archivo de configuración config.json para especificar los nombres de los buckets de cada configuración:

{
  "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"
}

Para cada uno de los buckets no analizados, crea un activador de Eventarc. Asegúrate de crear un nombre de activador único para cada bucket.

El bucket de Cloud Storage debe estar en el mismo proyecto y la misma región que el activador de Eventarc.

Libera espacio

En la siguiente sección, se explica cómo puedes evitar los cargos futuros para el proyecto de Google Cloud que usaste en esta implementación.

Borra el proyecto de Google Cloud

Puedes borrar el proyecto de Google Cloud para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en esta implementación.

Precaución: Borrar un proyecto tiene las siguientes consecuencias:

Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

¿Qué sigue?

Explora la documentación de Cloud Storage.
Para obtener más información sobre las arquitecturas de referencia, los diagramas y las prácticas recomendadas, explora Cloud Architecture Center.