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

1. 1. Conditions préalables

Temps estimé pour terminer: 1 à 2 heures

Il existe deux modes pour effectuer cet atelier de programmation: les tests en local ou le service d'agrégation. Le mode de test en local nécessite un ordinateur local et un navigateur Chrome (aucune création ni utilisation de ressources Google Cloud). Le mode de 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 les deux modes, vous devez remplir quelques prérequis. Chaque exigence est indiquée en conséquence, qu'elle soit requise pour les tests en local ou pour le service d'agrégation.

1.1. Inscription terminée et attestation (service d'agrégation)

Pour utiliser les API Privacy Sandbox, assurez-vous d'avoir suivi la procédure d'inscription et d'attestation pour Chrome et Android.

1.2. Activer les API Privacy Sandbox (service de tests et d'agrégation en local)

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

Dans votre navigateur, accédez à chrome://flags/#privacy-sandbox-ads-apis et activez les API Privacy Sandbox.

Assurez-vous également que les cookies tiers sont activés.

Dans votre navigateur, accédez à chrome://settings/cookies. Assurez-vous que les cookies tiers ne sont PAS bloqués. Selon la version de Chrome que vous utilisez, différentes options peuvent s'afficher dans ce menu des paramètres, mais les configurations acceptées sont les suivantes:

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

Vous devrez relancer Chrome pour que cette modification soit prise en compte.

1.3. Télécharger l'outil de test en local (test en 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 en local est disponible en téléchargement dans les archives JAR Cloud Functions dans GitHub. Il doit être nommé LocalTestingTool_{version}.jar.

1.4. Assurez-vous que JAVA JRE est installé (service de tests et d'agrégation en local)

Ouvrez Terminal et utilisez java --version pour vérifier si Java ou openJDK est installé sur votre ordinateur.

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

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

Vous pouvez télécharger une copie de aggregatable_report_converter à partir du dépôt GitHub de démonstrations de la Privacy Sandbox.

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

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

1.6.1. Déploiement

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

Remarque importante: Vous aurez besoin de certaines autorisations pour déployer le service. Pour cet atelier de programmation, assurez-vous que l'utilisateur dispose d'un accès administrateur / propriétaire sur le projet GCP.

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

1. Configurer la CLI "gcloud" et Terraform dans votre environnement
2. Créer 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 voir un exemple de fichier adtech_setup.auto.tfvars.
5. Mettez à jour dev.auto.tfvars, empruntez l'identité du compte de service de déploiement et exécutez le Terraform dev. Consultez l'annexe pour voir un exemple de fichier dev.auto.tfvars.
6. Une fois le déploiement terminé, capturez la valeur frontend_service_cloudfunction_url à partir de la sortie Terraform, qui sera nécessaire pour envoyer des requêtes au service d'agrégation lors des prochaines étapes.

1.6.2. Ensemble de rapports

Une fois le projet configuré, vous créerez un bucket dans Cloud Storage pour stocker les rapports agrégables et les rapports récapitulatifs de cet atelier de programmation. Voici un exemple de commande gcloud permettant de créer un bucket. Remplacez les espaces réservés par le nom et l'emplacement de votre choix.

gcloud storage buckets create gs://<bucket-name> --location=<location>

1,7. Intégration complète du service d'agrégation (service d'agrégation)

Le service d'agrégation nécessite l'intégration des coordinateurs pour qu'ils puissent l'utiliser. Remplissez le formulaire d'intégration pour le service d'agrégation en fournissant votre site de signalement et d'autres informations, en sélectionnant "Google Cloud" et en saisissant l'adresse de votre compte de service. Ce compte de service a été créé à l'étape précédente (1.6. "Configurer un environnement GCP"). Remarque: 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 la 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 à partir de 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 des requêtes API en vue d'une utilisation ultérieure.

Section 3.2. d'agrégation Service Usage, vous trouverez des instructions détaillées sur l'utilisation de ces deux options. 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 que vous êtes inscrit, un espace de travail est automatiquement créé pour vous.

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

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

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

Importez les deux fichiers JSON dans "My Workspace" (Mon espace de travail) à l'aide du bouton "Import" (Importer).

La collection "GCP Privacy Sandbox" sera créée 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".

Vous utiliserez la méthode "Bearer Token" (Jeton de support). 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:

1.8.3. Configurer l'environnement

Accédez à l'aperçu rapide de l'environnement dans l'angle supérieur droit:

Cliquez sur "Modifier", puis mettez à jour la valeur actuelle des champs "environment", "region" et "cloud-function-id":

Vous pouvez laisser le champ "request-id" vide pour le moment, car nous le renseignerons plus tard. Pour les autres champs, utilisez les valeurs de l'frontend_service_cloudfunction_url, qui vous a été renvoyé après avoir terminé le déploiement Terraform dans la condition 1.6. L'URL respecte le format suivant: https://--frontend-service--uc.a.run.app

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

Temps estimé pour terminer : moins de 1 heure

Vous pouvez utiliser l'outil de test en local de votre ordinateur pour effectuer des agrégations et générer des rapports récapitulatifs à l'aide des rapports de débogage non chiffrés. Avant de commencer, assurez-vous d'avoir rempli toutes les conditions préalables portant la mention "Tests en local".

Étapes de l'atelier de programmation

Étape 2.1. Générer un rapport: permet de déclencher la création de rapports Private Aggregation afin de pouvoir collecter le rapport.

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

Étape 2.3 : Récupérer les clés de bucket: les clés de bucket sont conçues par des adTechs. 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 vous ont été 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 du domaine de sortie.

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

Étape 2.6 : Consulter les rapports récapitulatifs: consultez 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é, vous pouvez utiliser le site de démonstration de la 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é les étapes d'inscription et d'attestation ainsi que d'intégration du service d'agrégation, vous devez utiliser un indicateur Chrome et un bouton bascule dans la CLI.

Pour cette démonstration, nous allons utiliser le site de démonstration de la Privacy Sandbox. Cliquez sur ce lien pour accéder au site. Vous pouvez ensuite consulter les rapports à l'adresse chrome://private-aggregation-internals:

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

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

Remarque: Si vous ne voyez pas de rapport de débogage comme celui présenté ci-dessus, actualisez la page de démonstration de la Privacy Sandbox, puis la page des composants internes de Chrome. Vous devriez voir plus de rapports, dont un généré par le point de terminaison de débogage. Si ce n'est pas le cas, vérifiez que les cookies tiers sont activés.

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

Copiez le rapport qui se trouve dans le champ "Report Body" (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é à la version 1.5 des prérequis).

Dans cet exemple, nous utilisons Vim puisque nous utilisons Linux. Mais vous pouvez utiliser n'importe quel éditeur de texte.

vim report.json

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

Ensuite, utilisez aggregatable_report_converter.jar pour créer le rapport de débogage agrégable. Un rapport agrégable appelé report.avro est alors créé 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 du rapport

Pour créer le fichier output_domain.avro, vous avez besoin des clés de bucket pouvant être extraites des rapports.

Les clés de bucket sont conçues par l'adTech. Toutefois, dans ce cas, le site Démonstration de la Privacy Sandbox crée les clés de bucket. Étant donné que l'agrégation privée pour ce site est en mode débogage, nous pouvons utiliser l'élément debug_cleartext_payload dans le corps du rapport pour obtenir la clé du bucket.

Copiez debug_cleartext_payload à partir du corps du rapport.

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

La page renvoie la valeur décimale de la clé du bucket. Vous trouverez ci-dessous un exemple de clé de bucket.

2.4. Créer l'AVRO du domaine de sortie

Maintenant que nous disposons de la clé de bucket, nous allons créer le fichier output_domain.avro dans le dossier dans lequel nous avons travaillé. Veillez à remplacer 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 en local

Nous allons utiliser LocalTestingTool_{version}.jar, que nous avons téléchargé dans les conditions préalables 1.3, pour créer les rapports récapitulatifs à l'aide de la commande ci-dessous. 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 d'accès relatif pour référencer 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 aux lignes ci-dessous doit s'afficher. Un rapport output.avro est créé une fois l'opération terminée.

2.6. Consulter le rapport récapitulatif

Le rapport récapitulatif créé est au format AVRO. Pour qu'il soit lisible, vous devez convertir le fichier AVRO au format JSON. Idéalement, l'adTech devrait é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

Un rapport semblable à celui-ci s'affiche. En plus du rapport output.json créé dans le même répertoire

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

Temps estimé pour terminer: 1 heure

Avant de commencer, assurez-vous d'avoir rempli toutes les conditions préalables portant la mention "Service d'agrégation".

Étapes de l'atelier de programmation

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

• Étape 3.1.1 : Rapport sur les déclencheurs
• Étape 3.1.2 : Collecter des rapports agrégables
• Étape 3.1.3 : Convertir les rapports au format AVRO
• Étape 3.1.4 : Créer une 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 du service d'agrégation pour créer des rapports de synthèse et les consulter.

• Étape 3.2.1 : Utiliser le point de terminaison createJob pour effectuer des 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éation d'une entrée du service d'agrégation

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

3.1.1. Rapport sur les déclencheurs

Cliquez sur ce lien pour accéder au site. Vous pouvez ensuite consulter les rapports à l'adresse chrome://private-aggregation-internals:

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

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

Remarque: Si vous ne voyez pas de rapport de débogage comme celui présenté ci-dessus, actualisez la page de démonstration de la Privacy Sandbox, puis la page des composants internes de Chrome. Vous devriez voir plus de rapports, dont un généré par le point de terminaison de débogage. Si ce n'est pas le cas, vérifiez que les cookies tiers sont activés.

3.1.2. Collecter des rapports agrégables

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

• Agrégation privée: {reporting-origin}/.well-known/private-aggregation/report-shared-storage
• Attribution Reporting - Rapport récapitulatif: {reporting-origin}/.well-known/attribution-reporting/report-aggregate-attribution

Dans cet atelier de programmation, nous allons collecter des rapports manuellement. En production, les technologies publicitaires doivent collecter et convertir les rapports de manière programmatique.

Copions le rapport JSON dans "Report Body" (Corps du rapport) à partir de chrome://private-aggregation-internals.

Dans cet exemple, nous utilisons Vim puisque nous utilisons Linux. Mais vous pouvez utiliser n'importe quel éditeur de texte.

vim report.json

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

3.1.3. Convertir les rapports au format AVRO

Les rapports provenant des points de terminaison .well-known sont au format JSON et doivent être convertis au format de rapport AVRO. Une fois que vous disposez du rapport JSON, accédez à l'emplacement où report.json est stocké et utilisez aggregatable_report_converter.jar pour créer le rapport de débogage agrégable. Un rapport agrégable appelé report.avro est alors créé dans votre répertoire actuel.

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

3.1.4. Créer une AVRO "output_domain"

Pour créer le fichier output_domain.avro, vous avez besoin des clés de bucket pouvant être extraites des rapports.

Les clés de bucket sont conçues par l'adTech. Toutefois, dans ce cas, le site Démonstration de la Privacy Sandbox crée les clés de bucket. Étant donné que l'agrégation privée pour ce site est en mode débogage, nous pouvons utiliser l'élément debug_cleartext_payload dans le corps du rapport pour obtenir la clé du bucket.

Copiez debug_cleartext_payload à partir du corps du rapport.

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

La page renvoie la valeur décimale de la clé du bucket. Vous trouverez ci-dessous un exemple de clé de bucket.

Maintenant que nous disposons de la clé de bucket, nous allons créer le fichier output_domain.avro dans le dossier dans lequel nous avons travaillé. Veillez à remplacer 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.

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 créé lors de la dernière étape de la condition 1.6).

Si la gcloud CLI est configurée dans votre environnement local, utilisez les commandes ci-dessous 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 appelé "reports" et importez-y le fichier report.avro. Créez un dossier nommé "output_domains" et importez-y le fichier output_domain.avro.

3.2. Utilisation du service d'agrégation

Rappelez-vous dans la version 1.8 de la condition préalable que vous aviez sélectionné cURL ou Postman pour envoyer des requêtes API aux points de terminaison du service d'agrégation. Vous trouverez ci-dessous les instructions pour les deux options.

3.2.1. Utiliser le point de terminaison createJob pour effectuer des lots

Utilisez les instructions cURL ou Postman ci-dessous pour créer une tâche.

cURL

Dans votre terminal, créez un fichier de corps de requête (body.json) et collez-y le code ci-dessous. Veillez à mettre à jour les valeurs des espaces réservés. Consultez cette documentation de l'API pour en savoir plus sur ce que chaque champ représente.

Remarque: attribution_report_to est l'origine, également appelée "Site de création de rapports de technologie publicitaire", qui a été intégrée lors de l'intégration du service d'agrégation (condition 1.7).

{
  "job_request_id": "<job_request_id>",
  "input_data_blob_prefix": "<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>",
    "report_error_threshold_percentage": "10",
    "debug_run": "true"
  }
}

Exécutez la requête ci-dessous. Remplacez les espaces réservés dans l'URL de la requête cURL par les valeurs de frontend_service_cloudfunction_url, qui s'affiche une fois le déploiement Terraform terminé avec succès (voir la condition 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 la requête acceptée par le service d'agrégation. Les autres codes de réponse possibles sont décrits dans les spécifications de l'API.

Facteur

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 fichier des rapports agrégables, des domaines de sortie et des rapports récapitulatifs.

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

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.

Remarque: attribution_report_to est l'origine, également appelée "Site de création de rapports de technologie publicitaire", qui a été intégrée lors de l'intégration du service d'agrégation (condition 1.7).

{
  "job_request_id": "<job_request_id>",
  "input_data_blob_prefix": "<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>",
    "report_error_threshold_percentage": "10",
    "debug_run": "true"
  }
}

Envoyez la requête API createJob:

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

Vous devriez recevoir une réponse HTTP 202 une fois la requête acceptée par le service d'agrégation. Les autres codes de réponse possibles sont décrits 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 les instructions cURL ou Postman ci-dessous pour obtenir un emploi.

cURL

Exécutez la requête ci-dessous dans votre terminal. Remplacez les espaces réservés dans l'URL par les valeurs de frontend_service_cloudfunction_url, qui est la même URL que vous avez 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 requête de tâche avec un état HTTP de 200. Le "corps" de la requête contient les informations nécessaires telles que job_status, return_message et error_messages (si la tâche comporte une erreur).

Remarque: Le rapport que nous utilisons pour cet atelier de programmation est associé à l'origine du rapport du site de démonstration de la Privacy Sandbox. Toutefois, lorsque vous avez intégré le service d'agrégation dans votre environnement GCP, vous avez fourni votre propre origine de création de rapports. Comme le rapport provient d'un site différent de celui qui a été intégré, vous pouvez recevoir une réponse avec return_code PRIVACY_BUDGET_AUTHORIZATION_ERROR. Ce comportement est normal et peut être ignoré.

Facteur

Pour vérifier l'état de la requête de tâche, vous pouvez utiliser le point de terminaison getJob. Dans la section "Paramètres" de la requête getJob, remplacez la valeur job_request_id par le job_request_id envoyé dans la requête createJob.

"Envoyez" la requête getJob:

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

Remarque: Le rapport que nous utilisons pour cet atelier de programmation est associé à l'origine du rapport du site de démonstration de la Privacy Sandbox. Toutefois, lorsque vous avez intégré le service d'agrégation dans votre environnement GCP, vous avez fourni votre propre origine de création de rapports. Comme le rapport provient d'un site différent de celui qui a été intégré, vous pouvez recevoir une réponse avec return_code PRIVACY_BUDGET_AUTHORIZATION_ERROR. Ce comportement est normal et peut être ignoré.

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 la commande ci-dessous.

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

Cette commande renvoie un fichier JSON contenant les valeurs agrégées de chaque clé de bucket, semblable à ce qui suit.

Si votre requête createJob inclut debug_run avec la valeur "true", vous pouvez recevoir votre rapport récapitulatif dans le dossier de débogage situé sous output_data_blob_prefix. Le rapport est au format AVRO et peut être converti au format JSON à l'aide de la commande ci-dessus.

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 est semblable à celui-ci :

Les annotations contiennent également "in_reports" et/ou "in_domain", ce qui signifie que:

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

4. 4. Effectuer un nettoyage

Pour supprimer les ressources créées pour le service d'agrégation via Terraform, utilisez la commande de destruction dans les dossiers adtech_setup et dev (ou tout 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 récapitulatifs, procédez comme suit:

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

Vous pouvez également choisir de rétablir les paramètres des cookies Chrome de la version 1.2 de la condition préalable 1.2 à leur état précédent.

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:[e-mail]"]

# 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 = "[e-mail]"

min_worker_instances = 1
max_worker_instances = 20