1. Prerequisiti
Per eseguire questo codelab, sono necessari alcuni prerequisiti. Ogni requisito è contrassegnato di conseguenza, a seconda che sia necessario per il "test locale" o per il "servizio di aggregazione".
1.1. Scarica lo strumento di test locale (test locale)
Per il test locale è necessario scaricare lo strumento di test locale. Lo strumento genererà report di riepilogo dai report di debug non criptati.
Lo strumento di test locale è disponibile per il download negli archivi JAR Lambda in GitHub. Deve essere denominato LocalTestingTool_{version}.jar.
1.2. Verifica che JAVA JRE sia installato (servizio di test e aggregazione locale)
Apri "Terminale" e utilizza java --version per verificare se sulla tua macchina è installato Java o openJDK.
Controllo della versione di Java JRE utilizzando `java --version`.
Se non è installato, puoi scaricarlo e installarlo dal sito Java o dal sito openJDK.
1.3. Scaricare Aggregatable Report Converter (test locali e servizio di aggregazione)
Puoi scaricare una copia del convertitore di report aggregabili dal repository GitHub di Privacy Sandbox Demos.
1.4. Abilitare le API per la privacy degli annunci (test locali e servizio di aggregazione)
Nel browser, vai a chrome://settings/adPrivacy e attiva tutte le API per la privacy degli annunci.
Verifica che i cookie di terze parti siano attivi.
Nel browser, vai su chrome://settings/cookies e seleziona "Blocca i cookie di terze parti in modalità di navigazione in incognito".
Impostazione dei cookie di terze parti di Chrome.
1.5. Registrazione su web e Android (servizio di aggregazione)
Per utilizzare le API Privacy Sandbox in un ambiente di produzione, assicurati di aver completato la registrazione e l'attestazione sia per Chrome che per Android.
Per i test locali, la registrazione può essere disabilitata utilizzando un flag di Chrome e un'opzione dell'interfaccia a riga di comando.
Per utilizzare il flag di Chrome per la nostra demo, vai a chrome://flags/#privacy-sandbox-enrollment-overrides e aggiorna l'override con il tuo sito. Se utilizzerai il nostro sito demo, non è necessario alcun aggiornamento.
Flag di Chrome per l'override della registrazione a Privacy Sandbox.
1.6. Onboarding del servizio di aggregazione (servizio di aggregazione)
Per poter utilizzare il servizio di aggregazione, è necessario eseguire l'onboarding dei coordinatori. Compila il modulo di onboarding del servizio di aggregazione fornendo l'indirizzo del sito di generazione dei report, l'ID account AWS e altre informazioni.
1.7. Cloud provider (servizio di aggregazione)
Il servizio di aggregazione richiede l'utilizzo di un Trusted Execution Environment che utilizza un ambiente cloud. Il servizio di aggregazione è supportato su Amazon Web Services (AWS) e Google Cloud (GCP). Questo codelab tratterà solo l'integrazione di AWS.
AWS fornisce un Trusted Execution Environment chiamato Nitro Enclaves. Verifica di avere un account AWS e segui le istruzioni di installazione e aggiornamento dell'interfaccia a riga di comando AWS per configurare l'ambiente dell'interfaccia a riga di comando AWS.
Se la tua AWS CLI è nuova, puoi configurarla utilizzando le istruzioni di configurazione della CLI.
1.7.1. Crea un bucket AWS S3
Crea un bucket AWS S3 per archiviare lo stato di Terraform e un altro bucket S3 per archiviare i report e i report di riepilogo. Puoi utilizzare il comando CLI fornito. Sostituisci il campo in <> con le variabili appropriate.
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. Crea chiave di accesso utente
Crea chiavi di accesso utente utilizzando la guida AWS. Verrà utilizzato per chiamare gli endpoint API createJob e getJob creati su AWS.
1.7.3. Autorizzazioni di utenti e gruppi AWS
Per eseguire il deployment del servizio di aggregazione su AWS, devi fornire determinate autorizzazioni all'utente utilizzato per il deployment del servizio. Per questo Codelab, verifica che l'utente disponga dell'accesso amministrativo per assicurarti di disporre delle autorizzazioni complete per l'implementazione.
1.8. Terraform (servizio di aggregazione)
Questo Codelab utilizza Terraform per eseguire il deployment del servizio di aggregazione. Verifica che il file binario di Terraform sia installato nell'ambiente locale.
Scarica il file binario Terraform nel tuo ambiente locale.
Una volta scaricato il file binario Terraform, estrailo e sposta il file binario Terraform in /usr/local/bin.
cp <directory>/terraform /usr/local/bin
Verifica che Terraform sia disponibile nel classpath.
terraform -v
1.9. Postman (per il servizio di aggregazione AWS)
Per questo Codelab, utilizza Postman per la gestione delle richieste.
Crea uno spazio di lavoro andando alla voce di navigazione in alto "Spazi di lavoro" e selezionando "Crea spazio di lavoro".
Workspace Postman
Seleziona "Area di lavoro vuota", fai clic su Avanti e assegna il nome "Privacy Sandbox". Seleziona "Personale" e fai clic su "Crea".
Scarica i file JSON configuration e Global Environment dell'area di lavoro preconfigurata.
Importa i file JSON in "Il mio spazio di lavoro" utilizzando il pulsante "Importa".
Importa i file JSON di Postman.
Verrà creata la raccolta Privacy Sandbox insieme alle richieste HTTP createJob e getJob.
Raccolta Postman importata.
Aggiorna "Chiave di accesso" e "Chiave segreta" di AWS tramite "Panoramica rapida dell'ambiente".
Panoramica rapida dell'ambiente Postman.
Fai clic su "Modifica" e aggiorna il "Valore attuale" di "access_key" e "secret_key". Tieni presente che frontend_api_id verrà fornito nella sezione 3.1.4 di questo documento. Inoltre, ti consigliamo di utilizzare la regione us-east-1. Tuttavia, se vuoi eseguire il deployment in un'altra regione, verifica di copiare l'AMI rilasciata nel tuo account o esegui una compilazione automatica utilizzando gli script forniti.
Variabili globali di Postman. 
Modifica le variabili globali di Postman.
2. Codelab per i test locali
Puoi utilizzare lo strumento di test locale sulla tua macchina per eseguire l'aggregazione e generare report di riepilogo utilizzando i report di debug non criptati.
Passaggi del codelab
Passaggio 2.1. Attiva report: attiva la generazione di report Private Aggregation per poter raccogliere il report.
Passaggio 2.2. Crea report aggregabile di debug: converti il report JSON raccolto in un report formattato AVRO.
Questo passaggio sarà simile a quando le tecnologie pubblicitarie raccolgono i report dagli endpoint di reporting API e convertono i report JSON in report in formato AVRO.
Passaggio 2.3. Analizza la chiave del bucket dal report di debug: le chiavi del bucket sono progettate dalle tecnologie pubblicitarie. In questo codelab, poiché i bucket sono predefiniti, recupera le chiavi del bucket come fornite.
Passaggio 2.4. Crea l'AVRO del dominio di output: una volta recuperate le chiavi del bucket, crea il file AVRO del dominio di output.
Passaggio 2.5. Crea report riepilogativi utilizzando lo strumento di test locale: utilizza lo strumento di test locale per creare report riepilogativi nell'ambiente locale.
Passaggio 2.6. Esamina il report di riepilogo: esamina il report di riepilogo creato dallo strumento di test locale.
2.1. Report trigger
Vai al sito della demo di Privacy Sandbox. Viene attivato un report di aggregazione privata. Puoi visualizzare il report all'indirizzo chrome://private-aggregation-internals.
Elementi interni dell'aggregazione privata di Chrome.
Se il report è in stato "In attesa", puoi selezionarlo e fare clic su "Invia report selezionati".
Invia report di aggregazione privata.
2.2. Crea report aggregabile di debug
In chrome://private-aggregation-internals, copia il "Corpo del report" ricevuto nell'endpoint [reporting-origin]/.well-known/private-aggregation/report-shared-storage.
Assicurati che in "Corpo del report", aggregation_coordinator_origin contenga https://publickeyservice.msmt.aws.privacysandboxservices.com, il che significa che il report è un report aggregabile di AWS.
Report di aggregazione privata.
Inserisci il "corpo del report" JSON in un file JSON. In questo esempio, puoi utilizzare vim. ma puoi utilizzare qualsiasi editor di testo.
vim report.json
Incolla il report in report.json e salva il file.
File JSON del report.
Una volta ottenuto, vai alla cartella dei report e utilizza aggregatable_report_converter.jar per creare il report aggregabile di debug. Viene creato un report aggregabile denominato report.avro nella directory corrente.
java -jar aggregatable_report_converter.jar \
--request_type convertToAvro \
--input_file report.json \
--debug
2.3. Analizza la chiave bucket dal report di debug
Il servizio di aggregazione richiede due file durante il batch. Il report aggregabile e il file di dominio di output. Il file del dominio di output contiene le chiavi che vuoi recuperare dai report aggregabili. Per creare il file output_domain.avro, hai bisogno delle chiavi del bucket che possono essere recuperate dai report.
Le chiavi del bucket sono progettate dal chiamante dell'API e la demo contiene chiavi del bucket di esempio predefinite. Poiché la demo ha attivato la modalità di debug per l'aggregazione privata, puoi analizzare il payload in testo normale di debug da "Corpo del report" per recuperare la chiave del bucket. Tuttavia, in questo caso, le chiavi dei bucket vengono create dalla demo di Privacy Sandbox. Poiché l'aggregazione privata per questo sito è in modalità di debug, puoi utilizzare debug_cleartext_payload da "Corpo del report" per ottenere la chiave del bucket.
Copia debug_cleartext_payload dal corpo del report.
Esegui il debug del payload in testo non crittografato dal corpo del report.
Apri lo strumento Decodificatore del payload di debug per l'aggregazione privata, incolla il tuo debug_cleartext_payloadnella casella "INPUT" e fai clic su "Decodifica".
Decodificatore del payload.
La pagina restituisce il valore decimale della chiave del bucket. Di seguito è riportata una chiave del bucket di esempio.
Risultato del decodificatore del payload.
2.4. Crea l'AVRO del dominio di output
Ora che abbiamo la chiave del bucket, copia il valore decimale della chiave. Procedi alla creazione di output_domain.avro utilizzando la chiave del bucket. Verifica di sostituire
java -jar aggregatable_report_converter.jar \
--request_type createDomainAvro \
--bucket_key <bucket key>
Lo script crea il file output_domain.avro nella cartella corrente.
2.5. Creare report di riepilogo utilizzando lo strumento di test locale
Utilizzeremo il file LocalTestingTool_{version}.jar scaricato nella sezione 1.1 per creare i report di riepilogo. Utilizza il seguente comando. Devi sostituire LocalTestingTool_{version}.jar con la versione scaricata per LocalTestingTool.
Esegui questo comando per generare un report di riepilogo nel tuo ambiente di sviluppo locale:
java -jar LocalTestingTool_{version}.jar \
--input_data_avro_file report.avro \
--domain_avro_file output_domain.avro \
--output_directory .
Una volta eseguito il comando, dovresti visualizzare un risultato simile a quello mostrato nell'immagine seguente. Al termine, viene creato un report output.avro.
File Avro del report di riepilogo dei test locali.
2.6. Esaminare il report di riepilogo
Il report di riepilogo creato è in formato AVRO. Per poterlo leggere, devi convertirlo da AVRO a un formato JSON. Idealmente, la tecnologia pubblicitaria dovrebbe codificare per convertire i report AVRO in JSON.
Per il nostro Codelab, utilizzeremo lo strumento aggregatable_report_converter.jar fornito per convertire il report AVRO di nuovo in JSON.
java -jar aggregatable_report_converter.jar \
--request_type convertToJson \
--input_file output.avro
Viene restituito un report simile all'immagine seguente. insieme a un report output.json creato nella stessa directory.
Summary avro file converted to json.
Apri il file JSON in un editor a tua scelta per esaminare il report di riepilogo.
3. Deployment del servizio di aggregazione
Per eseguire il deployment del servizio di aggregazione, segui questi passaggi:
Passaggio 3. Deployment del servizio di aggregazione: esegui il deployment del servizio di aggregazione su AWS
Passaggio 3.1. Clona il repository del servizio di aggregazione
Passaggio 3.2. Scarica le dipendenze precompilate
Passaggio 3.3 Crea un ambiente di sviluppo
Passaggio 3.4. Esegui il deployment del servizio di aggregazione
3.1. Clona il repository del servizio di aggregazione
Nel tuo ambiente locale, clona il repository GitHub del servizio di aggregazione.
git clone https://github.com/privacysandbox/aggregation-service.git
3.2. Scarica le dipendenze precompilate
Dopo aver clonato il repository del servizio di aggregazione, vai alla cartella Terraform del repository e alla cartella cloud corrispondente. Se il tuo cloud_provider è AWS, puoi procedere al passaggio
cd <repository_root>/terraform/aws
In download_prebuilt_dependencies.sh.
bash download_prebuilt_dependencies.sh
3.3 Crea un ambiente di sviluppo
Crea un ambiente di sviluppo in dev.
mkdir dev
Copia i contenuti della cartella demo nella cartella dev.
cp -R demo/* dev
Spostalo nella cartella dev.
cd dev
Aggiorna il file main.tf e premi i per input per modificare il file.
vim main.tf
Rimuovi il commento dal codice nella casella rossa rimuovendo il carattere # e aggiornando i nomi del bucket e della chiave.
Per AWS main.tf:
File main.tf di AWS.
Il codice non commentato dovrebbe avere l'aspetto seguente.
backend "s3" {
bucket = "<tf_state_bucket_name>"
key = "<environment_name>.tfstate"
region = "us-east-1"
}
Una volta completati gli aggiornamenti, salvali ed esci dall'editor premendo esc -> :wq!. In questo modo, gli aggiornamenti vengono salvati su main.tf.
Poi, rinomina example.auto.tfvars in dev.auto.tfvars.
mv example.auto.tfvars dev.auto.tfvars
Aggiorna dev.auto.tfvars e premi i per input per modificare il file.
vim dev.auto.tfvars
Aggiorna i campi nella casella rossa dell'immagine seguente con i parametri ARN AWS corretti forniti durante l'onboarding, l'ambiente e l'email di notifica del servizio di aggregazione.
Modifica il file dev auto tfvars.
Una volta completati gli aggiornamenti, premi esc -> :wq!. In questo modo viene salvato il file dev.auto.tfvars, che dovrebbe avere un aspetto simile a quello dell'immagine seguente.
File tfvars di sviluppo automatico aggiornato.
3.4. Esegui il deployment del servizio di aggregazione
Per eseguire il deployment del servizio di aggregazione, inizializza Terraform nella stessa cartella
terraform init
Dovresti ottenere un risultato simile a quello dell'immagine seguente:
Terraform init.
Una volta inizializzato Terraform, crea il piano di esecuzione di Terraform. Dove restituisce il numero di risorse da aggiungere e altre informazioni aggiuntive simili all'immagine seguente.
terraform plan
Di seguito puoi vedere il riepilogo del "Piano". Se si tratta di un nuovo deployment, dovresti vedere il numero di risorse che verranno aggiunte con 0 da modificare e 0 da eliminare.
Piano Terraform.
Una volta completata questa operazione, puoi procedere con l'applicazione di Terraform.
terraform apply
Quando ti viene chiesto di confermare l'esecuzione delle azioni da parte di Terraform, inserisci yes nel valore.
Prompt di applicazione di Terraform.
Al termine di terraform apply, vengono restituiti i seguenti endpoint per createJob e getJob. Viene restituito anche frontend_api_id che devi aggiornare in Postman nella sezione 1.9.
Terraform apply complete.
4. Creazione dell'input del servizio di aggregazione
Procedi alla creazione dei report AVRO per il batching nel servizio di aggregazione.
Passaggio 4. Creazione input del servizio di aggregazione: crea i report del servizio di aggregazione raggruppati in batch per il servizio di aggregazione.
Passaggio 4.1. Report attivatori
Passaggio 4.2. Raccogli report aggregabili
Passaggio 4.3. Converti i report in AVRO
Passaggio 4.4. Crea l'AVRO del dominio di output
4.1. Report trigger
Vai al sito della demo di Privacy Sandbox. Viene attivato un report di aggregazione privata. Puoi visualizzare il report all'indirizzo chrome://private-aggregation-internals.
Elementi interni dell'aggregazione privata di Chrome.
Se il report è in stato "In attesa", puoi selezionarlo e fare clic su "Invia report selezionati". "
Invia report di aggregazione privata.
4.2. Raccogliere report aggregabili
Raccogli i report aggregabili dagli endpoint .well-known dell'API corrispondente.
- Private Aggregation
[reporting-origin] /.well-known/private-aggregation/report-shared-storage - Attribution Reporting - Report di riepilogo
[reporting-origin] /.well-known/attribution-reporting/report-aggregate-attribution
Per questo codelab, eseguirai manualmente la raccolta dei report. In produzione, le tecnologie pubblicitarie devono raccogliere e convertire i report in modo programmatico.
In chrome://private-aggregation-internals, copia il "Corpo del report" ricevuto nell'endpoint [reporting-origin]/.well-known/private-aggregation/report-shared-storage.
Assicurati che in "Corpo del report", aggregation_coordinator_origin contenga https://publickeyservice.msmt.aws.privacysandboxservices.com, il che significa che il report è un report aggregabile di AWS.
Report di aggregazione privata.
Inserisci il "corpo del report" JSON in un file JSON. In questo esempio, puoi utilizzare vim. ma puoi utilizzare qualsiasi editor di testo.
vim report.json
Incolla il report in report.json e salva il file.
File JSON del report.
4.3. Convertire i report in AVRO
I report ricevuti dagli endpoint .well-known sono in formato JSON e devono essere convertiti in formato AVRO. Una volta ottenuto il report JSON, vai alla cartella dei report e utilizza aggregatable_report_converter.jar per creare il report aggregabile di debug. Viene creato un report aggregabile denominato report.avro nella directory corrente.
java -jar aggregatable_report_converter.jar \
--request_type convertToAvro \
--input_file report.json
4.4. Crea l'AVRO del dominio di output
Per creare il file output_domain.avro, hai bisogno delle chiavi del bucket che possono essere recuperate dai report.
Le chiavi dei bucket sono progettate dalla tecnologia pubblicitaria. Tuttavia, in questo caso, il sito demo di Privacy Sandbox crea le chiavi dei bucket. Poiché l'aggregazione privata per questo sito è in modalità di debug, puoi utilizzare debug_cleartext_payload da "Corpo del report" per ottenere la chiave del bucket.
Copia pure il debug_cleartext_payload dal corpo della segnalazione.
Esegui il debug del payload in testo non crittografato dal corpo del report.
Apri goo.gle/ags-payload-decoder, incolla il tuo debug_cleartext_payloadnella casella "INPUT" e fai clic su "Decode".
Decodificatore del payload.
La pagina restituisce il valore decimale della chiave del bucket. Di seguito è riportata una chiave del bucket di esempio.
Risultato del decodificatore del payload.
Ora che abbiamo la chiave del bucket, crea il output_domain.avro. Verifica di sostituire
java -jar aggregatable_report_converter.jar \
--request_type createDomainAvro \
--bucket_key <bucket key>
Lo script crea il file output_domain.avro nella cartella corrente.
4.5. Spostare i report nel bucket AWS
Una volta creati i report AVRO (dalla sezione 3.2.3) e il dominio di output (dalla sezione 3.2.4), procedi a spostarli nei bucket S3 dei report.
Se hai configurato la CLI AWS nel tuo ambiente locale, utilizza i seguenti comandi per copiare i report nel bucket S3 e nella cartella dei report corrispondenti.
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. Utilizzo del servizio di aggregazione
Da terraform apply, vengono restituiti create_job_endpoint, get_job_endpoint e frontend_api_id. Copia frontend_api_id e inseriscilo nella variabile globale Postman frontend_api_id che hai configurato nella sezione 1.9 dei prerequisiti.
Passaggio 5: Utilizzo del servizio di aggregazione: utilizza l'API Aggregation Service per creare report di riepilogo e rivederli.
Passaggio 5.1. Utilizzo dell'endpoint createJob per il batch
Passaggio 5.2. Utilizzo dell'endpoint getJob per recuperare lo stato del batch
Passaggio 5.3. Esaminare il report di riepilogo
5.1. Utilizzo dell'endpoint createJob per il batch
In Postman, apri la raccolta "Privacy Sandbox" e seleziona "createJob".
Seleziona "Body" e poi "raw" per inserire il payload della richiesta.
postman createJob request body
Lo schema del payload createJob è disponibile su GitHub ed è simile al seguente. Sostituisci <> con i campi appropriati.
{
"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"
}
}
Dopo aver fatto clic su "Invia", viene creato il job con job_request_id. Dovresti ricevere una risposta HTTP 202 una volta che la richiesta viene accettata dal servizio di aggregazione. Altri possibili codici di ritorno sono disponibili in Codici di risposta HTTP
postman createJob request status
5.2. Utilizzo dell'endpoint getJob per recuperare lo stato del batch
Per controllare lo stato della richiesta di job, puoi utilizzare l'endpoint getJob. Seleziona "getJob" nella raccolta "Privacy Sandbox".
In "Params", aggiorna il valore job_request_id con job_request_id inviato nella richiesta createJob.
postman getJob request
Il risultato di getJob deve restituire lo stato della richiesta di lavoro con uno stato HTTP 200. La richiesta "Body" contiene le informazioni necessarie, come job_status, return_message e error_messages (se il job ha generato un errore).
postman getJob request status
Poiché il sito di reporting del report demo generato è diverso dal sito di cui hai eseguito l'onboarding nel tuo ID AWS, potresti ricevere una risposta con il codice di ritorno PRIVACY_BUDGET_AUTHORIZATION_ERROR. Questo è normale, in quanto il sito di origine dei report non corrisponde al sito di reporting integrato per 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. Esaminare il report di riepilogo
Una volta ricevuto il report di riepilogo nel bucket S3 di output, puoi scaricarlo nel tuo ambiente locale. I report di riepilogo sono in formato AVRO e possono essere riconvertiti in un file JSON. Puoi utilizzare aggregatable_report_converter.jar per leggere il report utilizzando il seguente comando.
java -jar aggregatable_report_converter.jar \
--request_type convertToJson \
--input_file <summary_report_avro>
Viene restituito un JSON dei valori aggregati di ogni chiave bucket simile all'immagine seguente.
Report di riepilogo.
Se la tua richiesta createJob include debug_run come true, puoi ricevere il report riepilogativo nella cartella di debug che si trova in output_data_blob_prefix. Il report è in formato AVRO e può essere convertito in JSON utilizzando il comando precedente.
Il report contiene la chiave del bucket, la metrica non modificata e il rumore aggiunto alla metrica non modificata per formare il report di riepilogo. Il report è simile all'immagine seguente.
Report di riepilogo del debug.
Le annotazioni contengono anche in_reports e in_domain, il che significa:
- in_reports: la chiave del bucket è disponibile all'interno dei report aggregabili.
- in_domain: la chiave del bucket è disponibile all'interno del file AVRO output_domain.