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. Abilita le API Privacy Sandbox (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://flags/#privacy-sandbox-ads-apis e abilita le API Privacy Sandbox.

Abilitazione delle API Privacy Sandbox in corso...

Assicurati inoltre che i cookie di terze parti siano abilitati.

Visita la pagina chrome://settings/cookies sul browser. Assicurati che i cookie di terze parti NON siano 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" = ABILITATO

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.

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.

1.6.1. Deployment

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 l'interfaccia a riga di comando "gcloud" 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.
  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.6.2. Bucket del report

Una volta configurato il progetto, creerai un bucket in Cloud Storage per archiviare i report aggregabili e i report di riepilogo di questo codelab. Questo è un esempio di comando gcloud per creare un bucket. Sostituisci i segnaposto con un nome e una posizione di tua scelta.

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

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 API di Aggregation Service: cURL e Postman. cURL è il modo più rapido e più semplice 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 hai creato un'area di lavoro, vai all'elemento di navigazione in alto "Aree di lavoro" 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 automaticamente la raccolta "Privacy Sandbox di Google Cloud" insieme alle richieste HTTP createJob e getJob.

1.8.2. configura le autorizzazioni

Fai clic sulla raccolta "Privacy Sandbox di Google Cloud" e vai alla scheda "Autorizzazione".

Pulsante di autorizzazione

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

gcloud auth print-identity-token

Incolla quindi questo valore del token nel campo "Token" della scheda Autorizzazione Postman:

Campo token

1.8.3. Configura l'ambiente

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

Pulsante Ambiente

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

Imposta valori correnti

Per il momento puoi lasciare vuoto il campo "request-id" perché lo compileremo in seguito. 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 usi il tuo sito e non hai completato Registrazione e attestazione e Onboarding del servizio di 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 all'indirizzo 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 Chrome Internals.

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

Report di debug Google Cloud

2.2. Crea report aggregato di debug

Copia il report che si trova 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 debug_cleartext_payload nel "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 nella casella "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

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 all'indirizzo 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 Chrome Internals.

Qui potresti vedere molti report, ma per questo codelab usa un report aggregabile specifico per Google Cloud e generato dall'endpoint di debug. L'"URL del report" conterrà "/debug/", mentre il valore aggregation_coordinator_origin field del "Corpo del report" 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.

Proviamo a copiare 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 debug_cleartext_payload nel "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 nella casella "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

Una volta creati i report AVRO e il dominio di output, procedi con lo spostamento dei report e del dominio di output nel bucket in Cloud Storage (che hai creato come passaggio finale nel 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 "reports" e carica il file report.avro lì. Crea una cartella intitolata "output_domains" e carica lì il file output_domain.avro.

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.

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>",
    "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.

Postino

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 alla scheda "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>",
    "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. La richiesta "Corpo" contiene le informazioni necessarie come job_status, return_message e error_messages (se il job presenta errori).

Postino

Per controllare lo stato della richiesta di lavoro, puoi utilizzare l'endpoint getJob. Nella sezione "Params" della richiesta getJob, aggiorna il valore job_request_id al valore 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. La richiesta "Corpo" contiene le informazioni necessarie come job_status, return_message e error_messages (se il job 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.

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