Déployer une analyse automatisée des logiciels malveillants pour les fichiers importés dans Cloud Storage

Last reviewed 2023-06-20 UTC

Ce document explique comment déployer l'architecture sur la page Automatiser la détection de logiciels malveillants pour les fichiers importés dans Cloud Storage.

Dans ce guide de déploiement, nous partons du principe que vous connaissez les fonctionnalités de base des technologies suivantes:

Architecture

Le schéma suivant illustre l'architecture de déploiement que vous allez créer dans ce document :

Architecture du pipeline de détection des logiciels malveillants.

Le schéma montre les deux pipelines suivants gérés par cette architecture:

Le pipeline d'analyse des fichiers, qui vérifie si un fichier importé contient des logiciels malveillants.
Le pipeline de mise à jour du miroir de la base de données ClamAV de logiciels malveillants, qui tient à jour un miroir de la base de données de logiciels malveillants utilisée par ClamAV.

Pour en savoir plus sur l'architecture, consultez la page Automatiser la détection de logiciels malveillants pour les fichiers importés dans Cloud Storage.

Objectifs

Créer un miroir de la base de données ClamAV de définitions de logiciels malveillants dans un bucket Cloud Storage.
Créer un service Cloud Run avec les fonctions suivantes :
- Détection de logiciels malveillants dans des fichiers stockés dans un bucket Cloud Storage à l'aide de ClamAV, et déplacement des fichiers analysés vers des buckets de fichiers sains ou mis en quarantaine en fonction du résultat de l'analyse.
- Gestion d'un miroir de la base de données ClamAV de définitions de logiciels malveillants dans Cloud Storage.
Créer un déclencheur Eventarc pour déclencher le service de détection de logiciels malveillants lors de l'importation d'un fichier dans Cloud Storage.
Créer un job Cloud Scheduler pour déclencher le service de détection de logiciels malveillants afin d'actualiser le miroir de la base de données de définitions de logiciels malveillants dans Cloud Storage.

Coûts

Cette architecture utilise les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.

Avant de commencer

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.

Configurer votre environnement

Dans cette section, vous créez des paramètres pour les valeurs utilisées tout au long du déploiement, telles que la région et la zone. Dans ce déploiement, vous utilisez us-central1 comme région pour le service Cloud Run et us comme emplacement pour le déclencheur Eventarc et les buckets Cloud Storage.

Dans Cloud Shell, définissez les variables de shell courantes, y compris la région et l'emplacement :

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

Remplacez PROJECT_ID par l'ID du projet.

Initialisez l'environnement gcloud avec votre ID de projet :
```
gcloud config set project "${PROJECT_ID}"
```
Créez trois buckets Cloud Storage avec des noms uniques :
```
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} permet de garantir que les noms de bucket sont uniques.

Ces trois buckets contiennent les fichiers importés lors des différentes étapes du pipeline d'analyse de fichiers :
- unscanned-PROJECT_ID : contient les fichiers avant leur analyse. Vos utilisateurs importent leurs fichiers dans ce bucket.
- quarantined-PROJECT_ID : contient les fichiers analysés par le service de détection de logiciels malveillants et considérés comme contenant des logiciels malveillants.
- clean-PROJECT_ID : contient les fichiers analysés par le service de détection de logiciels malveillants et identifiés comme non infectés.
Créez un quatrième bucket Cloud Storage :
```
gsutil mb -l "${LOCATION}" "gs://cvd-mirror-${PROJECT_ID}"
```
${PROJECT_ID} permet de garantir que le nom du bucket est unique.

Ce bucket cvd-mirror-PROJECT_ID sert à gérer un miroir local de la base de données de définitions de logiciels malveillants, ce qui évite le déclenchement de la limitation du débit par le CDN de ClamAV.

Configurer un compte de service pour le service de détection de logiciels malveillants

Dans cette section, vous allez créer un compte de service à utiliser pour le service de détection de logiciels malveillants. Vous accordez ensuite les rôles appropriés au compte de service afin qu'il soit autorisé à lire et écrire dans les buckets Cloud Storage. Ces rôles garantissent que le compte dispose d'autorisations minimales et qu'il n'a accès qu'aux ressources dont il a besoin.

Créez le compte de service malware-scanner :

gcloud iam service-accounts create ${SERVICE_NAME}

Attribuez le rôle "Administrateur des objets" pour les buckets, ce qui permet au service de lire et de supprimer des fichiers du bucket non analysé, ainsi que d'écrire des fichiers dans les buckets de fichiers sains et mis en quarantaine.

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

Attribuez le rôle "Rédacteur de métriques" permettant au service d'écrire des métriques dans Monitoring :

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

Créer un service de détection de logiciels malveillants dans Cloud Run

Dans cette section, vous déployez le service de détection de logiciels malveillants sur Cloud Run. Le service s'exécute dans un conteneur Docker et contient les éléments suivants :

Un fichier Dockerfile pour créer une image de conteneur avec le service, l'environnement d'exécution Node.js, le SDK Google Cloud et les binaires ClamAV.
Les fichiers Node.js pour le service Cloud Run de détection de logiciels malveillants
Le fichier de configuration config.json pour spécifier les noms de vos buckets Cloud Storage.
Le script shell updateCvdMirror.sh servant à actualiser le miroir de la base de données ClamAV de définitions de logiciels malveillants dans Cloud Storage.
Le service cloud-run-proxy servant de proxy pour les requêtes HTTP freshclam, qui fournissent un accès authentifié aux API Cloud Storage.
Le script shell bootstrap.sh afin d'exécuter les services nécessaires au démarrage de l'instance.

Pour déployer le service, procédez comme suit:

Dans Cloud Shell, clonez le dépôt GitHub contenant les fichiers de code :

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

Accédez au répertoire cloudrun-malware-scanner :

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

Modifiez le fichier de configuration config.json pour spécifier les buckets Cloud Storage que vous avez créés. Comme les noms de buckets sont basés sur l'ID du projet, vous pouvez utiliser une opération de recherche et de remplacement:
```
sed "s/-bucket-name/-${PROJECT_ID}/" config.json.tmpl > config.json
```
Vous pouvez afficher le fichier de configuration mis à jour :
```
cat config.json
```
Effectuez un remplissage initial du miroir de la base de données ClamAV dans Cloud Storage :
```
python3 -m venv pyenv
. pyenv/bin/activate
pip3 install crcmod cvdupdate
./updateCvdMirror.sh "cvd-mirror-${PROJECT_ID}"
deactivate
```
La commande effectue une installation locale de l'outil CVDUpdate et l'utilise pour télécharger la base de données contenant les logiciels malveillants. La commande importe ensuite la base de données dans le bucket cvd-mirror-PROJECT_ID que vous avez créé précédemment.

Vous pouvez vérifier le contenu du bucket :
```
gsutil ls "gs://cvd-mirror-${PROJECT_ID}/cvds"
```
Le bucket doit contenir plusieurs fichiers CVD contenant la base de données malveillante complète, plusieurs fichiers .cdiff contenant les mises à jour différentielles quotidiennes et deux fichiers .json avec des informations de configuration et d'état.
Créez et déployez le service Cloud Run à l'aide du compte de service que vous avez créé précédemment:
```
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}"
```
La commande crée une instance Cloud Run avec un processeur virtuel et utilisant 4 Gio de RAM. Cette taille est acceptable pour ce déploiement. Dans un environnement de production, vous pouvez toutefois choisir une taille de processeur et de mémoire plus importante pour l'instance, ainsi qu'un paramètre --max-instances plus important. Les tailles de ressources dont vous pourriez avoir besoin dépendent du volume de trafic que le service doit gérer.

La commande inclut les spécifications suivantes:
- Le paramètre --concurrency indique le nombre de requêtes simultanées que chaque instance peut traiter.
- Le paramètre --no-cpu-throttling permet à l'instance d'effectuer des opérations en arrière-plan, telles que la mise à jour des définitions de logiciels malveillants.
- Le paramètre --cpu-boost double le nombre de vCPU au démarrage de l'instance afin de réduire la latence de démarrage.
- Le paramètre --min-instances 1 conserve au moins une instance active, car le temps de démarrage de chaque instance est relativement élevé.
- Le paramètre --max-instances 5 empêche un scaling à la hausse excessif du service.
Lorsque vous y êtes invité, saisissez Y pour créer et déployer le service. La compilation et le déploiement prennent environ 10 minutes. Une fois l'opération terminée, le message suivant s'affiche:
```
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
```
Stockez la valeur Service URL résultant de la commande de déploiement dans une variable shell. Vous utiliserez cette valeur lorsque vous créerez une tâche Cloud Scheduler.
```
SERVICE_URL="SERVICE_URL"
```

Pour vérifier le service en cours d'exécution et la version de ClamAV, exécutez la commande suivante:

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

Le service Cloud Run exige que tous les appels soient authentifiés, et les identités d'authentification doivent disposer de l'autorisation run.routes.invoke sur le service. Vous ajouterez l'autorisation dans la section suivante.

Créer un déclencheur Cloud Storage pour Eventarc

Dans cette section, vous allez ajouter des autorisations pour permettre à Eventarc de capturer les événements Cloud Storage et de créer un déclencheur pour envoyer ces événements au service malware-scanner Cloud Run.

Si vous utilisez un projet existant qui a été créé avant le 8 avril 2021, ajoutez le rôle iam.serviceAccountTokenCreator au compte de service 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'

Cet ajout de rôle n'est requis que pour les projets plus anciens et permet à Pub/Sub d'appeler le service Cloud Run.

Dans Cloud Shell, attribuez le rôle "Diffuseur Pub/Sub" au compte de service 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"

Autorisez le compte de service malware-scanner à appeler le service Cloud Run et à agir en tant que récepteur d'événements 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"

Créez un déclencheur Eventarc pour capturer l'événement d'objet finalisé dans le bucket Cloud Storage non analysé et l'envoyer à votre service Cloud Run. Le déclencheur utilise le compte de service malware-scanner pour l'authentification:

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 vous recevez l'une des erreurs suivantes, attendez une minute, puis exécutez à nouveau la commande:

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.

Remplacez le délai de confirmation du message par deux minutes dans l'abonnement Pub/Sub sous-jacent utilisé par le déclencheur Eventarc. La valeur par défaut de 10 secondes est trop courte pour les fichiers volumineux ou les charges élevées.
```
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
```
Bien que votre déclencheur soit créé immédiatement, sa propagation et le filtrage d'événements peuvent prendre jusqu'à 10 minutes.

Créer un job Cloud Scheduler pour déclencher les mises à jour du miroir de la base de données ClamAV

Créez un job Cloud Scheduler qui exécute une requête HTTP POST sur le service Cloud Run avec une commande permettant de mettre à jour le miroir de la base de données de définitions de logiciels malveillants. Pour éviter que trop de clients n'utilisent le même créneau, ClamAV exige de planifier le job à une minute aléatoire comprise entre 3 et 57, en évitant les multiples 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"
```
L'argument de ligne de commande --schedule définit le moment où le job est exécuté au format de chaîne unix-cron. La valeur donnée indique que la tâche doit être exécutée à la minute spécifique générée de manière aléatoire toutes les deux heures.

Cette tâche ne met à jour que le miroir dans Cloud Storage. Le daemon ClamAV freshclam dans chaque instance de Cloud Run vérifie la présence de nouvelles définitions auprès du miroir toutes les 30 minutes, et met à jour le daemon ClamAV.

Tester le pipeline en important des fichiers

Pour tester le pipeline, vous devez importer un fichier sain (sans logiciel malveillant) et un fichier de test qui imite un fichier infecté:

Créez un exemple de fichier texte ou utilisez un fichier sain existant pour tester les processus du pipeline.
Dans Cloud Shell, copiez l'exemple de fichier de données dans le bucket non analysé:
```
gsutil cp FILENAME "gs://unscanned-${PROJECT_ID}"
```
Remplacez FILENAME par le nom du fichier texte sain. Le service de détection de logiciels malveillants inspecte chaque fichier et le déplace vers le bucket approprié. Ce fichier est déplacé vers le bucket sain.
Laissez quelques secondes au pipeline pour traiter le fichier, puis vérifiez dans le bucket sain que le fichier traité est bien présent :
```
gsutil ls -r "gs://clean-${PROJECT_ID}"
```
Vous pouvez vérifier que le fichier a été supprimé du bucket non analysé:
```
gsutil ls -r "gs://unscanned-${PROJECT_ID}"
```
Importez un fichier nommé eicar-infected.txt contenant la signature de test anti-logiciels malveillants standard EICAR dans votre bucket non analysé:
```
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"
```
Cette chaîne de texte comporte une signature qui déclenche les services de détection de logiciels malveillants à des fins de test. Ce fichier de test est largement utilisé. Il ne s'agit pas d'un logiciel malveillant réel, et il est inoffensif pour votre poste de travail. Si vous essayez de créer un fichier contenant cette chaîne sur un ordinateur sur lequel un détecteur de logiciels malveillants est installé, vous pouvez déclencher une alerte.
Attendez quelques secondes, puis vérifiez dans le bucket de quarantaine que votre fichier est bien passé à travers le pipeline :
```
gsutil ls -r "gs://quarantined-${PROJECT_ID}"
```
Le service consigne également une entrée de journal Logging lorsqu'un fichier infecté par un logiciel malveillant est détecté.

Vous pouvez vérifier que le fichier a été supprimé du bucket non analysé:
```
gsutil ls -r "gs://unscanned-${PROJECT_ID}"
```

Tester le mécanisme de mise à jour de la base de données de définitions de logiciels malveillants

Dans Cloud Shell, déclenchez la vérification des mises à jour en forçant l'exécution du job Cloud Scheduler :
```
gcloud scheduler jobs run "${SERVICE_NAME}-mirror-update" --location="${REGION}"
```
Les résultats de cette commande ne sont affichés que dans les journaux détaillés.

Surveiller le service

Vous pouvez surveiller le service à l'aide de Cloud Logging et de Cloud Monitoring.

Afficher les journaux détaillés

Dans la console Google Cloud, accédez à la page "Explorateur de journaux" de Cloud Logging.

Accéder à l'explorateur de journaux
Si le filtre Champs de journal ne s'affiche pas, cliquez sur Champs de journal.
Dans le filtre Champs de journal, cliquez sur Révision dans Cloud Run.
Dans la section Nom du service du filtre Champs de journal, cliquez sur malware-scanner.

Les résultats de la requête de journaux affichent les journaux du service, y compris plusieurs lignes indiquant les requêtes d'analyse et l'état des deux fichiers que vous avez importés:

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)

Le résultat affiche la version de ClamAV et la révision de signature de base de données de logiciels malveillants, ainsi que le nom du logiciel malveillant pour le fichier de test infecté. Vous pouvez utiliser ces messages de journaux pour configurer des alertes chaque fois qu'un logiciel malveillant a été détecté ou lorsque des échecs se sont produits lors de l'analyse.

Le résultat affiche également les définitions des mises à jour des miroirs de définitions des logiciels malveillants:

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

Si le miroir a été mis à jour, le résultat affiche des lignes supplémentaires:

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

Les journaux de mise à jour freshclam apparaissent toutes les 30 minutes :

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 la base de données a été mise à jour, les lignes de journal freshclam sont à la place semblables à celles-ci:

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

Afficher les métriques

Le service génère les métriques suivantes à des fins de surveillance et d'alerte :

Nombre de fichiers sains traités :
custom.googleapis.com/opencensus/malware-scanning/clean_files
Nombre de fichiers infectés traités :
custom.googleapis.com/opencensus/malware-scanning/infected_files
Temps passé à analyser les fichiers :
custom.googleapis.com/opencensus/malware-scanning/scan_duration
Nombre total d'octets analysés :
custom.googleapis.com/opencensus/malware-scanning/bytes_scanned
Nombre d'échecs d'analyse de logiciels malveillants :
custom.googleapis.com/opencensus/malware-scanning/scans_failed
Nombre de vérifications de mise à jour du miroir CVD :
custom.googleapis.com/opencensus/malware-scanning/cvd-mirror-updates

Vous pouvez afficher ces métriques dans l'explorateur de métriques Cloud Monitoring:

Dans la console Google Cloud, accédez à la page "Explorateur de métriques" de Cloud Monitoring.

Accéder à l'explorateur de métriques
Cliquez sur le champ Sélectionner une métrique, puis saisissez la chaîne de filtre malware.
Sélectionnez la métrique OpenCensus/malware-scanning/clean_files. Le graphique affiche un point de données indiquant à quel moment le fichier sain a été analysé.

Vous pouvez utiliser des métriques pour surveiller le pipeline et créer des alertes en cas de détection d'un logiciel malveillant ou d'échec du traitement des fichiers.

Les métriques générées présentent les Libellés suivants que vous pouvez utiliser pour filtrer et agréger afin d'afficher des détails plus précis avecExplorateur de métriques :

source_bucket
destination_bucket
clam_version
cloud_run_revision

Gérer plusieurs buckets

Le service de détection de logiciels malveillants peut analyser des fichiers provenant de plusieurs buckets sources et les envoyer dans des buckets séparés propres et mis en quarantaine. Bien que cette configuration avancée n'entre pas dans le cadre de ce déploiement, voici un résumé des étapes requises:

Créer des buckets Cloud Storage non analysés, propres et mis en quarantaine avec des noms uniques
Attribuez les rôles appropriés au compte de service malware-scanner sur chaque bucket.

Modifiez le fichier de configuration config.json pour spécifier les noms des buckets pour chaque configuration :

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

Pour chacun des buckets non analysés, créez un déclencheur Eventarc. Veillez à créer un nom de déclencheur unique pour chaque bucket.

Le bucket Cloud Storage doit se trouver dans le même projet et la même région que le déclencheur Eventarc.

Effectuer un nettoyage

La section suivante explique comment éviter les frais futurs pour le projet Google Cloud que vous avez utilisé dans ce déploiement.

Supprimer le projet Google Cloud

Pour éviter que les ressources utilisées dans ce déploiement ne soient facturées sur votre compte Google Cloud, vous pouvez supprimer le projet Google Cloud.

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

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.

Étapes suivantes

Passez en revue la documentation Cloud Storage.
Pour découvrir d'autres architectures de référence, schémas et bonnes pratiques, consultez le Centre d'architecture cloud.