Cette page a été traduite par l'API Cloud Translation.

Déployer la détection automatique des logiciels malveillants pour les fichiers importés dans Cloud Storage

Last reviewed 2024-12-02 UTC

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

Ce guide de déploiement suppose 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 section Automatiser la détection de logiciels malveillants pour des 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 Build, Resource Manager, Cloud Scheduler, Eventarc, Logging, Monitoring, Pub/Sub, Cloud Run, and Service Usage 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 Build, Resource Manager, Cloud Scheduler, Eventarc, Logging, Monitoring, Pub/Sub, Cloud Run, and Service Usage 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.

Déployer l'architecture

Vous pouvez déployer l'architecture décrite dans ce document à l'aide de l'une des méthodes suivantes :

Utiliser Cloud Shell : utilisez cette méthode si vous souhaitez voir comment chaque composant de la solution est déployé et configuré à l'aide de l'outil de ligne de commande Google Cloud CLI.

Pour utiliser cette méthode de déploiement, suivez les instructions de la section Déployer à l'aide de Cloud Shell.
Utiliser la CLI Terraform : utilisez cette méthode si vous souhaitez déployer la solution en un minimum d'étapes manuelles. Cette méthode s'appuie sur Terraform pour déployer et configurer les composants individuels.

Pour utiliser cette méthode de déploiement, suivez les instructions de la section Déployer à l'aide de la CLI Terraform.

Déployer à l'aide de Cloud Shell

Pour déployer manuellement l'architecture décrite dans ce document, suivez les étapes décrites dans les sous-sections suivantes.

Préparer 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 :
```
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} 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 :
```
gcloud storage buckets create "gs://cvd-mirror-${PROJECT_ID}" --location="${LOCATION}"
```
${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 qui sera utilisé par le service de détection de logiciels malveillants. Vous attribuez ensuite les rôles appropriés au compte de service afin qu'il soit autorisé à lire et écrire dans les buckets Cloud Storage. Les rôles permettent de s'assurer que le compte dispose d'autorisations minimales et 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.

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

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 servant à créer une image de conteneur qui héberge le service, l'environnement d'exécution Node.js, Google Cloud SDK et les binaires ClamAV.
Les fichiers TypeScript 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 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

Créez le fichier de configuration config.json en fonction du fichier modèle config.json.tmpl dans le dépôt GitHub :
```
sed "s/-bucket-name/-${PROJECT_ID}/" config.json.tmpl > config.json
```
La commande précédente utilise une opération de recherche et de remplacement pour attribuer aux buckets Cloud Storage des noms uniques basés sur l'ID du projet.
Facultatif : Affichez 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
```
Ces commandes effectuent une installation locale de l'outil CVDUpdate, puis exécutent le script updateCvdMirror.sh qui utilise CVDUpdate pour copier la base de données de logiciels malveillants ClamAV dans le bucket cvd-mirror-PROJECT_ID que vous avez créé précédemment.

Vous pouvez vérifier le contenu du bucket :
```
gcloud storage ls "gs://cvd-mirror-${PROJECT_ID}/cvds"
```
Le bucket doit contenir plusieurs fichiers CVD qui correspondent à la base de données complète de logiciels malveillants, plusieurs fichiers .cdiff contenant les mises à jour différentielles quotidiennes, et deux fichiers JSON contenant 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 \
  --timeout 300s \
  --service-account="${SERVICE_ACCOUNT}"
```
La commande crée une instance Cloud Run dotée d'un processeur virtuel et de 4 Gio de RAM. Cette taille est acceptable pour ce déploiement. Toutefois, dans un environnement de production, vous pouvez choisir une taille de processeur et de mémoire plus importante pour l'instance, ainsi qu'un paramètre --max-instances plus élevé. 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 ultérieurement lorsque vous créerez un job Cloud Scheduler.
```
SERVICE_URL="SERVICE_URL"
```
Facultatif : 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 résultat doit ressembler à l'exemple ci-dessous. Il indique la version du service d'analyse des logiciels malveillants, la version de ClamAV et la version des définitions de logiciels malveillants avec la date de leur dernière mise à jour.
```
gcs-malware-scanner version 3.2.0
Using Clam AV version: ClamAV 1.4.1/27479/Fri Dec  6 09:40:14 2024
```

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=$(gcloud storage service-agent --project="${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 les commandes :

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.

Passez le délai de confirmation des messages à cinq 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=300
```
Bien que votre déclencheur soit créé immédiatement, il peut falloir jusqu'à deux minutes pour qu'il soit pleinement opérationnel.

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 fournie indique que le job doit s'exécuter toutes les deux heures à la minute spécifiée, générée aléatoirement.

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.

Déployer via la CLI Terraform

Cette section décrit le déploiement de l'architecture décrite dans ce document à l'aide de la CLI Terraform.

Cloner le dépôt GitHub

Dans Cloud Shell, clonez le dépôt GitHub contenant les fichiers de code et Terraform :
```
git clone https://github.com/GoogleCloudPlatform/docker-clamav-malware-scanner.git
```

Préparer l'environnement

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
```
Remplacez PROJECT_ID par l'ID du projet.
Initialisez l'environnement gcloud CLI avec votre ID de projet :
```
gcloud config set project "${PROJECT_ID}"
```
Créez le fichier de configuration config.json en fonction du fichier modèle config.json.tmpl dans le dépôt 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
```
La commande précédente utilise une opération de recherche et de remplacement pour attribuer aux buckets Cloud Storage des noms uniques basés sur l'ID du projet.

Facultatif : Affichez le fichier de configuration mis à jour :

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

Configurez les variables Terraform. Le contenu du fichier de configuration config.json est transmis à Terraform à l'aide de la variable TF_VAR_config_json, afin que Terraform sache quels buckets Cloud Storage créer. La valeur de cette variable est également transmise à Cloud Run pour configurer le service.

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

Déployer l'infrastructure de base

Dans Cloud Shell, exécutez les commandes suivantes pour déployer l'infrastructure de base :
```
gcloud services enable \
  cloudresourcemanager.googleapis.com \
  serviceusage.googleapis.com
cd docker-clamav-malware-scanner/terraform/infra
terraform init
terraform apply
```
Répondez yes lorsque vous y êtes invité.

Ce script Terraform effectue les tâches suivantes :
- Crée les comptes de service
- Crée Artifact Registry
- Crée les buckets Cloud Storage
- Définir les rôles et autorisations appropriés
- Effectue un remplissage initial du bucket Cloud Storage contenant le miroir de la base de données ClamAV de définitions de logiciels malveillants

Créer le conteneur pour le service

Dans Cloud Shell, exécutez les commandes suivantes pour lancer un job Cloud Build afin de créer l'image de conteneur pour le service :

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

Attendez quelques minutes que la compilation se termine.

Déployer le service et le déclencheur

Dans Cloud Shell, exécutez les commandes suivantes pour déployer le service Cloud Run :
```
cd ../terraform/service/
terraform init
terraform apply
```
Répondez yes lorsque vous y êtes invité.

Le déploiement et le démarrage du service peuvent prendre plusieurs minutes.

Ce script Terraform effectue les tâches suivantes :
- Déploie le service Cloud Run à l'aide de l'image de conteneur que vous venez de créer.
- Configure les déclencheurs Eventarc sur les buckets Cloud Storage unscanned. Bien que votre déclencheur soit créé immédiatement, il peut falloir jusqu'à deux minutes pour qu'il soit pleinement opérationnel.
- Crée le job Cloud Scheduler pour mettre à jour le miroir des définitions de logiciels malveillants ClamAV.
Si le déploiement échoue avec l'une des erreurs suivantes, attendez une minute, puis exécutez à nouveau la commande terraform apply pour réessayer de créer le déclencheur 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..
```
Facultatif : Pour vérifier le service en cours d'exécution et la version de ClamAV utilisée, exécutez les commandes suivantes :
```
MALWARE_SCANNER_URL="$(terraform output -raw cloud_run_uri)"
curl -H "Authorization: Bearer $(gcloud auth print-identity-token)"  \
  "${MALWARE_SCANNER_URL}"
```
Le résultat doit ressembler à l'exemple ci-dessous. Il indique la version du service d'analyse des logiciels malveillants, la version de ClamAV et la version des définitions de logiciels malveillants avec la date de leur dernière mise à jour.
```
gcs-malware-scanner version 3.2.0
Using Clam AV version: ClamAV 1.4.1/27479/Fri Dec  6 09:40:14 2024
```

Tester le pipeline en important des fichiers

Pour tester le pipeline, importez 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 des fichiers non analysés :
```
gcloud storage 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 :
```
gcloud storage ls "gs://clean-${PROJECT_ID}" --recursive
```
Vous pouvez vérifier que le fichier a été supprimé du bucket non analysé :
```
gcloud storage ls "gs://unscanned-${PROJECT_ID}" --recursive
```
Importez un fichier 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*' \
    | gcloud storage 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 un test 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é, cela peut déclencher une alerte.
Attendez quelques secondes, puis vérifiez dans le bucket de quarantaine que votre fichier est bien passé à travers le pipeline :
```
gcloud storage ls "gs://quarantined-${PROJECT_ID}" --recursive
```
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é :
```
gcloud storage ls "gs://unscanned-${PROJECT_ID}" --recursive
```

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 la signature de la base de données de logiciels malveillants, ainsi que le nom du logiciel malveillant correspondant au 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 journaux de mise à jour du miroir des définitions de logiciels malveillants :

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

Si le miroir a été mis à jour, des lignes supplémentaires s'affichent dans le résultat :

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 :
workload.googleapis.com/googlecloudplatform/gcs-malware-scanning/clean-files
Nombre de fichiers infectés traités :
workload.googleapis.com/googlecloudplatform/gcs-malware-scanning/infected-files
Nombre de fichiers ignorés et non analysés :
workload.googleapis.com/googlecloudplatform/gcs-malware-scanning/ignored-files
Temps passé à analyser les fichiers :
workload.googleapis.com/googlecloudplatform/gcs-malware-scanning/scan-duration
Nombre total d'octets analysés :
workload.googleapis.com/googlecloudplatform/gcs-malware-scanning/bytes-scanned
Nombre d'échecs d'analyse de logiciels malveillants :
workload.googleapis.com/googlecloudplatform/gcs-malware-scanning/scans-failed
Nombre de vérifications de mise à jour du miroir CVD :
workload.googleapis.com/googlecloudplatform/gcs-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 Cloud Monitoring > Explorateur de métriques.

Accéder à l'explorateur de métriques
Cliquez sur le champ Sélectionner une métrique, puis saisissez la chaîne de filtre malware.
Développez la ressource Generic Task.
Développez la catégorie Googlecloudplatform.
Sélectionnez la métrique googlecloudplatform/gcs-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

Dans la métrique ignored_files, les libellés reason suivants définissent la raison pour laquelle les fichiers sont ignorés :

ZERO_LENGTH_FILE : si la valeur de configuration ignoreZeroLengthFiles est définie et que le fichier est vide.
FILE_TOO_LARGE : lorsque le fichier dépasse la taille maximale d'analyse de 500 Mio.
REGEXP_MATCH : lorsque le nom de fichier correspond à l'un des modèles définis dans fileExclusionPatterns.
FILE_SIZE_MISMATCH : si la taille du fichier change pendant son examen.

Configuration avancée

Les sections suivantes expliquent comment configurer le scanner avec des paramètres plus avancés.

Gérer plusieurs buckets

Le service de détection de logiciels malveillants peut analyser des fichiers provenant de plusieurs buckets sources et les envoyer à des buckets distincts pour les fichiers sains 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 à suivre :

Créez des buckets Cloud Storage de fichiers non analysés, sains 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.

Si vous utilisez le déploiement Terraform, les étapes de cette section sont automatiquement appliquées lorsque vous transmettez votre fichier de configuration config.json mis à jour dans la variable de configuration Terraform TF_VAR_config_json.

Ignorer les fichiers temporaires

Certains services d'importation, tels que les passerelles SFTP vers Cloud Storage, créent un ou plusieurs fichiers temporaires pendant le processus d'importation. Ces services renomment ensuite ces fichiers avec le nom de fichier final une fois l'importation terminée.

Le comportement normal du scanner est d'analyser et de déplacer tous les fichiers, y compris ces fichiers temporaires, dès qu'ils sont écrits. Cela peut entraîner l'échec du service d'importation lorsqu'il ne trouve pas ses fichiers temporaires.

La section fileExclusionPatterns du fichier de configuration config.json vous permet d'utiliser des expressions régulières pour spécifier une liste de formats de noms de fichier à ignorer. Tous les fichiers correspondant à ces expressions régulières sont conservés dans le bucket unscanned.

Lorsque cette règle est déclenchée, le compteur ignored-files est incrémenté et un message est consigné pour indiquer que le fichier correspondant au modèle a été ignoré.

L'exemple de code suivant montre un fichier de configuration config.json avec la liste fileExclusionPatterns définie pour ignorer les fichiers se terminant par .tmp ou contenant la chaîne .partial_upload..

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

Soyez prudent lorsque vous utilisez des caractères \ dans l'expression régulière, car ils devront être échappés dans le fichier JSON avec un autre \. Par exemple, pour spécifier un . littéral dans une expression régulière, le symbole doit être échappé deux fois : une fois pour l'expression régulière et une fois pour le texte du fichier JSON. Il devient donc \\., comme dans la dernière ligne de l'exemple de code précédent.

Ignorer les fichiers de longueur nulle

Comme pour les fichiers temporaires, certains services d'importation créent un fichier de longueur nulle sur Cloud Storage, puis le mettent à jour ultérieurement avec plus de contenu.

Vous pouvez également ignorer ces fichiers en définissant le paramètre config.json ignoreZeroLengthFiles sur true, par exemple :

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

Lorsque cette règle est déclenchée, la métrique ignored-files est incrémentée et un message est consigné pour indiquer qu'un fichier de longueur nulle a été ignoré.

Taille maximale du fichier d'analyse

La taille maximale par défaut des fichiers d'analyse est de 500 Mio. Ce délai est choisi, car il faut environ cinq minutes pour analyser un fichier de cette taille.

Les fichiers de plus de 500 Mio sont ignorés et restent dans le bucket unscanned. La métrique files-ignored est incrémentée et un message est consigné.

Si vous devez augmenter cette limite, mettez à jour les limites suivantes pour qu'elles s'adaptent aux nouvelles valeurs maximales de taille de fichier et de durée d'analyse :

Le délai avant expiration des requêtes du service Cloud Run est de cinq minutes.
Le délai de confirmation des messages d'abonnement Pub/Sub est de cinq minutes.
Le code du scanner comporte une constante MAX_FILE_SIZE de 500 Mio.
La configuration du service ClamAV comporte des paramètres StreamMaxLength, MaxScanSize et MaxFileSize de 512 Mo. Ces paramètres sont définis par le script bootstrap.sh.

Effectuer un nettoyage

La section suivante explique comment éviter les frais futurs pour le projetGoogle 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 aura les effets suivants :

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.

Déployer la détection automatique des logiciels malveillants pour les fichiers importés dans Cloud Storage Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Architecture

Objectifs

Coûts

Avant de commencer

Déployer l'architecture

Déployer à l'aide de Cloud Shell

Préparer votre environnement

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

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

Créer un déclencheur Cloud Storage pour Eventarc

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

Déployer via la CLI Terraform

Cloner le dépôt GitHub

Préparer l'environnement

Déployer l'infrastructure de base

Créer le conteneur pour le service

Déployer le service et le déclencheur

Tester le pipeline en important des fichiers

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

Surveiller le service

Afficher les journaux détaillés

Afficher les métriques

Configuration avancée

Gérer plusieurs buckets

Ignorer les fichiers temporaires

Ignorer les fichiers de longueur nulle

Taille maximale du fichier d'analyse

Effectuer un nettoyage

Supprimer le projet Google Cloud

Étapes suivantes

Déployer la détection automatique des logiciels malveillants pour les fichiers importés dans Cloud Storage