Lavorare con Aggregation Service sulla piattaforma Google Cloud

1. 1. Prerequisiti

Tempo stimato per il completamento: 1-2 ore

Esistono due modalità per eseguire questo codelab: Test locale o Servizio di aggregazione. La modalità di test locale richiede un computer locale e il browser Chrome (non è possibile creare/utilizzare risorse di Google Cloud). La modalità del servizio di aggregazione richiede un deployment completo del servizio di aggregazione su Google Cloud.

Per eseguire questo codelab in entrambe le modalità, sono necessari alcuni prerequisiti. Ogni requisito viene contrassegnato di conseguenza, indipendentemente dal fatto che sia obbligatorio per i test locali o il servizio di aggregazione.

1.1. Registrazione e attestazione completa (servizio di aggregazione)

Per utilizzare le API Privacy Sandbox, assicurati di aver completato la registrazione e l'attestazione sia per Chrome sia per Android.

1.2. Attiva le API di privacy per gli annunci (servizio di test e aggregazione locale)

Poiché utilizzeremo Privacy Sandbox, ti invitiamo ad attivare le API per gli annunci di Privacy Sandbox.

Nel browser, vai a chrome://settings/adPrivacy e attiva tutte le API di privacy per gli annunci.

Assicurati inoltre che i cookie di terze parti siano abilitati.

A partire dal giorno chrome://settings/cookies, assicurati che i cookie di terze parti NON vengano bloccati. A seconda della versione di Chrome, potresti vedere opzioni diverse nel menu delle impostazioni, ma le configurazioni accettabili includono:

  • "Blocca tutti i cookie di terze parti" = DISATTIVATO
  • "Blocca cookie di terze parti" = DISATTIVATO
  • "Blocca cookie di terze parti in modalità di navigazione in incognito" = ATTIVATO

Abilitazione dei cookie

1.3. Scarica lo strumento di test locale (test locale)

Per i test locali sarà 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 della funzione Cloud Functions in GitHub. Dovrebbe essere denominato LocalTestingTool_{version}.jar.

1.4. Assicurati che JAVA JRE sia installato (servizio di test e aggregazione locale)

Apri "Terminale" e usa java --version per verificare se sulla macchina è installato Java o openJDK.

Controlla la versione di Java

Se non è installato, puoi scaricarlo e installarlo dal sito Java o dal sito di openJDK.

1.5. Scarica aggregable_report_converter (Local Testing and Aggregation Service)

Puoi scaricare una copia dell'aggregable_report_converter dal repository GitHub di Privacy Sandbox Demos. Il repository GitHub menziona l'utilizzo di IntelliJ o Eclipse, ma nessuno dei due è obbligatorio. Se non usi questi strumenti, scarica il file JAR nel tuo ambiente locale.

1.6. Configura un ambiente Google Cloud (servizio di aggregazione)

Il servizio di aggregazione richiede l'uso di un ambiente di esecuzione affidabile che utilizza un provider cloud. In questo codelab, Aggregation Service verrà eseguito in Google Cloud, ma AWS è supportato anche.

Segui le istruzioni per il deployment in GitHub per configurare gcloud CLI, scaricare programmi binari e moduli Terraform e creare risorse Google Cloud per il servizio di aggregazione.

Passaggi chiave nelle istruzioni per il deployment:

  1. Configura lo strumento "gcloud" l'interfaccia a riga di comando e Terraform nel tuo ambiente.
  2. Creare un bucket Cloud Storage per archiviare lo stato di Terraform.
  3. Scarica le dipendenze.
  4. Aggiorna adtech_setup.auto.tfvars ed esegui il Terraform adtech_setup. Consulta l'Appendice per un esempio di file adtech_setup.auto.tfvars. Prendi nota del nome del bucket di dati creato qui: verrà utilizzato nel codelab per archiviare i file creati.
  5. Aggiorna dev.auto.tfvars, impersona l'account di servizio di deployment ed esegui il Terraform dev. Consulta l'Appendice per un esempio di file dev.auto.tfvars.
  6. Al termine del deployment, acquisisci il frontend_service_cloudfunction_url dall'output Terraform, che sarà necessario per effettuare richieste al servizio di aggregazione nei passaggi successivi.

1.7. Onboarding completo del servizio di aggregazione (servizio di aggregazione)

Il servizio di aggregazione richiede l'onboarding dei coordinatori per poterlo utilizzare. Compila il modulo di onboarding del servizio di aggregazione fornendo il tuo sito di segnalazione e altre informazioni, selezionando "Google Cloud" e inserendo l'indirizzo del tuo account di servizio. Questo account di servizio viene creato nel prerequisito precedente (1.6. configurare un ambiente Google Cloud). Suggerimento: se utilizzi i nomi predefiniti forniti, questo account di servizio inizierà con "worker-sa@".

Il completamento della procedura di onboarding può richiedere fino a 2 settimane.

1.8. Determina il metodo per chiamare gli endpoint API (servizio di aggregazione)

Questo codelab offre due opzioni per chiamare gli endpoint dell'API Aggregation Service: cURL e Postman. cURL è il modo più facile e veloce per chiamare gli endpoint API dal tuo terminale, poiché richiede una configurazione minima e nessun software aggiuntivo. Tuttavia, se non vuoi utilizzare cURL, puoi utilizzare Postman per eseguire e salvare le richieste API per un uso futuro.

Nella sezione 3.2. Utilizzo del servizio di aggregazione, troverai istruzioni dettagliate per l'utilizzo di entrambe le opzioni. Puoi visualizzarle in anteprima per stabilire quale metodo utilizzerai. Se selezioni Postman, esegui la seguente configurazione iniziale.

1.8.1. Configura spazio di lavoro

Crea un account Postman. Dopo aver eseguito la registrazione, viene creata automaticamente un'area di lavoro.

Area di lavoro Postman

Se non è stata creata un'area di lavoro per te, vai a "Aree di lavoro" in alto e seleziona "Crea spazio di lavoro".

Seleziona "Area di lavoro vuota", fai clic su Avanti e assegnale il nome "Privacy Sandbox di Google Cloud". Seleziona "Personale" e fai clic su "Crea".

Scarica la configurazione JSON e i file dell'ambiente globale preconfigurati dell'area di lavoro.

Importa entrambi i file JSON in "La mia area di lavoro" tramite il pulsante "Importa" .

Pulsante importa

Verrà creata la "Privacy Sandbox di Google Cloud" insieme alle richieste HTTP createJob e getJob.

1.8.2. configura le autorizzazioni

Fai clic su "Privacy Sandbox di Google Cloud" raccolta e vai alla sezione "Autorizzazione" .

Pulsante di autorizzazione

Userai il token "Bearer Token" . Dal tuo ambiente terminale, esegui questo comando e copia l'output.

gcloud auth print-identity-token

Dopodiché, incolla questo valore nel "Token" della scheda Autorizzazione di Postman:

Campo token

1.8.3. Configura l'ambiente

Vai alla sezione "Look rapido dell'ambiente" nell'angolo in alto a destra:

Pulsante Ambiente

Fai clic su "Modifica" e aggiornare il "Valore attuale" di "ambiente", "regione" e "id-cloud-function-id":

Imposta valori correnti

Puoi lasciare "request-id" vuoto per ora, perché lo compileremo più tardi. Per gli altri campi, utilizza i valori dell'elemento frontend_service_cloudfunction_url, che è stato restituito dopo il completamento con esito positivo del deployment di Terraform nel prerequisito 1.6. L'URL è nel seguente formato: https://--frontend-service--uc.a.run.app

2. 2. Codelab sui test locali

Tempo stimato per il completamento: < 1 ora

Puoi utilizzare lo strumento di test locale sul tuo computer per eseguire l'aggregazione e generare report di riepilogo utilizzando i report di debug non criptati. Prima di iniziare, assicurati di aver completato tutti i prerequisiti etichettati con "Test locale".

Passaggi del codelab

Passaggio 2.1. Attiva report: attiva i report sull'aggregazione privata per poter raccogliere il report.

Passaggio 2.2. Crea report AVRO di debug: converti il report JSON raccolto in un report in formato AVRO. Questo passaggio sarà simile a quando adTechs raccoglierà i report dagli endpoint di reporting dell'API e convertirà i report JSON in report in formato AVRO.

Passaggio 2.3. Recupera le chiavi bucket: le chiavi dei bucket sono progettate da adTechs. In questo codelab, poiché i bucket sono predefiniti, recupera le chiavi dei bucket come previsto.

Passaggio 2.4. Crea AVRO del dominio di output: una volta recuperate le chiavi dei bucket, crea il file AVRO del dominio di output.

Passaggio 2.5. Crea report di riepilogo: utilizza lo strumento di test locale per creare report di riepilogo nell'ambiente locale.

Passaggio 2.6. Esamina i report di riepilogo: esamina il report di riepilogo creato dallo strumento di test locale.

2.1. Attiva report

Per attivare un report di aggregazione privato, puoi utilizzare il sito demo di Privacy Sandbox (https://privacy-sandbox-demos-news.dev/?env=gcp) o il tuo sito (ad es. https://adtechexample.com). Se utilizzi il tuo sito e non hai completato la registrazione e Onboarding dei servizi di attestazione e aggregazione, devi utilizzare un flag di Chrome e un'opzione dell'interfaccia a riga di comando.

Per questa demo, utilizzeremo il sito dimostrativo di Privacy Sandbox. Segui il link per accedere al sito. Poi potrai visualizzare i report alla pagina chrome://private-aggregation-internals:

Pagina Interni di Chrome

Il report inviato all'endpoint {reporting-origin}/.well-known/private-aggregation/debug/report-shared-storage si trova anche nel "Corpo del report" dei report visualizzati nella pagina Interni di Chrome.

Qui potresti vedere molti report, ma per questo codelab usa un report aggregabile specifico per Google Cloud e generato dall'endpoint di debug. "URL della segnalazione" conterrà "/debug/" e aggregation_coordinator_origin field del "Corpo del rapporto" conterrà questo URL: https://publickeyservice.msmt.gcp.privacysandboxservices.com.

Report di debug Google Cloud

2.2. Crea report aggregato di debug

Copiare il report presente nel "Corpo del report". di chrome://private-aggregation-internals e crea un file JSON nella cartella privacy-sandbox-demos/tools/aggregatable_report_converter/out/artifacts/aggregatable_report_converter_jar (all'interno del repository scaricato nel prerequisito 1.5).

In questo esempio viene utilizzato vim perché utilizziamo Linux. ma puoi utilizzare qualsiasi editor di testo.

vim report.json

Incolla il report in report.json e salva il file.

JSON del report

Dopodiché, usa aggregatable_report_converter.jar per creare il report aggregabile di debug. In questo modo, nella directory attuale viene creato un report aggregabile chiamato report.avro.

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

2.3. Recupera la chiave bucket dal report

Per creare il file output_domain.avro, hai bisogno delle chiavi dei bucket che è possibile recuperare dai report.

Le chiavi dei bucket sono progettate da adTech. Tuttavia, in questo caso, il sito Privacy Sandbox Demo crea le chiavi dei bucket. Poiché l'aggregazione privata per questo sito è in modalità di debug, possiamo utilizzare il valore debug_cleartext_payload del "Corpo del report" per ottenere la chiave del bucket.

Copia il debug_cleartext_payload dal corpo del report.

Debug del payload in chiaro

Apri goo.gle/ags-payload-decoder e incolla il tuo debug_cleartext_payload in "INPUT" e fai clic su "Decodifica".

Pulsante Decodifica

La pagina restituisce il valore decimale della chiave del bucket. Di seguito è riportato un esempio di chiave bucket.

Chiave bucket

2.4. Crea AVRO del dominio di output

Ora che abbiamo la chiave del bucket, creiamo output_domain.avro nella stessa cartella in cui abbiamo lavorato. Assicurati di sostituire la chiave del bucket con la chiave del bucket che hai recuperato.

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. Crea report di riepilogo utilizzando lo strumento di test locale

Utilizzeremo l'elemento LocalTestingTool_{version}.jar scaricato nel prerequisito 1.3 per creare i report di riepilogo mediante il comando in basso. Sostituisci {version} con la versione scaricata. Ricordati di spostare LocalTestingTool_{version}.jar nella directory corrente o di aggiungere un percorso relativo per fare riferimento alla sua posizione attuale.

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

Una volta eseguito il comando, il risultato dovrebbe essere simile a quello riportato di seguito. Al termine dell'operazione, verrà creato un report output.avro.

AVRO di output

2.6. Esamina il report di riepilogo

Il report di riepilogo creato è in formato AVRO. Per poterlo leggere, devi convertirlo da AVRO a un formato JSON. Idealmente, adTech dovrebbe scrivere il codice per riconvertire i report AVRO in JSON.

Utilizzeremo aggregatable_report_converter.jar per riconvertire il report AVRO in JSON.

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

Viene restituito un report simile al seguente. È inoltre presente un report output.json creato nella stessa directory.

JSON di output

Codelab completato.

Riepilogo:hai raccolto un report di debug, creato un file di dominio di output e generato un report di riepilogo utilizzando lo strumento di test locale che simula il comportamento di aggregazione del servizio di aggregazione.

Passaggi successivi: ora che hai sperimentato lo strumento di test locale, puoi provare lo stesso esercizio con un deployment live di Aggregation Service nel tuo ambiente. Rivedi i prerequisiti per assicurarti di aver configurato tutto per "Servizio di aggregazione" , quindi procedi con il passaggio 3.

3. 3. Codelab sui servizi di aggregazione

Tempo stimato per il completamento: 1 ora

Prima di iniziare, assicurati di aver completato tutti i prerequisiti etichettati con "Servizio di aggregazione".

Passaggi del codelab

Passaggio 3.1. Creazione di input del servizio di aggregazione: crea i report del servizio di aggregazione che vengono raggruppati in batch per il servizio di aggregazione.

  • Passaggio 3.1.1. Report trigger
  • Passaggio 3.1.2. Raccogli report aggregati
  • Passaggio 3.1.3. Converti i report in AVRO
  • Passaggio 3.1.4. Crea output_domain AVRO
  • Passaggio 3.1.5. Sposta i report nel bucket Cloud Storage

Passaggio 3.2. Utilizzo del servizio di aggregazione: utilizza l'API Aggregation Service per creare report di riepilogo ed esaminare i report di riepilogo.

  • Passaggio 3.2.1. Utilizzo dell'endpoint createJob per i batch
  • Passaggio 3.2.2. Utilizzo dell'endpoint getJob per recuperare lo stato del batch
  • Passaggio 3.2.3. Esaminare il report di riepilogo

3.1. Creazione di input del servizio di aggregazione

Procedi alla creazione dei report AVRO per il raggruppamento in batch al servizio di aggregazione. I comandi shell in questi passaggi possono essere eseguiti all'interno di Cloud Shell di Google Cloud (purché le dipendenze dei prerequisiti siano clonate nell'ambiente Cloud Shell) o in un ambiente di esecuzione locale.

3.1.1. Report trigger

Segui il link per accedere al sito. Poi potrai visualizzare i report alla pagina chrome://private-aggregation-internals:

Pagina Interni di Chrome

Il report inviato all'endpoint {reporting-origin}/.well-known/private-aggregation/debug/report-shared-storage si trova anche nel "Corpo del report" dei report visualizzati nella pagina Interni di Chrome.

Qui potresti vedere molti report, ma per questo codelab usa un report aggregabile specifico per Google Cloud e generato dall'endpoint di debug. "URL della segnalazione" conterrà "/debug/" e aggregation_coordinator_origin field del "Corpo del rapporto" conterrà questo URL: https://publickeyservice.msmt.gcp.privacysandboxservices.com.

Report di debug Google Cloud

3.1.2. Raccogli report aggregati

Raccogli i report aggregabili dagli endpoint .well-known dell’API corrispondente.

  • Aggregazione privata: {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, la raccolta dei report viene eseguita manualmente. In fase di produzione, le tecnologie pubblicitarie dovrebbero raccogliere e convertire i report in modo programmatico.

Copiamo il report JSON nel "Corpo del report" da chrome://private-aggregation-internals.

In questo esempio viene usato vim, perché con Linux. ma puoi utilizzare qualsiasi editor di testo.

vim report.json

Incolla il report in report.json e salva il file.

JSON del report

3.1.3. Converti i report in AVRO

I report ricevuti dagli endpoint .well-known sono in formato JSON e devono essere convertiti in formato di report AVRO. Una volta ottenuto il report JSON, vai alla posizione in cui è archiviato report.json e usa aggregatable_report_converter.jar per creare il report aggregabile di debug. In questo modo, nella directory attuale viene creato un report aggregabile chiamato report.avro.

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

3.1.4. Crea output_domain AVRO

Per creare il file output_domain.avro, hai bisogno delle chiavi dei bucket che è possibile recuperare dai report.

Le chiavi dei bucket sono progettate da adTech. Tuttavia, in questo caso, il sito Privacy Sandbox Demo crea le chiavi dei bucket. Poiché l'aggregazione privata per questo sito è in modalità di debug, possiamo utilizzare il valore debug_cleartext_payload del "Corpo del report" per ottenere la chiave del bucket.

Copia il debug_cleartext_payload dal corpo del report.

Debug del payload in chiaro

Apri goo.gle/ags-payload-decoder e incolla il tuo debug_cleartext_payload in "INPUT" e fai clic su "Decodifica".

Pulsante Decodifica

La pagina restituisce il valore decimale della chiave del bucket. Di seguito è riportato un esempio di chiave bucket.

Chiave bucket

Ora che abbiamo la chiave del bucket, creiamo output_domain.avro nella stessa cartella in cui abbiamo lavorato. Assicurati di sostituire la chiave del bucket con la chiave del bucket che hai recuperato.

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

Lo script crea il file output_domain.avro nella cartella corrente.

3.1.5. Sposta i report nel bucket Cloud Storage

Dopo aver creato i report AVRO e il dominio di output, procedi con lo spostamento dei report e del dominio di output nel bucket in Cloud Storage (come indicato in Prerequisito 1.6).

Se hai configurato gcloud CLI nel tuo ambiente locale, utilizza i comandi seguenti per copiare i file nelle cartelle corrispondenti.

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

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

In caso contrario, carica manualmente i file nel bucket. Crea una cartella denominata "report" e carica il file report.avro lì. Crea una cartella denominata "output_domains" e carica il file output_domain.avro lì.

3.2. Utilizzo del servizio di aggregazione

Ricorda nel prerequisito 1.8 che hai selezionato cURL o Postman per effettuare richieste API agli endpoint del servizio di aggregazione. Di seguito troverai le istruzioni per entrambe le opzioni.

Se il job non riesce e genera un errore, consulta la nostra documentazione per la risoluzione dei problemi in GitHub per maggiori informazioni su come procedere.

3.2.1. Utilizzo dell'endpoint createJob per i batch

Utilizza le istruzioni di cURL o Postman riportate di seguito per creare un job.

cURL

In "Terminale", crea un file del corpo della richiesta (body.json) e incollaci il codice seguente. Assicurati di aggiornare i valori segnaposto. Per saperne di più su ciò che rappresenta ciascun campo, consulta questa documentazione 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"
  }
}

Esegui la richiesta riportata di seguito. Sostituisci i segnaposto nell'URL della richiesta cURL con i valori di frontend_service_cloudfunction_url, che vengono restituiti dopo il completamento del deployment di Terraform nel prerequisito 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

Dovresti ricevere una risposta HTTP 202 dopo che il servizio di aggregazione avrà accettato la richiesta. Altri possibili codici di risposta sono documentati nelle specifiche dell'API.

Postman

Per l'endpoint createJob, è necessario un corpo della richiesta al fine di fornire al servizio di aggregazione i nomi di località e file aggregabili, domini di output e report di riepilogo.

Vai al "Corpo" della richiesta createJob :

Scheda Corpo

Sostituisci i segnaposto all'interno del file JSON fornito. Per saperne di più su questi campi e su ciò che rappresentano, consulta la documentazione dell'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"
  }
}

"Invia" la richiesta API createJob:

Pulsante Invia

Il codice di risposta è disponibile nella metà inferiore della pagina:

Codice risposta

Dovresti ricevere una risposta HTTP 202 dopo che il servizio di aggregazione avrà accettato la richiesta. Altri possibili codici di risposta sono documentati nelle specifiche dell'API.

3.2.2. Utilizzo dell'endpoint getJob per recuperare lo stato del batch

Utilizza le istruzioni di cURL o Postman riportate di seguito per trovare un lavoro.

cURL

Esegui la richiesta riportata di seguito nel tuo terminale. Sostituisci i segnaposto nell'URL con i valori di frontend_service_cloudfunction_url, che corrispondono a quelli utilizzati per la richiesta createJob. Per "job_request_id", utilizza il valore del job che hai creato con l'endpoint 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>

Il risultato dovrebbe restituire lo stato della tua richiesta di job con uno stato HTTP pari a 200. Il "Corpo" della richiesta contiene le informazioni necessarie come job_status, return_message e error_messages (se il lavoro presenta errori).

Postman

Per controllare lo stato della richiesta di lavoro, puoi utilizzare l'endpoint getJob. Nella sezione "Parametri" della richiesta getJob, aggiorna il valore job_request_id a job_request_id inviato nella richiesta createJob.

ID richiesta job

"Invia" la richiesta getJob:

Pulsante Invia

Il risultato dovrebbe restituire lo stato della tua richiesta di job con uno stato HTTP pari a 200. Il "Corpo" della richiesta contiene le informazioni necessarie come job_status, return_message e error_messages (se il lavoro presenta errori).

JSON risposta

3.2.3. Esaminare il report di riepilogo

Dopo aver ricevuto il report di riepilogo nel bucket Cloud Storage di output, puoi scaricarlo nel tuo ambiente locale. I report di riepilogo sono in formato AVRO e possono essere riconvertiti in formato JSON. Puoi utilizzare aggregatable_report_converter.jar per leggere il report usando il comando seguente.

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

Questo restituisce un json dei valori aggregati di ogni chiave del bucket simile al seguente.

Report di riepilogo

Se la richiesta createJob include debug_run come true, puoi ricevere il report di riepilogo 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 senza rumore e il rumore che viene aggiunto alla metrica senza rumore per formare il report di riepilogo. Il report è simile al seguente.

Report con rumore

Le annotazioni contengono anche "in_reports" e/o "in_domain" il che significa che:

  • in_reports: la chiave del bucket è disponibile all'interno dei report aggregabili.
  • in_domain: la chiave del bucket è disponibile nel file AVRO output_domain.

Codelab completato.

Riepilogo: hai eseguito il deployment del servizio di aggregazione nel tuo ambiente cloud, hai raccolto un report di debug, creato un file del dominio di output, hai archiviato questi file in un bucket Cloud Storage ed eseguito un job correttamente.

Passaggi successivi:continua a utilizzare il servizio di aggregazione nel tuo ambiente oppure elimina le risorse cloud che hai appena creato seguendo le istruzioni di pulizia riportate nel passaggio 4.

4. 4. Eliminazione

Per eliminare le risorse create per il servizio di aggregazione tramite Terraform, utilizza il comando destroy nelle cartelle adtech_setup e dev (o nell'altro ambiente):

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

Per eliminare il bucket Cloud Storage che contiene i report aggregabili e i report di riepilogo:

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

Puoi anche scegliere di ripristinare le impostazioni dei cookie di Chrome dal prerequisito 1.2 al loro stato precedente.

5. 5. Appendice

File adtech_setup.auto.tfvars di esempio

/**
 * 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>"

File dev.auto.tfvars di esempio

/**
 * 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