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

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

  1. 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.

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

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Artifact Registry, Cloud Build, Resource Manager, Cloud Scheduler, Eventarc, Logging, Monitoring, Pub/Sub, Cloud Run, and Service Usage APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

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

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the Artifact Registry, Cloud Build, Resource Manager, Cloud Scheduler, Eventarc, Logging, Monitoring, Pub/Sub, Cloud Run, and Service Usage APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

    8.

  8. 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.

    9. En esta implementación, ejecutarás todos los comandos desde Cloud Shell.

    Implementa la arquitectura

    Puedes implementar la arquitectura que se describe en este documento con uno de los siguientes métodos:

    • Usa Cloud Shell: Usa este método si deseas ver cómo se implementa y configura cada componente de la solución con la herramienta de línea de comandos de Google Cloud CLI.

      Para usar este método de implementación, sigue las instrucciones en Implementa con Cloud Shell.

    • Usa la CLI de Terraform: Usa este método si quieres implementar la solución con la menor cantidad posible de pasos manuales. Este método se basa en Terraform para implementar y configurar los componentes individuales.

      Para usar este método de implementación, sigue las instrucciones en Implementa con la CLI de Terraform.

    Implementa con Cloud Shell

    Para implementar de forma manual la arquitectura que se describe en este documento, completa los pasos de las siguientes subsecciones.

    Prepara el 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.

    1. 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.

    2. Inicializa el entorno gcloud con el ID de tu proyecto:

      gcloud config set project "${PROJECT_ID}"

    3. 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.

    4. 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.

    1. Crea la cuenta de servicio malware-scanner:

      gcloud iam service-accounts create ${SERVICE_NAME}

    2. 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

    3. 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 TypeScript 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.
    • 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:

    1. 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

    2. Cambia al directorio cloudrun-malware-scanner:

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

    3. Crea el archivo de configuración config.json según el archivo de plantilla config.json.tmpl en el repositorio de GitHub:

      sed "s/-bucket-name/-${PROJECT_ID}/" config.json.tmpl > config.json

      El comando anterior usa una operación de búsqueda y reemplazo para asignarles a los buckets de Cloud Storage nombres únicos basados en el ID del proyecto.

    4. Opcional: Consulta el archivo de configuración actualizado:

      cat config.json

    5. 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

      Estos comandos realizan una instalación local de la herramienta CVDUpdate y, luego, ejecutan la secuencia de comandos updateCvdMirror.sh que usa CVDUpdate para copiar la base de datos de software malicioso de ClamAV en el 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.

    6. 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 \
  --timeout 300s \
  --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.

    7. 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

    8. 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"

    9. Opcional: 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 resultado es similar al siguiente ejemplo. Muestra la versión del servicio de análisis de software malicioso, la versión de ClamAV y la versión de las definiciones de software malicioso con la fecha en que se actualizaron por última vez.

      gcs-malware-scanner version 3.2.0
Using Clam AV version: ClamAV 1.4.1/27479/Fri Dec  6 09:40:14 2024

    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.

    1. 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.

    2. 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"

    3. 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"

    4. 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 los comandos:

      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.

    5. Cambia el plazo de confirmación de mensaje a cinco 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=300

      Aunque tu activador se creará de inmediato, puede tardar hasta dos minutos para que funcione por completo.

    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.

    Implementa con la CLI de Terraform

    En esta sección, se describe la implementación de la arquitectura que se describe en este documento con la CLI de Terraform.

    Clona el repositorio de GitHub

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

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

    Prepare el 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.

    1. 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

      Reemplaza PROJECT_ID con el ID del proyecto.

    2. Inicializa el entorno gcloud CLI con el ID de tu proyecto:

      gcloud config set project "${PROJECT_ID}"

    3. Crea el archivo de configuración config.json según el archivo de plantilla config.json.tmpl en el repositorio de GitHub:

      sed "s/-bucket-name/-${PROJECT_ID}/" \
  docker-clamav-malware-scanner/cloudrun-malware-scanner/config.json.tmpl \
  > docker-clamav-malware-scanner/cloudrun-malware-scanner/config.json

      El comando anterior usa una operación de búsqueda y reemplazo para asignarles a los buckets de Cloud Storage nombres únicos basados en el ID del proyecto.

    4. Opcional: Consulta el archivo de configuración actualizado:

      cat docker-clamav-malware-scanner/cloudrun-malware-scanner/config.json

    5. Configura las variables de Terraform. El contenido del archivo de configuración config.json se pasa a Terraform con la variable TF_VAR_config_json, de modo que Terraform sepa qué buckets de Cloud Storage debe crear. El valor de esta variable también se pasa a Cloud Run para configurar el servicio.

      TF_VAR_project_id=$PROJECT_ID
TF_VAR_region=us-central1
TF_VAR_bucket_location=us
TF_VAR_config_json="$(cat docker-clamav-malware-scanner/cloudrun-malware-scanner/config.json)"
TF_VAR_create_buckets=true
export TF_VAR_project_id TF_VAR_region TF_VAR_bucket_location TF_VAR_config_json TF_VAR_create_buckets

    Implementa la infraestructura base

    1. En Cloud Shell, ejecuta los siguientes comandos para implementar la infraestructura básica:

      gcloud services enable \
  cloudresourcemanager.googleapis.com \
  serviceusage.googleapis.com
cd docker-clamav-malware-scanner/terraform/infra
terraform init
terraform apply

      Responde yes cuando se te solicite.

      Esta secuencia de comandos de Terraform realiza las siguientes tareas:

      • Crea las cuentas de servicio
      • Crea el registro de Artifact Registry
      • Crea los buckets de Cloud Storage
      • Establece los roles y permisos adecuados
      • Realiza una propagación inicial del bucket de Cloud Storage que contiene la duplicación de la base de datos de definiciones de software malicioso de ClamAV.

    Compila el contenedor para el servicio

    1. En Cloud Shell, ejecuta los siguientes comandos para iniciar un trabajo de Cloud Build que cree la imagen de contenedor para el servicio:

      cd ../../cloudrun-malware-scanner
gcloud builds submit \
  --region="$TF_VAR_region" \
  --config=cloudbuild.yaml \
  --service-account="projects/$PROJECT_ID/serviceAccounts/malware-scanner-build@$PROJECT_ID.iam.gserviceaccount.com" \
  .

      Espera unos minutos a que se complete la compilación.

    Implementa el servicio y el activador

    1. En Cloud Shell, ejecuta los siguientes comandos para implementar el servicio de Cloud Run:

      cd ../terraform/service/
terraform init
terraform apply

      Responde yes cuando se te solicite.

      El servicio puede tardar varios minutos en implementarse y comenzar a ejecutarse.

      Esta secuencia de comandos de Terraform realiza las siguientes tareas:

      • Implementa el servicio de Cloud Run con la imagen de contenedor que acabas de compilar.
      • Configura los activadores de Eventarc en los buckets de Cloud Storage unscanned. Aunque tu activador se crea de inmediato, puede tardar hasta dos minutos para que funcione por completo.
      • Crea el trabajo de Cloud Scheduler para actualizar la duplicación de las definiciones de software malicioso de ClamAV.

      Si la implementación falla con uno de los siguientes errores, espera un minuto y, luego, vuelve a ejecutar el comando terraform apply para intentar crear el activador de Eventarc.

      Error: Error creating Trigger: googleapi: Error 400: Invalid resource state for "": The request was invalid: Bucket "unscanned-PROJECT_ID" was not found. Please verify that the bucket exists.

      Error: Error creating Trigger: googleapi: Error 400: 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..

    2. Opcional: Para verificar el servicio en ejecución y la versión de ClamAV en uso, ejecuta los siguientes comandos:

      MALWARE_SCANNER_URL="$(terraform output -raw cloud_run_uri)"
curl -H "Authorization: Bearer $(gcloud auth print-identity-token)"  \
  "${MALWARE_SCANNER_URL}"

      El resultado es similar al siguiente ejemplo. Muestra la versión del servicio de análisis de software malicioso, la versión de ClamAV y la versión de las definiciones de software malicioso con la fecha en que se actualizaron por última vez.

      gcs-malware-scanner version 3.2.0
Using Clam AV version: ClamAV 1.4.1/27479/Fri Dec  6 09:40:14 2024

    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:

    1. Crea un archivo de texto de muestra o usa un archivo limpio existente para probar los procesos de canalización.

    2. 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.

    3. 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

    4. 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.

    5. 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

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

      Ir al Explorador de registros

    2. Si el filtro Campos de registro no se muestra, haz clic en Campos de registro.

    3. En el filtro Campos de registro, haz clic en Revisión de Cloud Run.

    4. 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:
      workload.googleapis.com/googlecloudplatform/gcs-malware-scanning/clean-files
    • Cantidad de archivos infectados procesados:
      workload.googleapis.com/googlecloudplatform/gcs-malware-scanning/infected-files
    • Cantidad de archivos ignorados y no analizados:
      workload.googleapis.com/googlecloudplatform/gcs-malware-scanning/ignored-files
    • Tiempo de análisis de archivos:
      workload.googleapis.com/googlecloudplatform/gcs-malware-scanning/scan-duration
    • Cantidad total de bytes analizados:
      workload.googleapis.com/googlecloudplatform/gcs-malware-scanning/bytes-scanned
    • Cantidad de análisis de software malicioso con errores:
      workload.googleapis.com/googlecloudplatform/gcs-malware-scanning/scans-failed
    • Cantidad de verificaciones de actualización de la duplicación de CVD:
      workload.googleapis.com/googlecloudplatform/gcs-malware-scanning/cvd-mirror-updates

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

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

      Ir al Explorador de métricas

    2. Haz clic en el campo Seleccionar una métrica y, luego, ingresa la string de filtro malware.

    3. Expande el recurso Generic Task.

    4. Expande la categoría Googlecloudplatform.

    5. Selecciona la métrica googlecloudplatform/gcs-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

    En la métrica ignored_files, las siguientes etiquetas reason definen por qué se ignoran los archivos:

    • ZERO_LENGTH_FILE: Si se establece el valor de configuración ignoreZeroLengthFiles y el archivo está vacío.
    • FILE_TOO_LARGE: Cuando el archivo supera el tamaño máximo de análisis de 500 MiB.
    • REGEXP_MATCH: Cuando el nombre de archivo coincide con uno de los patrones definidos en fileExclusionPatterns.
    • FILE_SIZE_MISMATCH: Si el tamaño del archivo cambia mientras se examina.

    Configuración avanzada

    En las siguientes secciones, se describe cómo puedes configurar el escáner con parámetros más avanzados.

    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:

    1. Crea buckets de Cloud Storage no analizados, limpios y en cuarentena con nombres únicos.

    2. Otorga los roles correspondientes a la cuenta de servicio malware-scanner en cada bucket.

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

    4. 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.

    Si usas la implementación de Terraform, los pasos de esta sección se aplican automáticamente cuando pasas el archivo de configuración config.json actualizado en la variable de configuración de Terraform TF_VAR_config_json.

    Cómo ignorar archivos temporales

    Algunos servicios de carga, como las puertas de enlace de SFTP a Cloud Storage, crean uno o más archivos temporales durante el proceso de carga. Luego, estos servicios cambian el nombre de los archivos al nombre final una vez que se completa la carga.

    El comportamiento normal del escáner es analizar y mover todos los archivos, incluidos estos archivos temporales, en cuanto se escriben, lo que puede provocar que el servicio de carga falle cuando no puede encontrar sus archivos temporales.

    La sección fileExclusionPatterns del archivo de configuración config.json te permite usar expresiones regulares para especificar una lista de patrones de nombres de archivos que se deben ignorar. Los archivos que coincidan con estas expresiones regulares se dejarán en el bucket unscanned.

    Cuando se activa esta regla, se incrementa el contador ignored-files y se registra un mensaje para indicar que se ignoró el archivo que coincidía con el patrón.

    En el siguiente muestra de código, se muestra un archivo de configuración config.json con la lista fileExclusionPatterns configurada para ignorar los archivos que terminan en .tmp o que contienen la cadena .partial_upload..

    {
  "buckets": [
    {
      "unscanned": "unscanned-bucket-name",
      "clean": "clean-bucket-name",
      "quarantined": "quarantined-bucket-name"
    },
  ],
  "ClamCvdMirrorBucket": "cvd-mirror-bucket-name",
  "fileExclusionPatterns": [
    "\\.tmp$",
    "\\.partial_upload\\."
  ]
}

    Ten cuidado cuando uses caracteres \ en la expresión regular, ya que deberán incluirse como escape en el archivo JSON con otro \. Por ejemplo, para especificar un . literal en una expresión regular, el símbolo debe tener un escape dos veces: una vez para la expresión regular y otra vez para el texto en el archivo JSON, por lo que se convierte en \\., como en la última línea del muestra de código anterior.

    Ignorar archivos de longitud cero

    Al igual que con los archivos temporales, algunos servicios de carga crean un archivo de longitud cero en Cloud Storage y, luego, actualizan este archivo con más contenido.

    También puedes ignorar estos archivos configurando el parámetro config.json ignoreZeroLengthFiles en true, por ejemplo:

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

    Cuando se activa esta regla, se incrementa la métrica ignored-files y se registra un mensaje para indicar que se ignoró un archivo de longitud cero.

    Tamaño máximo del archivo de análisis

    El tamaño máximo predeterminado del archivo de análisis es de 500 MiB. Se elige este tamaño porque se tarda aproximadamente 5 minutos en analizar un archivo de este tamaño.

    Se ignoran los archivos que superan los 500 MiB y se dejan en el bucket de unscanned. La métrica files-ignored se incrementa y se registra un mensaje.

    Si necesitas aumentar este límite, actualiza los siguientes límites para que se adapten a los nuevos valores máximos de tamaño de archivo y duración del análisis:

    Limpia

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

    Borra el Google Cloud proyecto

    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.

    1. In the Google Cloud console, go to the Manage resources page.

      Go to Manage resources

    2. In the project list, select the project that you want to delete, and then click Delete.
    3. In the dialog, type the project ID, and then click Shut down to delete the project.

    ¿Qué sigue?