1. 1. Prérequis
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 de confidentialité des annonces (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://settings/adPrivacy et activez toutes les API de confidentialité des annonces.
Assurez-vous également que les cookies tiers sont activés.
À partir du 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É
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. Le dépôt GitHub mentionne l'utilisation d'IntelliJ ou d'Eclipse, mais aucun 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 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.
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.
Étapes clés des instructions de déploiement:
- Configurer la commande "gcloud" la CLI et Terraform dans votre environnement.
- Créer un bucket Cloud Storage pour stocker l'état Terraform
- Téléchargez les dépendances.
- Mettez à jour
adtech_setup.auto.tfvarset exécutez le Terraformadtech_setup. Consultez l'annexe pour voir un exemple de fichieradtech_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 créons. - Mettez à jour
dev.auto.tfvars, empruntez l'identité du compte de service de déploiement et exécutez le Terraformdev. Consultez l'annexe pour voir un exemple de fichierdev.auto.tfvars. - 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,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'a été créé automatiquement, accédez à "Espaces de travail" en haut de l'écran et 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" puis cliquez sur "Créer".
Téléchargez la configuration JSON et les fichiers d'environnement global de l'espace de travail préconfigurés.
Importer les deux fichiers JSON dans "Mon espace de travail" via l'option "Importer" .
La Privacy Sandbox de GCP sera créée pour vous, ainsi que les requêtes HTTP createJob et getJob.
1.8.2. Configurer les autorisations
Cliquez sur la Privacy Sandbox de GCP et accédez à la section "Authorization" .
Vous utiliserez le 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 dans le champ de l'onglet d'autorisation Postman:
1.8.3. Configurer l'environnement
Accédez à l'aperçu rapide de l'environnement. en haut à droite:
Cliquez sur "Modifier". et mettez à jour la valeur actuelle "environment", "region" et "cloud-function-id" :
Vous pouvez laisser
« request-id » vide pour l'instant, car nous
le remplirons plus tard. Pour les autres champs, utilisez les valeurs du 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://
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é l'inscription et Pour intégrer les services d'attestation et d'agrégation, vous devez utiliser un indicateur Chrome et un commutateur 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. Ensuite, vous pouvez 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 des rapports affichés sur la page interne 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. L'URL du rapport contiendra "/debug/" et l'attribut aggregation_coordinator_origin field du "corps du rapport" contiendra cette URL: https://publickeyservice.msmt.gcp.privacysandboxservices.com.
2.2. Créer un rapport de débogage agrégable
Copiez le rapport qui se trouve 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 les conditions préalables 1.5).
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'debug_cleartext_payload du "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 "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
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 en local, vous pouvez effectuer le même exercice en déployant le service d'agrégation en direct dans votre propre environnement. Passez en revue les conditions préalables afin de vous assurer que vous avez tout configuré pour le "service d'agrégation". puis passez à l'étape 3.
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
createJobpour effectuer des lots - Étape 3.2.2 : Utiliser le point de terminaison
getJobpour 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. Ensuite, vous pouvez 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 des rapports affichés sur la page interne 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. L'URL du rapport contiendra "/debug/" et l'attribut aggregation_coordinator_origin field du "corps du rapport" contiendra cette URL: https://publickeyservice.msmt.gcp.privacysandboxservices.com.
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" 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'debug_cleartext_payload du "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 "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 (comme vous l'avez noté à la section 1.6 dans les conditions préalables).
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éer un dossier appelé "rapports" et importez-y le fichier report.avro. Créer un dossier appelé "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.
Si votre job échoue avec une erreur, consultez notre documentation de dépannage dans GitHub pour savoir comment procéder.
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.
{
"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>",
"reporting_site": "<domain of reporting origin(s) of report>", // Only one of attribution_report_to or reporting_site is required as of v2.7.0
"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.
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 fichier des rapports agrégables, des domaines de sortie et des rapports récapitulatifs.
Accéder au "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.
{
"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>",
"reporting_site": "<domain of reporting origin(s) of report>", // Only one of attribution_report_to or reporting_site is required as of v2.7.0
"report_error_threshold_percentage": "10",
"debug_run": "true"
}
}
"Envoyer" 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 le job a généré une erreur).
Postman
Pour vérifier l'état de la requête de tâche, vous pouvez utiliser le point de terminaison getJob. Dans la boîte de dialogue "Paramètres", de la requête getJob, remplacez la valeur job_request_id par l'job_request_id envoyé dans la requête createJob.
"Envoyer" 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 le job a généré une erreur).
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.
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.
É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 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: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