Trabajar con el servicio de agregación en Google Cloud Platform (GCP)

1. 1. Requisitos previos

Tiempo estimado para completar la actividad: 1 a 2 horas

Hay 2 modos para realizar este codelab: Pruebas locales o Servicio de agregación. El modo de prueba local requiere una máquina local y el navegador Chrome (no se crea ni se usa ningún recurso de Google Cloud). El modo del servicio de agregación requiere una implementación completa del servicio de agregación en Google Cloud.

Para realizar este codelab en cualquiera de los modos, se requieren algunos requisitos previos. Cada requisito se marca según corresponda, ya sea que se requiera para las pruebas locales o el Servicio de agregación.

1.1. Completar la inscripción y la certificación (servicio de agregación)

Para usar las APIs de Privacy Sandbox, verifica que hayas completado la inscripción y la certificación tanto para Chrome como para Android.

1.2. Habilita las APIs de Privacidad de anuncios (pruebas locales y servicio de agregación)

Como usaremos Privacy Sandbox, te recomendamos que habilites las APIs de Privacy Sandbox Ads.

En tu navegador, ve a chrome://settings/adPrivacy y habilita todas las APIs de Privacidad de los anuncios.

También verifica que tus cookies de terceros estén habilitadas.

En chrome://settings/cookies, asegúrate de que NO se bloqueen las cookies de terceros. Según tu versión de Chrome, es posible que veas diferentes opciones en este menú de configuración, pero las configuraciones aceptables incluyen las siguientes:

  • "Bloquear todas las cookies de terceros" = INHABILITADO
  • "Bloquear cookies de terceros" = INHABILITADO
  • "Bloquear cookies de terceros en el modo Incógnito" = HABILITADO

Cómo habilitar las cookies Habilitar cookies

1.3. Descarga la herramienta de pruebas locales (Local Testing)

Las pruebas locales requerirán la descarga de la herramienta de pruebas locales. La herramienta generará informes resumidos a partir de los informes de depuración sin encriptar.

La herramienta de pruebas locales está disponible para su descarga en los archivos JAR de Cloud Functions en GitHub. Debería llamarse LocalTestingTool_{version}.jar.

1.4. Verifica que esté instalado el JRE de JAVA (servicio de pruebas locales y agregación)

Abre "Terminal" y usa java --version para verificar si tu máquina tiene instalado Java o openJDK.

Comprueba la versión de Java. Verifica la versión de Java.

Si no está instalado, puedes descargarlo e instalarlo desde el sitio de Java o el sitio de openJDK.

1.5. Descarga aggregatable_report_converter (Servicio de pruebas y agregación locales)

Puedes descargar una copia de aggregatable_report_converter desde el repositorio de GitHub de las demostraciones de Privacy Sandbox. En el repositorio de GitHub, se menciona el uso de IntelliJ o Eclipse, pero ninguno de los dos es obligatorio. Si no usas estas herramientas, descarga el archivo JAR en tu entorno local.

1.6. Configura un entorno de Cloud Platform (servicio de agregación)

El Servicio de agregación requiere el uso de un entorno de ejecución confiable que utilice un proveedor de servicios en la nube. En este codelab, el servicio de agregación se implementará en Google Cloud, pero AWS también es compatible.

Sigue las instrucciones de implementación en GitHub para configurar la CLI de gcloud, descargar los módulos y los archivos binarios de Terraform, y crear recursos de Google Cloud para el Servicio de agregación.

Pasos clave en las instrucciones de implementación:

  1. Configura la CLI de "gcloud" y Terraform en tu entorno.
  2. Crea un bucket de Cloud Storage para almacenar el estado de Terraform.
  3. Descarga las dependencias.
  4. Actualiza adtech_setup.auto.tfvars y ejecuta el Terraform adtech_setup. Consulta el Apéndice para ver un ejemplo de archivo adtech_setup.auto.tfvars. Toma nota del nombre del bucket de datos que se crea aquí, ya que se usará en el codelab para almacenar los archivos que crearemos.
  5. Actualiza dev.auto.tfvars, suplanta la identidad de la cuenta de servicio de implementación y ejecuta el Terraform dev. Consulta el Apéndice para ver un ejemplo de archivo dev.auto.tfvars.
  6. Una vez que se complete la implementación, captura el frontend_service_cloudfunction_url del resultado de Terraform, que se necesitará para realizar solicitudes al servicio de agregación en pasos posteriores.

1.7. Completa la incorporación del Servicio de agregación (Servicio de agregación)

El Servicio de agregación requiere la incorporación a los coordinadores para poder usar el servicio. Completa el formulario de incorporación del Servicio de agregación proporcionando tu sitio de informes y otra información, seleccionando "Google Cloud" y, luego, ingresando la dirección de tu cuenta de servicio. Esta cuenta de servicio se crea en el requisito previo anterior (1.6. Configura un entorno de Google Cloud). (Sugerencia: Si usas los nombres predeterminados proporcionados, esta cuenta de servicio comenzará con "worker-sa@").

El proceso de incorporación puede tardar hasta 2 semanas en completarse.

1.8. Determina tu método para llamar a los extremos de la API (servicio de agregación)

En este codelab, se proporcionan 2 opciones para llamar a los extremos de la API de Aggregation Service: cURL y Postman. cURL es la forma más rápida y sencilla de llamar a los extremos de la API desde tu terminal, ya que requiere una configuración mínima y no necesita software adicional. Sin embargo, si no quieres usar cURL, puedes usar Postman para ejecutar y guardar solicitudes a la API para usarlas en el futuro.

En la sección 3.2 Uso del Servicio de agregación, encontrarás instrucciones detalladas para usar ambas opciones. Puedes obtener una vista previa ahora para determinar qué método usarás. Si seleccionas Postman, realiza la siguiente configuración inicial.

1.8.1. Configurar espacio de trabajo

Regístrate para obtener una cuenta de Postman. Una vez que te registres, se creará automáticamente un espacio de trabajo para ti.

Un espacio de trabajo de Postman Un espacio de trabajo de Postman

Si no se crea un espacio de trabajo para ti, ve al elemento de navegación superior "Espacios de trabajo" y selecciona "Crear espacio de trabajo".

Selecciona "Espacio de trabajo en blanco", haz clic en Siguiente y asígnale el nombre "GCP Privacy Sandbox". Selecciona “Personal” y haz clic en “Crear”.

Descarga el archivo de configuración JSON y los archivos de entorno global del espacio de trabajo preconfigurado.

Importa ambos archivos JSON a "Mi espacio de trabajo" con el botón "Importar".

El botón Importar. El botón Importar.

Esto creará la colección "GCP Privacy Sandbox" junto con las solicitudes HTTP createJob y getJob.

1.8.2. Configura la autorización

Haz clic en la colección "GCP Privacy Sandbox" y navega a la pestaña "Authorization".

Botón de autorización Botón de autorización.

Usarás el método "Bearer Token". Desde tu entorno de Terminal, ejecuta este comando y copia el resultado.

gcloud auth print-identity-token

Luego, pega este valor del token en el campo "Token" de la pestaña de autorización de Postman:

La El campo "Token".

1.8.3. Cómo configurar el entorno

Navega a "Environment quick look" en la esquina superior derecha:

el botón de vistazo rápido del entorno. El botón de vista rápida del entorno.

Haz clic en "Editar" y actualiza el "Valor actual" de "entorno", "región" y "cloud-function-id":

Establece los valores actuales. Establece los valores actuales.

Por ahora, puedes dejar "request-id" en blanco, ya que lo completaremos más adelante. Para los demás campos, usa los valores de frontend_service_cloudfunction_url, que se devolvieron tras la finalización correcta de la implementación de Terraform en el requisito previo 1.6. La URL sigue este formato: https://--frontend-service--uc.a.run.app

2. 2. Codelab de Local Testing

Tiempo estimado para completar la actividad: Menos de 1 hora

Puedes usar la herramienta de pruebas locales en tu máquina para realizar la agregación y generar informes de resumen con los informes de depuración sin encriptar. Antes de comenzar, verifica que hayas completado todos los requisitos previos etiquetados como "Pruebas locales".

Pasos del codelab

Paso 2.1: Informe de activación: Activa la generación de informes de Private Aggregation para poder recopilar el informe.

Paso 2.2: Create Debug AVRO Report: Convierte el informe JSON recopilado en un informe con formato AVRO. Este paso será similar a cuando las tecnologías publicitarias recopilan los informes de los extremos de informes de la API y convierten los informes JSON en informes con formato AVRO.

Paso 2.3: Recupera las claves de Bucket: Las claves de Bucket son diseñadas por las plataformas de tecnología publicitaria. En este codelab, como los buckets están predefinidos, recupera las claves de bucket tal como se proporcionan.

Paso 2.4. Create Output Domain AVRO: Una vez que se recuperan las claves del bucket, crea el archivo AVRO de Output Domain.

Paso 2.5: Crear informe de resumen: Usa la herramienta de pruebas locales para crear informes de resumen en el entorno local.

Paso 2.6. Revisa los informes de resumen: Revisa el informe de resumen que crea la herramienta de prueba local.

2.1. Informe de activador

Para activar un informe de agregación privada, puedes usar el sitio de demostración de Privacy Sandbox (https://privacy-sandbox-demos-news.dev/?env=gcp) o tu propio sitio (p.ej., https://adtechexample.com). Si usas tu propio sitio y no completaste la inscripción y la certificación, ni la incorporación al Servicio de agregación, deberás usar una marca de Chrome y un parámetro de CLI.

Para esta demostración, usaremos el sitio de demostración de Privacy Sandbox. Sigue el vínculo para ir al sitio y, luego, podrás ver los informes en chrome://private-aggregation-internals:

Página de Chrome Internals Página de Chrome Internals.

El informe que se envía al extremo {reporting-origin}/.well-known/private-aggregation/debug/report-shared-storage también se encuentra en el "Cuerpo del informe" de los informes que se muestran en la página chrome://internals.

Es posible que veas muchos informes aquí, pero para este codelab, usa el informe agregable que es específico de Google Cloud y que genera el extremo de depuración. La "URL del informe" contendrá "/debug/", y el aggregation_coordinator_origin field del "Cuerpo del informe" contendrá esta URL: https://publickeyservice.msmt.gcp.privacysandboxservices.com.

Es el informe de depuración de Google Cloud. Informe de depuración de Google Cloud.

2.2. Crea un informe agregable de depuración

Copia el informe que se encuentra en el "Cuerpo del informe" de chrome://private-aggregation-internals y crea un archivo JSON en la carpeta privacy-sandbox-demos/tools/aggregatable_report_converter/out/artifacts/aggregatable_report_converter_jar (dentro del repositorio descargado en el requisito previo 1.5).

En este ejemplo, usamos vim, ya que usamos Linux. Sin embargo, puedes usar el editor de texto que quieras.

vim report.json

Pega el informe en report.json y guarda el archivo.

Es el código JSON del informe.: Es el código JSON del informe.

Una vez que lo tengas, usa aggregatable_report_converter.jar para crear el informe agregable de depuración. Esto crea un informe agregable llamado report.avro en tu directorio actual.

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

2.3. Recupera la clave del bucket del informe

Para crear el archivo output_domain.avro, necesitas las claves del bucket que se pueden recuperar de los informes.

Las claves de discretización están diseñadas por la tecnología publicitaria. Sin embargo, en este caso, el sitio de la demostración de Privacy Sandbox crea las claves de discretización. Dado que la agregación privada para este sitio está en modo de depuración, podemos usar debug_cleartext_payload del "Cuerpo del informe" para obtener la clave del bucket.

Copia el debug_cleartext_payload del cuerpo del informe.

Depura la carga útil de texto sin cifrar. Depura la carga útil de texto simple.

Abre goo.gle/ags-payload-decoder, pega tu debug_cleartext_payload en el cuadro “INPUT” y haz clic en “Decode”.

El botón de decodificación. El botón de decodificación.

La página devuelve el valor decimal de la clave del bucket. A continuación, se muestra una clave de bucket de ejemplo.

Es una clave de bucket de muestra. Es una clave de bucket de muestra.

2.4. Crea el AVRO del dominio de salida

Ahora que tenemos la clave del bucket, creemos el output_domain.avro en la misma carpeta en la que hemos estado trabajando. Verifica que reemplazaste la clave del bucket por la que recuperaste.

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

La secuencia de comandos crea el archivo output_domain.avro en tu carpeta actual.

2.5. Crea informes de resumen con la herramienta de pruebas locales

Usaremos LocalTestingTool_{version}.jar, que se descargó en el requisito previo 1.3, para crear los informes de resumen con el siguiente comando. Reemplaza {version} por la versión que descargaste. Recuerda mover LocalTestingTool_{version}.jar al directorio actual o agregar una ruta relativa para hacer referencia a su ubicación actual.

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

Deberías ver un resultado similar al siguiente cuando se ejecute el comando. Una vez que se complete este proceso, se creará un informe output.avro.

AVRO de salida AVRO de salida

2.6. Revisa el Informe de resumen

El informe de resumen que se crea está en formato AVRO. Para poder leerlo, debes convertirlo de AVRO a un formato JSON. Lo ideal sería que la tecnología publicitaria escribiera código para convertir los informes de AVRO nuevamente a JSON.

Usaremos aggregatable_report_converter.jar para convertir el informe AVRO de nuevo a JSON.

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

Esto devuelve un informe similar al siguiente. Junto con un informe output.json creado en el mismo directorio.

JSON de salida JSON de salida

¡Codelab completado!

Resumen: Recopilaste un informe de depuración, creaste un archivo de dominio de salida y generaste un informe de resumen con la herramienta de pruebas locales, que simula el comportamiento de agregación del Servicio de agregación.

Próximos pasos: Ahora que experimentaste con la herramienta de pruebas locales, puedes probar el mismo ejercicio con una implementación activa del Servicio de agregación en tu propio entorno. Vuelve a revisar los requisitos previos para asegurarte de que configuraste todo para el modo "Servicio de agregación" y, luego, continúa con el paso 3.

3. 3. Codelab sobre el servicio de agregación

Tiempo estimado para completar la actividad: 1 hora

Antes de comenzar, verifica que hayas completado todos los requisitos previos etiquetados como "Servicio de agregación".

Pasos del codelab

Paso 3.1: Creación de entrada del Servicio de agregación: Crea los informes del Servicio de agregación que se agrupan para el Servicio de agregación.

  • Paso 3.1.1 Informe de activador
  • Paso 3.1.2: Recopila informes agregables
  • Paso 3.1.3 Convierte informes a AVRO
  • Paso 3.1.4 Crea el AVRO de output_domain
  • Paso 3.1.5: Mueve los informes al bucket de Cloud Storage

Paso 3.2: Uso del servicio de agregación: Usa la API del servicio de agregación para crear informes de resumen y revisarlos.

  • Paso 3.2.1 Usa el extremo createJob para el procesamiento por lotes
  • Paso 3.2.2: Usa el extremo getJob para recuperar el estado del lote
  • Paso 3.2.3: Revisa el Informe de resumen

3.1. Creación de entradas del servicio de agregación

Continúa para crear los informes AVRO para el procesamiento por lotes en el Servicio de agregación. Los comandos de shell de estos pasos se pueden ejecutar en Cloud Shell de Google Cloud (siempre y cuando las dependencias de los requisitos previos se clonen en tu entorno de Cloud Shell) o en un entorno de ejecución local.

3.1.1. Informe de activador

Sigue el vínculo para ir al sitio y, luego, podrás ver los informes en chrome://private-aggregation-internals:

Página de Chrome Internals Página de Chrome Internals

El informe que se envía al extremo {reporting-origin}/.well-known/private-aggregation/debug/report-shared-storage también se encuentra en el "Cuerpo del informe" de los informes que se muestran en la página chrome://internals.

Es posible que veas muchos informes aquí, pero para este codelab, usa el informe agregable que es específico de Google Cloud y que genera el extremo de depuración. La "URL del informe" contendrá "/debug/", y el aggregation_coordinator_origin field del "Cuerpo del informe" contendrá esta URL: https://publickeyservice.msmt.gcp.privacysandboxservices.com.

Es el informe de depuración de Google Cloud. Informe de depuración de Google Cloud.

3.1.2. Recopila informes agregables

Recopila tus informes agregables de los extremos .well-known de la API correspondiente.

  • Private Aggregation: {reporting-origin}/.well-known/private-aggregation/report-shared-storage
  • Attribution Reporting - Informe de resumen: {reporting-origin}/.well-known/attribution-reporting/report-aggregate-attribution

En este codelab, recopilamos el informe de forma manual. En producción, se espera que las tecnologías publicitarias recopilen y conviertan los informes de forma programática.

Copiemos el informe JSON en el "Cuerpo del informe" de chrome://private-aggregation-internals.

En este ejemplo, usamos vim, ya que usamos Linux. Sin embargo, puedes usar el editor de texto que quieras.

vim report.json

Pega el informe en report.json y guarda el archivo.

Informe en formato JSON Informe en formato JSON

3.1.3. Convierte informes a AVRO

Los informes que se reciben de los extremos de .well-known están en formato JSON y deben convertirse al formato de informe AVRO. Una vez que tengas el informe en formato JSON, navega hasta donde se almacena report.json y usa aggregatable_report_converter.jar para crear el informe depurable agregable. Esto crea un informe agregable llamado report.avro en tu directorio actual.

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

3.1.4. Crea el AVRO de output_domain

Para crear el archivo output_domain.avro, necesitas las claves del bucket que se pueden recuperar de los informes.

Las claves de discretización están diseñadas por la tecnología publicitaria. Sin embargo, en este caso, el sitio de la demostración de Privacy Sandbox crea las claves de discretización. Dado que la agregación privada para este sitio está en modo de depuración, podemos usar debug_cleartext_payload del "Cuerpo del informe" para obtener la clave del bucket.

Copia el debug_cleartext_payload del cuerpo del informe.

Depura la carga útil de texto sin cifrar. Depura la carga útil de texto simple.

Abre goo.gle/ags-payload-decoder, pega tu debug_cleartext_payload en el cuadro “INPUT” y haz clic en “Decode”.

El botón de decodificación. El botón de decodificación.

La página devuelve el valor decimal de la clave del bucket. A continuación, se muestra una clave de bucket de ejemplo.

Es una clave de bucket de muestra. Es una clave de bucket de muestra.

Ahora que tenemos la clave del bucket, creemos el output_domain.avro en la misma carpeta en la que hemos estado trabajando. Verifica que reemplazaste la clave del bucket por la que recuperaste.

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

La secuencia de comandos crea el archivo output_domain.avro en tu carpeta actual.

3.1.5. Mueve los informes al bucket de Cloud Storage

Una vez que se creen los informes AVRO y el dominio de salida, procede a moverlos al bucket en Cloud Storage (que anotaste en el requisito previo 1.6).

Si tienes configurada la CLI de gcloud en tu entorno local, usa los siguientes comandos para copiar los archivos en las carpetas correspondientes.

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

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

De lo contrario, sube los archivos a tu bucket de forma manual. Crea una carpeta llamada "reports" y sube el archivo report.avro allí. Crea una carpeta llamada "output_domains" y sube el archivo output_domain.avro allí.

3.2. Uso del Servicio de agregación

Recuerda que, en el requisito previo 1.8, seleccionaste curl o Postman para realizar solicitudes a la API de los extremos del servicio de agregación. A continuación, se incluyen las instrucciones para ambas opciones.

Si tu trabajo falla con un error, consulta nuestra documentación de solución de problemas en GitHub para obtener más información sobre cómo proceder.

3.2.1. Usa el extremo createJob para el procesamiento por lotes

Usa cualquiera de las siguientes instrucciones de curl o Postman para crear un trabajo.

curl

En tu "Terminal", crea un archivo de cuerpo de solicitud (body.json) y pega el siguiente objeto JSON. Asegúrate de actualizar los valores de los marcadores de posición. Consulta esta documentación de la API para obtener más información sobre lo que representa cada campo.

{
    "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": "<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"
    }
}

Ejecuta la siguiente solicitud. Reemplaza los marcadores de posición en la URL de la solicitud de curl con los valores de frontend_service_cloudfunction_url, que se genera después de que se completa correctamente la implementación de Terraform en el requisito previo 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

Deberías recibir una respuesta HTTP 202 una vez que el Servicio de agregación acepte la solicitud. Los otros códigos de respuesta posibles se documentan en las especificaciones de la API.

Cartero

Para el extremo createJob, se requiere un cuerpo de solicitud para proporcionar al Servicio de agregación la ubicación y los nombres de archivo de los informes agregables, los dominios de salida y los informes de resumen.

Navega a la pestaña "Cuerpo" de la solicitud createJob:

Pestaña Cuerpo Pestaña Cuerpo

Reemplaza los marcadores de posición dentro del JSON proporcionado. Para obtener más información sobre estos campos y lo que representan, consulta la documentación de la API.

{
    "job_request_id": "<job_request_id>",
    "input_data_blob_prefix": "<report_folder>/",
    "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": "<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"
    }
}

"Envía" la solicitud a la API de createJob:

Botón Enviar Botón Enviar

El código de respuesta se encuentra en la mitad inferior de la página:

Código de respuesta Código de respuesta

Deberías recibir una respuesta HTTP 202 una vez que el Servicio de agregación acepte la solicitud. Los otros códigos de respuesta posibles se documentan en las especificaciones de la API.

3.2.2. Usa el extremo getJob para recuperar el estado del lote

Usa cualquiera de las siguientes instrucciones de curl o Postman para obtener un trabajo.

curl

Ejecuta la siguiente solicitud en tu terminal. Reemplaza los marcadores de posición en la URL por los valores de frontend_service_cloudfunction_url, que es la misma URL que usaste para la solicitud de createJob. Para "job_request_id", usa el valor del trabajo que creaste con el extremo 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>

El resultado debe mostrar el estado de tu solicitud de trabajo con un estado HTTP 200. El "Cuerpo" de la solicitud contiene la información necesaria, como job_status, return_message y error_messages (si el trabajo generó un error).

Cartero

Para verificar el estado de la solicitud de trabajo, puedes usar el extremo getJob. En la sección "Params" de la solicitud getJob, actualiza el valor de job_request_id al job_request_id que se envió en la solicitud createJob.

ID de solicitud de trabajo ID de solicitud de trabajo

"Envía" la solicitud getJob:

Botón Enviar Botón Enviar

El resultado debe mostrar el estado de tu solicitud de trabajo con un estado HTTP 200. El "Cuerpo" de la solicitud contiene la información necesaria, como job_status, return_message y error_messages (si el trabajo generó un error).

Respuesta JSON Respuesta JSON

3.2.3. Revisa el Informe de resumen

Una vez que recibas el informe de resumen en tu bucket de Cloud Storage de salida, podrás descargarlo a tu entorno local. Los informes de resumen están en formato AVRO y se pueden volver a convertir a JSON. Puedes usar aggregatable_report_converter.jar para leer tu informe con este comando.

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

Esto devuelve un JSON de los valores agregados de cada clave de bucket que se parece al siguiente.

Es el informe de resumen. Informe de resumen.

Si tu solicitud de createJob incluye debug_run como verdadero, puedes recibir tu informe de resumen en la carpeta de depuración que se encuentra en output_data_blob_prefix. El informe está en formato AVRO y se puede convertir a JSON con el comando anterior.

El informe contiene la clave de discretización, la métrica sin ruido y el ruido que se agrega a la métrica sin ruido para formar el informe de resumen. El informe es similar al siguiente.

Informe de datos contaminados Informe de ruido

Las anotaciones también contienen "in_reports" o "in_domain" (o ambas), lo que significa lo siguiente:

  • in_reports: La clave de discretización está disponible en los informes agregables.
  • in_domain: La clave del bucket está disponible dentro del archivo AVRO output_domain.

¡Codelab completado!

Resumen: Implementaste el Servicio de agregación en tu propio entorno de nube, recopilaste un informe de depuración, creaste un archivo de dominio de salida, almacenaste estos archivos en un bucket de Cloud Storage y ejecutaste un trabajo correctamente.

Próximos pasos: Sigue usando el Servicio de agregación en tu entorno o borra los recursos de Cloud que acabas de crear siguiendo las instrucciones de limpieza del paso 4.

4. 4. Corrección

Para borrar los recursos creados para el Servicio de agregación con Terraform, usa el comando destroy en las carpetas adtech_setup y dev (o en otro entorno):

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

Para borrar el bucket de Cloud Storage que contiene tus informes agregables y de resumen, sigue estos pasos:

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

También puedes revertir la configuración de cookies de Chrome del requisito previo 1.2 a su estado anterior.

5. 5. Apéndice

Archivo adtech_setup.auto.tfvars de ejemplo

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

Archivo dev.auto.tfvars de ejemplo

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