Utiliser le service d'agrégation sur Google Cloud Platform (GCP)

1. 1. Prérequis

Durée estimée : 1 à 2 heures

Vous pouvez suivre cet atelier de programmation de deux façons : test local ou service d'agrégation. Le mode de test local nécessite une machine locale et le navigateur Chrome (aucune création ni utilisation de ressources Google Cloud). Le mode Service d'agrégation nécessite un déploiement complet du service d'agrégation sur Google Cloud.

Pour suivre cet atelier de programmation dans l'un ou l'autre mode, vous devez remplir quelques conditions préalables. Chaque exigence est marquée en conséquence, qu'elle soit requise pour les tests locaux ou le service d'agrégation.

1.1. Finaliser l'inscription et l'attestation (service d'agrégation)

Pour utiliser les API Privacy Sandbox, vérifiez que vous avez effectué l'inscription et l'attestation pour Chrome et Android.

1.2. Activer les API de confidentialité des annonces (service de test local et d'agrégation)

Étant donné que nous allons utiliser la Privacy Sandbox, nous vous encourageons à activer les API Privacy Sandbox Ads.

Dans votre navigateur, accédez à chrome://settings/adPrivacy et activez toutes les API de confidentialité des annonces.

Vérifiez également que vos cookies tiers sont activés.

Dans chrome://settings/cookies, assurez-vous que les cookies tiers ne sont PAS bloqués. Selon votre version de Chrome, différentes options peuvent s'afficher dans ce menu de paramètres. Voici quelques configurations acceptables :

• "Bloquer tous les cookies tiers" = DÉSACTIVÉ
• "Bloquer les cookies tiers" = DÉSACTIVÉ
• "Bloquer les cookies tiers en mode navigation privée" = ACTIVÉ

 Activer les cookies

1.3. Télécharger l'outil de test local

Pour effectuer des tests en local, vous devrez télécharger l'outil de test en local. L'outil génère des rapports récapitulatifs à partir des rapports de débogage non chiffrés.

L'outil de test local est disponible en téléchargement dans les archives JAR Cloud Functions sur GitHub. Il doit être nommé LocalTestingTool_{version}.jar.

1.4. Vérifier que JAVA JRE est installé (service de test et d'agrégation local)

Ouvrez Terminal et utilisez java --version pour vérifier si Java ou openJDK sont installés sur votre machine.

 Vérifiez la version de Java.

Si ce n'est pas le cas, vous pouvez le télécharger et l'installer depuis le site Java ou le site openJDK.

1.5. Télécharger aggregatable_report_converter (service de test et d'agrégation local)

Vous pouvez télécharger une copie de aggregatable_report_converter à partir du dépôt GitHub des démos Privacy Sandbox. Le dépôt GitHub mentionne l'utilisation d'IntelliJ ou d'Eclipse, mais aucun des deux n'est obligatoire. Si vous n'utilisez pas ces outils, téléchargez plutôt le fichier JAR dans votre environnement local.

1.6. Configurer un environnement Cloud Platform (service d'agrégation)

Le service d'agrégation nécessite l'utilisation d'un environnement d'exécution sécurisé qui utilise un fournisseur de services cloud. Dans cet atelier de programmation, le service d'agrégation sera déployé dans Google Cloud, mais AWS est également compatible.

Suivez les instructions de déploiement sur GitHub pour configurer la gcloud CLI, télécharger les binaires et les modules Terraform, et créer des ressources Google Cloud pour le service d'agrégation.

Étapes clés des instructions de déploiement :

1. Configurez la gcloud CLI et Terraform dans votre environnement.
2. Créez un bucket Cloud Storage pour stocker l'état Terraform.
3. Téléchargez les dépendances.
4. Mettez à jour adtech_setup.auto.tfvars et exécutez le Terraform adtech_setup. Consultez l'annexe pour obtenir un exemple de fichier adtech_setup.auto.tfvars. Notez le nom du bucket de données créé ici. Il sera utilisé dans l'atelier de programmation pour stocker les fichiers que nous allons créer.
5. Mettez à jour dev.auto.tfvars, empruntez l'identité du compte de service de déploiement et exécutez le dev Terraform. Consultez l'annexe pour obtenir un exemple de fichier dev.auto.tfvars.
6. Une fois le déploiement terminé, capturez frontend_service_cloudfunction_url à partir de la sortie Terraform. Vous en aurez besoin pour envoyer des requêtes au service d'agrégation lors des étapes suivantes.

1.7. Intégration complète du service d'agrégation (Aggregation Service)

Le service d'agrégation nécessite l'intégration aux coordinateurs pour pouvoir être utilisé. Remplissez le formulaire d'intégration au service d'agrégation en fournissant votre site de reporting et d'autres informations, en sélectionnant "Google Cloud" et en saisissant l'adresse de votre compte de service. Ce compte de service est créé dans le prérequis précédent (1.6. Configurer un environnement Google Cloud). (Conseil : si vous utilisez les noms par défaut fournis, ce compte de service commencera par "worker-sa@".)

Le processus d'intégration peut prendre jusqu'à deux semaines.

1.8. Déterminer votre méthode d'appel des points de terminaison de l'API (service d'agrégation)

Cet atelier de programmation propose deux options pour appeler les points de terminaison de l'API Aggregation Service : cURL et Postman. cURL est le moyen le plus rapide et le plus simple d'appeler les points de terminaison de l'API depuis votre terminal, car il nécessite une configuration minimale et aucun logiciel supplémentaire. Toutefois, si vous ne souhaitez pas utiliser cURL, vous pouvez utiliser Postman pour exécuter et enregistrer les requêtes API pour une utilisation ultérieure.

Dans la section 3.2. Vous trouverez des instructions détaillées sur l'utilisation des deux options dans la section "Utilisation d'Aggregation Service". Vous pouvez les prévisualiser maintenant pour déterminer la méthode que vous allez utiliser. Si vous sélectionnez Postman, effectuez la configuration initiale suivante.

1.8.1. Configurer l'espace de travail

Créez un compte Postman. Une fois inscrit, un espace de travail est automatiquement créé pour vous.

Un espace de travail Postman.

Si aucun espace de travail n'est créé pour vous, accédez à l'élément de navigation "Espaces de travail" en haut de la page, puis sélectionnez "Créer un espace de travail".

Sélectionnez "Espace de travail vide", cliquez sur "Suivant", puis nommez-le "GCP Privacy Sandbox". Sélectionnez "Personnel", puis cliquez sur "Créer".

Téléchargez la configuration JSON et les fichiers d'environnement global de l'espace de travail préconfiguré.

Importez les deux fichiers JSON dans "Mon espace de travail" à l'aide du bouton "Importer".

  Bouton "Importer".

Cela créera la collection "GCP Privacy Sandbox" pour vous, ainsi que les requêtes HTTP createJob et getJob.

1.8.2. Configurer les autorisations

Cliquez sur la collection "GCP Privacy Sandbox" et accédez à l'onglet "Authorization" (Autorisation).

Bouton d'autorisation.

Vous utiliserez la méthode "Jeton du porteur". Depuis votre environnement de terminal, exécutez cette commande et copiez le résultat.

gcloud auth print-identity-token

Collez ensuite cette valeur de jeton dans le champ "Token" (Jeton) de l'onglet d'autorisation Postman :

Champ "Jeton".

1.8.3. Configurer l'environnement

Accédez à "Aperçu rapide de l'environnement" en haut à droite :

Bouton d'aperçu rapide de l'environnement.

Cliquez sur "Modifier" et mettez à jour la "Valeur actuelle" de "environment", "region" et "cloud-function-id" :

 : définissez les valeurs actuelles.

Vous pouvez laisser le champ "request-id" vide pour le moment, car nous le remplirons plus tard. Pour les autres champs, utilisez les valeurs de frontend_service_cloudfunction_url, qui ont été renvoyées à la fin du déploiement Terraform dans le prérequis 1.6. L'URL est au format suivant : https://--frontend-service--uc.a.run.app

2. 2. Atelier de programmation sur les tests en local

Durée estimée : moins d'une heure

Vous pouvez utiliser l'outil de test local sur votre ordinateur pour effectuer l'agrégation et générer des rapports récapitulatifs à l'aide des rapports de débogage non chiffrés. Avant de commencer, vérifiez que vous avez rempli toutes les conditions préalables portant la mention "Test local".

Étapes de l'atelier de programmation

Étape 2.1 : Générer un rapport : générez un rapport Private Aggregation pour pouvoir le collecter.

Étape 2.2 : Créer un rapport AVRO de débogage : convertissez le rapport JSON collecté en rapport au format AVRO. Cette étape sera semblable à celle où les technologies publicitaires collectent les rapports à partir des points de terminaison de l'API et convertissent les rapports JSON au format AVRO.

Étape 2.3 : Récupérez les clés de bucket : les clés de bucket sont conçues par les technologies publicitaires. Dans cet atelier de programmation, étant donné que les buckets sont prédéfinis, récupérez les clés de bucket telles qu'elles sont fournies.

Étape 2.4 : Créer un fichier AVRO de domaine de sortie : une fois les clés de bucket récupérées, créez le fichier AVRO de domaine de sortie.

Étape 2.5 : Créer un rapport récapitulatif : utilisez l'outil de test en local pour créer des rapports récapitulatifs dans l'environnement local.

Étape 2.6 : Consultez les rapports récapitulatifs : examinez le rapport récapitulatif créé par l'outil de test en local.

2.1. Rapport sur les déclencheurs

Pour déclencher un rapport d'agrégation privée, vous pouvez utiliser le site de démonstration Privacy Sandbox (https://privacy-sandbox-demos-news.dev/?env=gcp) ou votre propre site (par exemple, https://adtechexample.com). Si vous utilisez votre propre site et que vous n'avez pas terminé l'inscription, l'attestation et l'intégration du service d'agrégation, vous devrez utiliser un flag Chrome et un commutateur CLI.

Pour cette démonstration, nous allons utiliser le site de démonstration Privacy Sandbox. Suivez le lien pour accéder au site, puis consultez les rapports sur chrome://private-aggregation-internals :

Page "À propos" de Chrome.

Le rapport envoyé au point de terminaison {reporting-origin}/.well-known/private-aggregation/debug/report-shared-storage se trouve également dans le corps des rapports affichés sur la page "Chrome Internals".

Vous verrez peut-être de nombreux rapports ici, mais pour cet atelier de programmation, utilisez le rapport agrégable spécifique à Google Cloud et généré par le point de terminaison de débogage. L'URL du rapport contiendra "/debug/" et le aggregation_coordinator_origin field du corps du rapport contiendra cette URL : https://publickeyservice.msmt.gcp.privacysandboxservices.com.

Rapport de débogage Google Cloud.

2.2. Créer un rapport agrégable de débogage

Copiez le rapport figurant dans le "corps du rapport" de chrome://private-aggregation-internals et créez un fichier JSON dans le dossier privacy-sandbox-demos/tools/aggregatable_report_converter/out/artifacts/aggregatable_report_converter_jar (dans le dépôt téléchargé dans le prérequis 1.5).

Dans cet exemple, nous utilisons vim, car nous utilisons Linux. Mais vous pouvez utiliser l'éditeur de texte de votre choix.

vim report.json

Collez le rapport dans report.json et enregistrez votre fichier.

 : code JSON du rapport.

Une fois que vous l'avez, utilisez aggregatable_report_converter.jar pour créer le rapport agrégable de débogage. Cela crée un rapport agrégable nommé report.avro dans votre répertoire actuel.

java -jar aggregatable_report_converter.jar \
  --request_type convertToAvro \
  --input_file report.json \
  --debug

2.3. Récupérer la clé de bucket à partir du rapport

Pour créer le fichier output_domain.avro, vous avez besoin des clés de bucket qui peuvent être récupérées à partir des rapports.

Les clés de bucket sont conçues par la technologie publicitaire. Toutefois, dans ce cas, le site Privacy Sandbox Demo crée les clés de bucket. Comme l'agrégation privée pour ce site est en mode débogage, nous pouvons utiliser debug_cleartext_payload à partir du corps du rapport pour obtenir la clé du bucket.

Copiez l'debug_cleartext_payload dans le corps du rapport.

Déboguer la charge utile en texte clair.

Ouvrez goo.gle/ags-payload-decoder, collez votre debug_cleartext_payload dans la zone "INPUT" (ENTRÉE), puis cliquez sur "Decode" (Décoder).

 Bouton "Décoder".

La page renvoie la valeur décimale de la clé du bucket. Voici un exemple de clé de bucket.

Exemple de clé de bucket.

2.4. Créer un fichier AVRO de domaine de sortie

Maintenant que nous avons la clé du bucket, créons le fichier output_domain.avro dans le même dossier dans lequel nous avons travaillé. Vérifiez que vous remplacez la clé du bucket par celle que vous avez récupérée.

java -jar aggregatable_report_converter.jar \
  --request_type createDomainAvro \
  --bucket_key <bucket key>

Le script crée le fichier output_domain.avro dans votre dossier actuel.

2.5. Créer des rapports récapitulatifs à l'aide de l'outil de test local

Nous utiliserons LocalTestingTool_{version}.jar téléchargé dans le prérequis 1.3 pour créer les rapports récapitulatifs à l'aide de la commande suivante. Remplacez {version} par la version que vous avez téléchargée. N'oubliez pas de déplacer LocalTestingTool_{version}.jar vers le répertoire actuel ou d'ajouter un chemin relatif pour faire référence à son emplacement actuel.

java -jar LocalTestingTool_{version}.jar \
  --input_data_avro_file report.avro \
  --domain_avro_file output_domain.avro \
  --output_directory .

Une fois la commande exécutée, un résultat semblable à celui-ci devrait s'afficher. Un rapport output.avro est créé une fois cette opération terminée.

 : sortie AVRO

2.6. Consulter le rapport récapitulatif

Le rapport récapitulatif créé est au format AVRO. Pour pouvoir le lire, vous devez le convertir d'AVRO au format JSON. Dans l'idéal, l'ad tech doit écrire du code pour reconvertir les rapports AVRO au format JSON.

Nous utiliserons aggregatable_report_converter.jar pour reconvertir le rapport AVRO au format JSON.

java -jar aggregatable_report_converter.jar \
  --request_type convertToJson \
  --input_file output.avro

Vous obtiendrez un rapport semblable à celui-ci. ainsi qu'un rapport output.json créé dans le même répertoire.

Sortie JSON

Atelier de programmation terminé !

Résumé : Vous avez collecté un rapport de débogage, créé un fichier de domaine de sortie et généré un rapport récapitulatif à l'aide de l'outil de test local qui simule le comportement d'agrégation du service d'agrégation.

Étapes suivantes : Maintenant que vous avez testé l'outil de test local, vous pouvez essayer le même exercice avec un déploiement en direct du service d'agrégation dans votre propre environnement. Repassez en revue les conditions préalables pour vous assurer d'avoir tout configuré pour le mode "Service d'agrégation", puis passez à l'étape 3.

3. 3. Atelier de programmation sur le service d'agrégation

Durée estimée : 1 heure

Avant de commencer, vérifiez que vous avez rempli toutes les conditions préalables portant le libellé "Service d'agrégation".

Étapes de l'atelier de programmation

Étape 3.1 : Création des entrées du service d'agrégation : créez les rapports du service d'agrégation qui sont regroupés par lots pour le service d'agrégation.

• Étape 3.1.1 : Rapport sur les déclencheurs
• Étape 3.1.2 : Collecter les rapports agrégables
• Étape 3.1.3 : Convertir des rapports au format AVRO
• Étape 3.1.4 : Créer un AVRO output_domain
• Étape 3.1.5 : Déplacer des rapports vers un bucket Cloud Storage

Étape 3.2 : Utilisation du service d'agrégation : utilisez l'API Aggregation Service pour créer et examiner des rapports récapitulatifs.

• Étape 3.2.1 : Utiliser le point de terminaison createJob pour les lots
• Étape 3.2.2 : Utiliser le point de terminaison getJob pour récupérer l'état du lot
• Étape 3.2.3 : Examiner le rapport récapitulatif

3.1. Créer des entrées pour le service d'agrégation

Créez les rapports AVRO pour le traitement par lot dans le service d'agrégation. Les commandes shell de ces étapes peuvent être exécutées dans Cloud Shell de Google Cloud (à condition que les dépendances des prérequis soient clonées dans votre environnement Cloud Shell) ou dans un environnement d'exécution local.

3.1.1. Rapport sur les déclencheurs

Suivez le lien pour accéder au site, puis consultez les rapports sur chrome://private-aggregation-internals :

Page "À propos" de Chrome

Le rapport envoyé au point de terminaison {reporting-origin}/.well-known/private-aggregation/debug/report-shared-storage se trouve également dans le corps des rapports affichés sur la page "Chrome Internals".

Vous verrez peut-être de nombreux rapports ici, mais pour cet atelier de programmation, utilisez le rapport agrégable spécifique à Google Cloud et généré par le point de terminaison de débogage. L'URL du rapport contiendra "/debug/" et le aggregation_coordinator_origin field du corps du rapport contiendra cette URL : https://publickeyservice.msmt.gcp.privacysandboxservices.com.

Rapport de débogage Google Cloud.

3.1.2. Collecter les rapports agrégables

Collectez vos rapports agrégables à partir des points de terminaison .well-known de l'API correspondante.

• Private Aggregation : {reporting-origin}/.well-known/private-aggregation/report-shared-storage
• Attribution Reporting – Rapport récapitulatif : {reporting-origin}/.well-known/attribution-reporting/report-aggregate-attribution

Pour cet atelier de programmation, nous collectons les rapports manuellement. En production, les technologies publicitaires sont censées collecter et convertir les rapports de manière programmatique.

Copions le rapport JSON dans le corps du rapport à partir de chrome://private-aggregation-internals.

Dans cet exemple, nous utilisons vim, car nous utilisons Linux. Mais vous pouvez utiliser l'éditeur de texte de votre choix.

vim report.json

Collez le rapport dans report.json et enregistrez votre fichier.

 Rapport JSON

3.1.3. Convertir des rapports au format AVRO

Les rapports reçus à partir des points de terminaison .well-known sont au format JSON et doivent être convertis au format AVRO. Une fois que vous avez le rapport JSON, accédez à l'emplacement où report.json est stocké et utilisez aggregatable_report_converter.jar pour créer le rapport agrégable de débogage. Cela crée un rapport agrégable nommé report.avro dans votre répertoire actuel.

java -jar aggregatable_report_converter.jar \
  --request_type convertToAvro \
  --input_file report.json

3.1.4. Créer un AVRO output_domain

Pour créer le fichier output_domain.avro, vous avez besoin des clés de bucket qui peuvent être récupérées à partir des rapports.

Les clés de bucket sont conçues par la technologie publicitaire. Toutefois, dans ce cas, le site Privacy Sandbox Demo crée les clés de bucket. Comme l'agrégation privée pour ce site est en mode débogage, nous pouvons utiliser debug_cleartext_payload à partir du corps du rapport pour obtenir la clé du bucket.

Copiez l'debug_cleartext_payload dans le corps du rapport.

Déboguer la charge utile en texte clair.

Ouvrez goo.gle/ags-payload-decoder, collez votre debug_cleartext_payload dans la zone "INPUT" (ENTRÉE), puis cliquez sur "Decode" (Décoder).

 Bouton "Décoder".

La page renvoie la valeur décimale de la clé du bucket. Voici un exemple de clé de bucket.

Exemple de clé de bucket.

Maintenant que nous avons la clé du bucket, créons le fichier output_domain.avro dans le même dossier dans lequel nous avons travaillé. Vérifiez que vous remplacez la clé du bucket par celle que vous avez récupérée.

java -jar aggregatable_report_converter.jar \
  --request_type createDomainAvro \
  --bucket_key <bucket key>

Le script crée le fichier output_domain.avro dans votre dossier actuel.

3.1.5. Déplacer des rapports vers un bucket Cloud Storage

Une fois les rapports AVRO et le domaine de sortie créés, déplacez-les dans le bucket Cloud Storage (que vous avez noté dans le prérequis 1.6).

Si vous avez configuré la gcloud CLI dans votre environnement local, utilisez les commandes suivantes pour copier les fichiers dans les dossiers correspondants.

gcloud storage cp report.avro gs://<bucket_name>/reports/

gcloud storage cp output_domain.avro gs://<bucket_name>/output_domain/

Sinon, importez manuellement les fichiers dans votre bucket. Créez un dossier nommé "reports" et importez-y le fichier report.avro. Créez un dossier appelé "output_domains" et importez-y le fichier output_domain.avro.

3.2. Utilisation du service d'agrégation

Rappelez-vous que dans le prérequis 1.8, vous avez sélectionné curl ou Postman pour effectuer des requêtes d'API vers les points de terminaison du service d'agrégation. Les instructions pour les deux options sont fournies ci-dessous.

Si votre job échoue et génère une erreur, consultez notre documentation de dépannage sur GitHub pour savoir comment procéder.

3.2.1. Utiliser le point de terminaison createJob pour les lots

Utilisez les instructions curl ou Postman suivantes pour créer un job.

curl

Dans votre terminal, créez un fichier de corps de requête (body.json) et collez-y l'objet JSON suivant. Veillez à modifier les valeurs des espaces réservés. Pour en savoir plus sur la signification de chaque champ, consultez la documentation de l'API.

{
    "job_request_id": "<job_request_id>",
    "input_data_blob_prefix": "<report_folder>/<report_name>.avro",
    "input_data_blob_prefixes": [ // Mutually exclusive to input_data_blob_prefix as of v2.11.0
      "<report_folder>/<report_name-1>/",
      "<report_folder>/<report_name-2>/",
      "<report_folder>/<report_name>.avro"
    ],
    "input_data_bucket_name": "<bucket_name>",
    "output_data_blob_prefix": "<output_folder>/<summary_report_prefix>",
    "output_data_bucket_name": "<bucket_name>",
    "job_parameters": {
      "output_domain_blob_prefix": "<output_domain_folder>/<output_domain>.avro",
      "output_domain_bucket_name": "<bucket_name>",
      "attribution_report_to": "<reporting origin of report>",
      "reporting_site": "<domain of reporting origin(s) of report>", // Mutually exclusive to attribution_report_to as of v2.7.0
      "report_error_threshold_percentage": "10",
      "debug_run": "true"
    }
}

Exécutez la requête suivante. Remplacez les espaces réservés dans l'URL de la requête curl par les valeurs de frontend_service_cloudfunction_url, qui sont générées une fois le déploiement Terraform terminé (prérequis 1.6).

curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
  -d @body.json \
  https://<environment>-<region>-frontend-service-<cloud-function-id>-uc.a.run.app/v1alpha/createJob

Vous devriez recevoir une réponse HTTP 202 une fois que la requête aura été acceptée par le service d'agrégation. D'autres codes de réponse possibles sont documentés dans les spécifications de l'API.

Postman

Pour le point de terminaison createJob, un corps de requête est requis afin de fournir au service d'agrégation l'emplacement et les noms de fichiers des rapports agrégables, des domaines de sortie et des rapports récapitulatifs.

Accédez à l'onglet "Body" (Corps) de la requête createJob :

 onglet "Corps"

Remplacez les espaces réservés dans le fichier JSON fourni. Pour en savoir plus sur ces champs et ce qu'ils représentent, consultez la documentation de l'API.

{
    "job_request_id": "<job_request_id>",
    "input_data_blob_prefix": "<report_folder>/",
    "input_data_blob_prefixes": [ // Mutually exclusive to input_data_blob_prefix as of v2.11.0
      "<report_folder>/<report_name-1>/",
      "<report_folder>/<report_name-2>/",
      "<report_folder>/<report_name>.avro"
    ],
    "input_data_bucket_name": "<bucket_name>",
    "output_data_blob_prefix": "<output_folder>/<summary_report_prefix>",
    "output_data_bucket_name": "<bucket_name>",
    "job_parameters": {
      "output_domain_blob_prefix": "<output_domain_folder>/<output_domain>.avro",
      "output_domain_bucket_name": "<bucket_name>",
      "attribution_report_to": "<reporting origin of report>",
      "reporting_site": "<domain of reporting origin(s) of report>", // Mutually exclusive to attribution_report_to as of v2.7.0
      "report_error_threshold_percentage": "10",
      "debug_run": "true"
    }
}

Envoyez la requête d'API createJob :

  Bouton "Envoyer"

Le code de réponse se trouve dans la moitié inférieure de la page :

Code de réponse

Vous devriez recevoir une réponse HTTP 202 une fois que la requête aura été acceptée par le service d'agrégation. D'autres codes de réponse possibles sont documentés dans les spécifications de l'API.

3.2.2. Utiliser le point de terminaison getJob pour récupérer l'état du lot

Utilisez l'une des instructions curl ou Postman suivantes pour obtenir un job.

curl

Exécutez la requête suivante dans votre terminal. Remplacez les espaces réservés de l'URL par les valeurs de frontend_service_cloudfunction_url, qui est la même URL que celle utilisée pour la requête createJob. Pour "job_request_id", utilisez la valeur de la tâche que vous avez créée avec le point de terminaison createJob.

curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
  https://<environment>-<region>-frontend-service-<cloud-function-id>-uc.a.run.app/v1alpha/getJob?job_request_id=<job_request_id>

Le résultat doit renvoyer l'état de votre demande de tâche avec un état HTTP 200. Le "corps" de la requête contient les informations nécessaires, telles que job_status, return_message et error_messages (si le job a échoué).

Postman

Pour vérifier l'état de la demande de tâche, vous pouvez utiliser le point de terminaison getJob. Dans la section "Params" de la requête getJob, remplacez la valeur job_request_id par celle qui a été envoyée dans la requête createJob.job_request_id

 ID de la demande de job

Envoyez la demande getJob :

  Bouton "Envoyer"

Le résultat doit renvoyer l'état de votre demande de tâche avec un état HTTP 200. Le "corps" de la requête contient les informations nécessaires, telles que job_status, return_message et error_messages (si le job a échoué).

Réponse JSON

3.2.3. Examiner le rapport récapitulatif

Une fois que vous avez reçu votre rapport récapitulatif dans votre bucket Cloud Storage de sortie, vous pouvez le télécharger dans votre environnement local. Les rapports récapitulatifs sont au format AVRO et peuvent être reconvertis au format JSON. Vous pouvez utiliser aggregatable_report_converter.jar pour lire votre rapport à l'aide de cette commande.

java -jar aggregatable_report_converter.jar \
  --request_type convertToJson \
  --input_file <summary_report_avro>

L'opération renvoie un fichier JSON contenant les valeurs agrégées de chaque clé de bucket, qui ressemble à ce qui suit.

Rapport récapitulatif.

Si votre demande createJob inclut debug_run comme valeur "true", vous pouvez recevoir votre rapport récapitulatif dans le dossier de débogage situé dans output_data_blob_prefix. Le rapport est au format AVRO et peut être converti au format JSON à l'aide de la commande précédente.

Le rapport contient la clé du bucket, la métrique sans bruit et le bruit ajouté à la métrique sans bruit pour former le rapport récapitulatif. Le rapport ressemble à ce qui suit.

Rapport sur le bruit

Les annotations contiennent également "in_reports" ou "in_domain" (ou les deux), ce qui signifie :

• in_reports : la clé de bucket est disponible dans les rapports agrégables.
• in_domain : la clé du bucket est disponible dans le fichier AVRO output_domain.

Atelier de programmation terminé !

Résumé : Vous avez déployé le service d'agrégation dans votre propre environnement cloud, collecté un rapport de débogage, créé un fichier de domaine de sortie, stocké ces fichiers dans un bucket Cloud Storage et exécuté une tâche avec succès.

Étapes suivantes : Continuez à utiliser le service d'agrégation dans votre environnement ou supprimez les ressources cloud que vous venez de créer en suivant les instructions de nettoyage de l'étape 4.

4. 4. Effectuer un nettoyage

Pour supprimer les ressources créées pour le service d'agrégation à l'aide de Terraform, utilisez la commande destroy dans les dossiers adtech_setup et dev (ou dans un autre environnement) :

$ cd <repository_root>/terraform/gcp/environments/adtech_setup
$ terraform destroy
$ cd <repository_root>/terraform/gcp/environments/dev
$ terraform destroy

Pour supprimer le bucket Cloud Storage contenant vos rapports agrégables et vos rapports récapitulatifs :

$ gcloud storage buckets delete gs://my-bucket

Vous pouvez également choisir de rétablir les paramètres de cookies de Chrome à leur état précédent (voir le prérequis 1.2).

5. 5. Annexe

Fichier adtech_setup.auto.tfvars d'exemple

/**
 * Copyright 2023 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

project = "my-project-id"

# Required to generate identity token for access of Adtech Services API endpoints
service_account_token_creator_list = ["user:me@email.com"]

# Uncomment the below line if you like Terraform to create an Artifact registry repository
# for self-build container artifacts. "artifact_repo_location" defaults to "us".
artifact_repo_name     = "my-ags-artifacts"

# Note: Either one of [1] or [2] must be uncommented.

# [1] Uncomment below lines if you like Terraform grant needed permissions to
# pre-existing service accounts
# deploy_service_account_email = "<YourDeployServiceAccountName>@<ProjectID>.iam.gserviceaccount.com"
# worker_service_account_email = "<YourWorkerServiceAccountName>@<ProjectID>.iam.gserviceaccount.com"

# [2] Uncomment below lines if you like Terraform to create service accounts
# and needed permissions granted e.g "deploy-sa" or "worker-sa"
deploy_service_account_name = "deploy-sa"
worker_service_account_name = "worker-sa"
# Uncomment the below line if you want Terraform to create the
# below bucket. "data_bucket_location" defaults to "us".
data_bucket_name     = "my-ags-data"

# Uncomment the below lines if you want to specify service account customer role names
# deploy_sa_role_name = "<YourDeploySACustomRole>"
# worker_sa_role_name = "<YourWorkerSACustomRole>"

Fichier dev.auto.tfvars d'exemple

/**
 * Copyright 2022 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

# Example values required by job_service.tf
#
# These values should be modified for each of your environments.
region      = "us-central1"
region_zone = "us-central1-c"

project_id  = "my-project-id"
environment = "operator-demo-env"

# Co-locate your Cloud Spanner instance configuration with the region above.
# https://cloud.google.com/spanner/docs/instance-configurations#regional-configurations
spanner_instance_config = "regional-us-central1"

# Adjust this based on the job load you expect for your deployment.
# Monitor the spanner instance utilization to decide on scale out / scale in.
# https://console.cloud.google.com/spanner/instances
spanner_processing_units = 100

# Uncomment the line below at your own risk to disable Spanner database protection.
# This needs to be set to false and applied before destroying all resources is possible.
spanner_database_deletion_protection = false

instance_type = "n2d-standard-8" # 8 cores, 32GiB

# Container image location that packages the job service application
# If not set otherwise, uncomment and edit the line below:
#worker_image = "<location>/<project>/<repository>/<image>:<tag or digest>"

# Service account created and onboarded for worker
user_provided_worker_sa_email = "worker-sa@my-project-id.iam.gserviceaccount.com"

min_worker_instances = 1
max_worker_instances = 20