1. Prérequis
Pour effectuer cet atelier de programmation, 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. 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 au téléchargement dans les archives JAR Lambda sur GitHub. Il doit être nommé LocalTestingTool_{version}.jar.
1.2. 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érification de la version de Java JRE à l'aide de `java --version`.
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.3. Télécharger le convertisseur de rapports agrégables (service d'agrégation et de tests en local)
Vous pouvez télécharger une copie du convertisseur de rapports agrégables à partir du dépôt GitHub des démos Privacy Sandbox.
1.4. Activer les API de confidentialité des annonces (service de test local et d'agrégation)
Dans votre navigateur, accédez à chrome://settings/adPrivacy et activez toutes les API de confidentialité des annonces.
Vérifiez que les cookies tiers sont activés.
Dans votre navigateur, accédez à chrome://settings/cookies, puis sélectionnez Bloquer les cookies tiers en mode navigation privée.
Paramètre Chrome pour les cookies tiers.
1.5. Inscription sur le Web et Android (service d'agrégation)
Pour utiliser les API Privacy Sandbox dans un environnement de production, assurez-vous d'avoir effectué l'inscription et l'attestation pour Chrome et Android.
Pour les tests locaux, l'enregistrement peut être désactivé à l'aide d'un flag Chrome et d'un commutateur CLI.
Pour utiliser le flag Chrome pour notre démonstration, accédez à chrome://flags/#privacy-sandbox-enrollment-overrides et mettez à jour le remplacement avec votre site. Si vous utilisez notre site de démonstration, aucune mise à jour n'est requise.
Indicateur Chrome pour remplacer l'inscription à la Privacy Sandbox.
1.6. Intégration 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 l'adresse de votre site de reporting, votre ID de compte AWS et d'autres informations.
1.7. Fournisseur de services cloud (service d'agrégation)
Le service d'agrégation nécessite l'utilisation d'un environnement d'exécution sécurisé qui utilise un environnement cloud. Le service d'agrégation est compatible avec Amazon Web Services (AWS) et Google Cloud (GCP). Cet atelier de programmation ne couvre que l'intégration d'AWS.
AWS fournit un environnement d'exécution sécurisé appelé Nitro Enclaves. Vérifiez que vous disposez d'un compte AWS, puis suivez les instructions d'installation et de mise à jour de la CLI AWS pour configurer votre environnement CLI AWS.
Si votre CLI AWS est nouvelle, vous pouvez la configurer à l'aide des instructions de configuration de la CLI.
1.7.1. Créer un bucket AWS S3
Créez un bucket AWS S3 pour stocker l'état Terraform, ainsi qu'un autre bucket S3 pour stocker vos rapports et rapports récapitulatifs. Vous pouvez utiliser la commande CLI fournie. Remplacez le champ dans <> par les variables appropriées.
aws s3api create-bucket --bucket <tf_bucket_name> --region us-east-1
aws s3api create-bucket --bucket <report_bucket_name> --region us-east-1
1.7.2. Créer une clé d'accès utilisateur
Créez des clés d'accès utilisateur à l'aide du guide AWS. Elle servira à appeler les points de terminaison d'API createJob et getJob créés sur AWS.
1.7.3. Autorisations des utilisateurs et des groupes AWS
Pour déployer le service d'agrégation sur AWS, vous devez accorder certaines autorisations à l'utilisateur utilisé pour déployer le service. Pour cet atelier de programmation, vérifiez que l'utilisateur dispose d'un accès administrateur afin de vous assurer qu'il dispose de toutes les autorisations nécessaires pour le déploiement.
1.8. Terraform (service d'agrégation)
Cet atelier de programmation utilise Terraform pour déployer le service d'agrégation. Vérifiez que le binaire Terraform est installé dans votre environnement local.
Téléchargez le binaire Terraform dans votre environnement local.
Une fois le fichier binaire Terraform téléchargé, extrayez-le et déplacez-le dans /usr/local/bin.
cp <directory>/terraform /usr/local/bin
Vérifiez que Terraform est disponible dans le classpath.
terraform -v
1.9. Postman (pour le service d'agrégation AWS)
Pour cet atelier de programmation, utilisez Postman pour gérer les requêtes.
Pour créer un espace de travail, accédez à l'élément de navigation supérieur Espaces de travail, puis sélectionnez Créer un espace de travail.
Espace de travail Postman
Sélectionnez Espace de travail vide, cliquez sur "Suivant", puis nommez-le Privacy Sandbox. Sélectionnez Personnel, puis cliquez sur Créer.
Téléchargez les fichiers de configuration JSON et d'environnement global de l'espace de travail préconfiguré.
Importez les fichiers JSON dans Mon espace de travail à l'aide du bouton Importer.
Importez des fichiers JSON Postman.
Cela créera la collection Privacy Sandbox pour vous, ainsi que les requêtes HTTP createJob et getJob.
Collection Postman importée.
Mettez à jour la clé d'accès et la clé secrète AWS dans Aperçu rapide de l'environnement.
Aperçu rapide de l'environnement Postman.
Cliquez sur Modifier et mettez à jour la "Valeur actuelle" de access_key et secret_key. Notez que frontend_api_id sera fourni dans la section 3.1.4 de ce document. Nous vous conseillons d'utiliser la région us-east-1. Toutefois, si vous souhaitez déployer dans une autre région, vérifiez que vous copiez l'AMI publiée dans votre compte ou effectuez une compilation manuelle à l'aide des scripts fournis.
Variables globales Postman. 
Modifier les variables globales dans Postman.
2. Atelier de programmation sur les tests en local
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.
É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 agrégable de débogage : convertissez le rapport JSON collecté en rapport au format AVRO.
Cette étape sera semblable à celle où les ad techs collectent les rapports à partir des points de terminaison de l'API et convertissent les rapports JSON au format AVRO.
Étape 2.3 : Analysez la clé du bucket à partir du rapport de débogage : 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éez le fichier AVRO du domaine de sortie : une fois les clés du bucket récupérées, créez le fichier AVRO du domaine de sortie.
Étape 2.5 : Créez des rapports récapitulatifs à l'aide de l'outil de test en local : utilisez l'outil de test en local pour créer des rapports récapitulatifs dans l'environnement local.
Étape 2.6 : Examinez le rapport récapitulatif : consultez le rapport récapitulatif créé par l'outil de test local.
2.1. Rapport sur les déclencheurs
Accédez au site de démonstration de la Privacy Sandbox. Cela déclenche un rapport d'agrégation privée. Vous pouvez consulter le rapport sur chrome://private-aggregation-internals.
Informations internes sur l'agrégation privée de Chrome.
Si votre rapport est en état En attente, vous pouvez le sélectionner et cliquer sur Envoyer les rapports sélectionnés.
Envoyez un rapport d'agrégation privé.
2.2. Créer un rapport agrégable de débogage
Dans chrome://private-aggregation-internals, copiez le corps du rapport reçu dans le point de terminaison [reporting-origin]/.well-known/private-aggregation/report-shared-storage.
Assurez-vous que dans le corps du rapport, aggregation_coordinator_origin contient https://publickeyservice.msmt.aws.privacysandboxservices.com, ce qui signifie que le rapport est un rapport AWS agrégable.
Rapport d'agrégation privée.
Placez le corps du rapport JSON dans un fichier JSON. Dans cet exemple, vous pouvez utiliser vim. Mais vous pouvez utiliser l'éditeur de texte de votre choix.
vim report.json
Collez le rapport dans report.json et enregistrez votre fichier.
Fichier JSON du rapport.
Une fois que vous l'avez, accédez au dossier de vos rapports 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 \
--debug
2.3. Analyser la clé du bucket à partir du rapport de débogage
Le service d'agrégation nécessite deux fichiers lors du traitement par lot. Le rapport agrégable et le fichier de domaine de sortie. Le fichier de domaine de sortie contient les clés que vous souhaitez récupérer à partir des rapports agrégables. 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 l'appelant de l'API, et la démonstration contient des exemples de clés de bucket préconstruits. Étant donné que le mode débogage est activé pour l'agrégation privée dans la démo, vous pouvez analyser la charge utile en texte brut de débogage à partir de Corps du rapport pour récupérer la clé du bucket. Toutefois, dans ce cas, le site de démonstration 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, vous pouvez utiliser debug_cleartext_payload à partir de Corps du rapport pour obtenir la clé du bucket.
Copiez l'ID debug_cleartext_payload à partir du corps du rapport.
Déboguer la charge utile en texte brut à partir du corps du rapport.
Ouvrez l'outil Décodeur de charge utile de débogage pour l'agrégation privée, collez votre debug_cleartext_payload dans la zone INPUT (ENTRÉE), puis cliquez sur Decode (Décoder).
Décodeur de charge utile.
La page renvoie la valeur décimale de la clé du bucket. Voici un exemple de clé de bucket.
Résultat du décodage de la charge utile.
2.4. Créer le fichier AVRO du domaine de sortie
Maintenant que nous avons la clé du bucket, copiez la valeur décimale de la clé du bucket. Créez ensuite le output_domain.avro à l'aide de la clé du bucket. Veillez à remplacer
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 la section 1.1 pour créer les rapports récapitulatifs. Exécutez la commande suivante. Vous devez remplacer LocalTestingTool_{version}.jar par la version téléchargée pour LocalTestingTool.
Exécutez la commande suivante pour générer un rapport récapitulatif dans votre environnement de développement local :
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, une image semblable à celle ci-dessous devrait s'afficher. Un rapport output.avro est créé une fois cette opération terminée.
Fichier Avro du rapport récapitulatif des tests locaux.
2.6. Examiner 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, les technologies publicitaires devraient coder pour reconvertir les rapports AVRO au format JSON.
Pour cet atelier de programmation, nous utiliserons l'outil aggregatable_report_converter.jar fourni 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 de l'image ci-dessous s'affiche. ainsi qu'un rapport output.json créé dans le même répertoire.
Fichier Avro récapitulatif converti au format JSON.
Ouvrez le fichier JSON dans l'éditeur de votre choix pour consulter le rapport récapitulatif.
3. Déploiement du service d'agrégation
Pour déployer le service d'agrégation, procédez comme suit :
Étape 3 : Déploiement du service d'agrégation : déployer le service d'agrégation sur AWS
Étape 3.1 Cloner le dépôt du service d'agrégation
Étape 3.2 Télécharger les dépendances prédéfinies
Étape 3.3 Créer un environnement de développement
Étape 3.4 Déployer le service d'agrégation
3.1. Cloner le dépôt du service d'agrégation
Dans votre environnement local, clonez le dépôt GitHub du service d'agrégation.
git clone https://github.com/privacysandbox/aggregation-service.git
3.2. Télécharger les dépendances précompilées
Une fois que vous avez cloné le dépôt Aggregation Service, accédez au dossier Terraform du dépôt et au dossier cloud correspondant. Si votre cloud_provider est AWS, vous pouvez passer à
cd <repository_root>/terraform/aws
Dans download_prebuilt_dependencies.sh.
bash download_prebuilt_dependencies.sh
3.3. Créer un environnement de développement
Créez un environnement de développement dans dev.
mkdir dev
Copiez le contenu du dossier demo dans le dossier dev.
cp -R demo/* dev
Accédez à votre dossier dev.
cd dev
Mettez à jour votre fichier main.tf et appuyez sur i pour input afin de modifier le fichier.
vim main.tf
Annulez la mise en commentaire du code dans l'encadré rouge en supprimant le # et en mettant à jour les noms du bucket et de la clé.
Pour AWS main.tf :
Fichier tf principal AWS.
Le code sans commentaire doit se présenter comme suit.
backend "s3" {
bucket = "<tf_state_bucket_name>"
key = "<environment_name>.tfstate"
region = "us-east-1"
}
Une fois les modifications effectuées, enregistrez-les et quittez l'éditeur en appuyant sur esc > :wq!. Les modifications sont ainsi enregistrées sur main.tf.
Ensuite, renommez example.auto.tfvars en dev.auto.tfvars.
mv example.auto.tfvars dev.auto.tfvars
Mettez à jour dev.auto.tfvars et appuyez sur i pour input afin de modifier le fichier.
vim dev.auto.tfvars
Mettez à jour les champs de la zone rouge de l'image ci-dessous avec les paramètres AWS ARN corrects fournis lors de l'intégration du service d'agrégation, de l'environnement et de l'adresse e-mail de notification.
Modifiez le fichier tfvars de développement automatique.
Une fois les mises à jour effectuées, appuyez sur esc > :wq!. Le fichier dev.auto.tfvars est alors enregistré. Il devrait ressembler à l'image suivante.
Fichier tfvars de développement automatique mis à jour.
3.4. Déployer le service d'agrégation
Pour déployer Aggregation Service, initialisez Terraform dans le même dossier
terraform init
Un résultat semblable à celui de l'image suivante devrait s'afficher :
Terraform init.
Une fois Terraform initialisé, créez le plan d'exécution Terraform. Il renvoie le nombre de ressources à ajouter et d'autres informations supplémentaires, comme dans l'image ci-dessous.
terraform plan
Vous pouvez consulter le récapitulatif du forfait ci-dessous. S'il s'agit d'un nouveau déploiement, vous devriez voir le nombre de ressources qui seront ajoutées, avec 0 à modifier et 0 à détruire.
Plan Terraform.
Une fois cette étape terminée, vous pouvez appliquer Terraform.
terraform apply
Lorsque Terraform vous invite à confirmer l'exécution des actions, saisissez yes dans la valeur.
Invite "terraform apply".
Une fois terraform apply terminé, les points de terminaison suivants pour createJob et getJob sont renvoyés. Le frontend_api_id que vous devez mettre à jour dans Postman dans la section 1.9 est également renvoyé.
L'application Terraform est terminée.
4. Créer des entrées Aggregation Service
Créez les rapports AVRO pour le traitement par lot dans le service d'agrégation.
Étape 4 : 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 4.1 Rapport sur les déclencheurs
Étape 4.2 Collecter des rapports agrégables
Étape 4.3 Convertir les rapports au format AVRO
Étape 4.4 Créer le fichier AVRO du domaine de sortie
4.1. Rapport sur les déclencheurs
Accédez au site de démonstration de la Privacy Sandbox. Cela déclenche un rapport d'agrégation privée. Vous pouvez consulter le rapport sur chrome://private-aggregation-internals.
Informations internes sur l'agrégation privée de Chrome.
Si votre rapport est en état En attente, vous pouvez le sélectionner et cliquer sur Envoyer les rapports sélectionnés. '
Envoyez un rapport d'agrégation privé.
4.2. Collecter des 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, vous allez collecter les rapports manuellement. En production, les technologies publicitaires sont censées collecter et convertir les rapports de manière programmatique.
Dans chrome://private-aggregation-internals, copiez le corps du rapport reçu dans le point de terminaison [reporting-origin]/.well-known/private-aggregation/report-shared-storage.
Assurez-vous que dans le corps du rapport, aggregation_coordinator_origin contient https://publickeyservice.msmt.aws.privacysandboxservices.com, ce qui signifie que le rapport est un rapport AWS agrégable.
Rapport d'agrégation privée.
Placez le corps du rapport JSON dans un fichier JSON. Dans cet exemple, vous pouvez utiliser vim. Mais vous pouvez utiliser l'éditeur de texte de votre choix.
vim report.json
Collez le rapport dans report.json et enregistrez votre fichier.
Fichier JSON du rapport.
4.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 au dossier de vos rapports 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
4.4. Créer le fichier AVRO du domaine de sortie
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, la démonstration de la Privacy Sandbox du site crée les clés de bucket. Étant donné que l'agrégation privée pour ce site est en mode débogage, vous pouvez utiliser debug_cleartext_payload à partir de 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 brut à partir du corps du rapport.
Ouvrez goo.gle/ags-payload-decoder, collez votre debug_cleartext_payload dans la zone INPUT (ENTRÉE), puis cliquez sur Decode (Décoder).
Décodeur de charge utile.
La page renvoie la valeur décimale de la clé du bucket. Voici un exemple de clé de bucket.
Résultat du décodage de la charge utile.
Maintenant que nous avons la clé du bucket, créons le output_domain.avro. Veillez à remplacer
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.
4.5. Déplacer des rapports vers un bucket AWS
Une fois les rapports AVRO (de la section 3.2.3) et le domaine de sortie (de la section 3.2.4) créés, déplacez-les dans les buckets S3 de reporting.
Si vous avez configuré l'interface de ligne de commande AWS dans votre environnement local, utilisez les commandes suivantes pour copier les rapports dans le bucket S3 et le dossier de rapports correspondants.
aws s3 cp report.avro s3://<report_bucket_name>/<report_folder>/
aws s3 cp output_domain.avro s3://<report_bucket_name>/<output_domain_folder>/
5. Utilisation du service d'agrégation
À partir du terraform apply, vous recevez le create_job_endpoint, le get_job_endpoint et le frontend_api_id. Copiez le frontend_api_id et placez-le dans la variable globale Postman frontend_api_id que vous avez configurée dans la section 1.9 des prérequis.
Étape 5 : Utilisation du service d'agrégation : utilisez l'API Aggregation Service pour créer et examiner des rapports récapitulatifs.
Étape 5.1 Utiliser le point de terminaison createJob pour le traitement par lot
Étape 5.2 Utiliser le point de terminaison getJob pour récupérer l'état du lot
Étape 5.3 Examiner le rapport récapitulatif
5.1. Utiliser le point de terminaison createJob pour le traitement par lot
Dans Postman, ouvrez la collection Privacy Sandbox et sélectionnez createJob.
Sélectionnez Body (Corps), puis raw (brut) pour placer la charge utile de votre requête.
postman createJob request body
Le schéma de charge utile createJob est disponible sur GitHub et ressemble à ce qui suit. Remplacez <> par les champs appropriés.
{
"job_request_id": "<job_request_id>",
"input_data_blob_prefix": "<report_folder>/<report_name>.avro",
"input_data_blob_prefixes": [
"<report_folder>/<report_name-1>/",
"<report_folder>/<report_name-2>/",
"<report_folder>/<report_name>.avro"
], // Mutually exclusive to input_data_blob_prefix as of v2.11.0
"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"
}
}
Une fois que vous avez cliqué sur Envoyer, le job est créé avec le job_request_id. 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 retour possibles sont disponibles dans Codes de réponse HTTP.
État de la demande Postman createJob
5.2. Utiliser le point de terminaison getJob pour récupérer l'état du lot
Pour vérifier l'état de la demande de tâche, vous pouvez utiliser le point de terminaison getJob. Sélectionnez getJob dans la collection Privacy Sandbox.
Dans "Params", remplacez la valeur job_request_id par le job_request_id envoyé dans la requête createJob.
postman getJob request
Le résultat de getJob 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 getJob request status
Étant donné que le site de reporting du rapport de démonstration généré est différent du site intégré à votre ID AWS, vous pouvez recevoir une réponse avec le code de retour PRIVACY_BUDGET_AUTHORIZATION_ERROR. Cela est normal, car le site d'origine des rapports ne correspond pas au site de reporting intégré pour l'ID AWS.
{
"job_status": "FINISHED",
"request_received_at": "2023-12-07T22:50:58.830956Z",
"request_updated_at": "2023-12-07T22:51:10.526326456Z",
"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": "<input_bucket_name>",
"output_data_blob_prefix": "<output_folder>/<summary_report_prefix>",
"output_data_bucket_name": "<output_bucket_name>",
"postback_url": "",
"result_info": {
"return_code": "PRIVACY_BUDGET_AUTHORIZATION_ERROR",
"return_message": "Aggregation job successfully processed",
"error_summary": {
"error_counts": [],
"error_messages": []
},
"finished_at": "2023-12-07T22:51:10.517730898Z"
},
"job_parameters": {
"debug_run": "true",
"output_domain_bucket_name": "<output_domain_bucket_name>",
"output_domain_blob_prefix": "<output_domain_folder>/<output_domain>.avro",
"attribution_report_to": "https://privacy-sandbox-demos-dsp.dev",
"reporting_site": "<domain of reporting origin(s) of report>", // Mutually exclusive to attribution_report_to as of v2.7.0
},
"request_processing_started_at": "2023-12-07T22:51:06.034472697Z"
}
5.3. Examiner le rapport récapitulatif
Une fois que vous avez reçu votre rapport récapitulatif dans votre bucket S3 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 suivante.
java -jar aggregatable_report_converter.jar \
--request_type convertToJson \
--input_file <summary_report_avro>
Cela renvoie un JSON des valeurs agrégées de chaque clé de bucket, qui ressemble à l'image suivante.
Rapport récapitulatif.
Si votre demande createJob inclut debug_run en tant que 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 en 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 à l'image suivante.
Rapport récapitulatif de débogage.
Les annotations contiennent également in_reports et in_domain, 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.