Protege los modelos de AA y la propiedad intelectual con Confidential Space

1. Descripción general

Confidential Space ofrece un entorno seguro para la colaboración entre varias partes. En este codelab, se muestra cómo se puede usar Confidential Space para proteger la propiedad intelectual sensible, como los modelos de aprendizaje automático.

En este codelab, usarás Confidential Space para permitir que una empresa comparta de forma segura su modelo de aprendizaje automático propietario con otra empresa que quiera usarlo. Específicamente, Company Primus tiene un modelo de aprendizaje automático que solo se lanzaría para una carga de trabajo que se ejecute en Confidential Space, lo que le permite a Primus retener el control completo de su propiedad intelectual. La empresa Secundus será el operador de la carga de trabajo y ejecutará la carga de trabajo de aprendizaje automático en un Confidential Space. Secundus cargará este modelo y ejecutará una inferencia con datos de muestra que le pertenecen.

Aquí, Primus es el autor de la carga de trabajo que crea el código de la carga de trabajo y un colaborador que desea proteger su propiedad intelectual del operador de carga de trabajo no confiable, Secundus. Secundus es el operador de la carga de trabajo de aprendizaje automático.

Qué aprenderás

Cómo configurar un entorno en el que una parte puede compartir su modelo de AA propietario con otra parte sin perder el control sobre su propiedad intelectual

Requisitos

Un proyecto de Google Cloud Platform
Conocimientos básicos de Google Compute Engine ( codelab), Confidential VMs, contenedores y repositorios remotos
Conocimientos básicos sobre cuentas de servicio, federación de identidades para cargas de trabajo y condiciones de atributos

Roles involucrados en la configuración de Confidential Space

En este codelab, Company Primus será el propietario del recurso y el autor de la carga de trabajo, y será responsable de lo siguiente:

Configura los recursos de Cloud necesarios con un modelo de aprendizaje automático
Escribe el código de la carga de trabajo
Publica la imagen de la carga de trabajo
Configura la política del grupo de identidades de cargas de trabajo para proteger el modelo de AA contra un operador no confiable

Secundus Company será el operador y se encargará de lo siguiente:

Configurar los recursos de Cloud necesarios para almacenar las imágenes de muestra que usa la carga de trabajo y los resultados
Ejecución de la carga de trabajo de AA en Confidential Space con el modelo proporcionado por Primus

Cómo funciona Confidential Space

Cuando ejecutas la carga de trabajo en Confidential Space, se lleva a cabo el siguiente proceso con los recursos configurados:

La carga de trabajo solicita un token de acceso general de Google para el $PRIMUS_SERVICEACCOUNT desde el grupo de identidades para cargas de trabajo. Ofrece un token de servicio de verificador de certificación con reclamos de carga de trabajo y entorno.
Si las declaraciones de medición de la carga de trabajo en el token del servicio de verificador de certificación coinciden con la condición del atributo en el WIP, se muestra el token de acceso para $PRIMUS_SERVICEACCOUNT..
La carga de trabajo usa el token de acceso de la cuenta de servicio asociado con $PRIMUS_SERVICEACCOUNT para acceder al modelo de aprendizaje automático almacenado en el bucket $PRIMUS_INPUT_STORAGE_BUCKET.
La carga de trabajo realiza una operación en los datos que son propiedad de Secundus, y Secundus opera y ejecuta esa carga de trabajo en su proyecto.
La carga de trabajo usa la cuenta de servicio $WORKLOAD_SERVICEACCOUNT para escribir los resultados de esa operación en el bucket $SECUNDUS_RESULT_STORAGE_BUCKET.

2. Configura los recursos de Cloud

Antes de comenzar

Clona este repositorio con el siguiente comando para obtener las secuencias de comandos necesarias que se usan como parte de este codelab.

git clone https://github.com/GoogleCloudPlatform/confidential-space.git

Cambia el directorio de este codelab.

cd confidential-space/codelabs/ml_model_protection/scripts

Asegúrate de haber configurado las variables de entorno del proyecto necesarias como se muestra a continuación. Para obtener más información sobre cómo configurar un proyecto de GCP, consulta este codelab. Puedes consultar este vínculo para obtener detalles sobre cómo recuperar el ID del proyecto y en qué se diferencia del nombre y el número del proyecto.

export PRIMUS_PROJECT_ID=<GCP project id of Primus>
export SECUNDUS_PROJECT_ID=<GCP project id of Secundus>

Habilita la facturación para tus proyectos.
Habilita la API de Confidential Computing y las siguientes APIs para ambos proyectos.

gcloud services enable \
    cloudapis.googleapis.com \
    cloudresourcemanager.googleapis.com \
    cloudshell.googleapis.com \
    container.googleapis.com \
    containerregistry.googleapis.com \
    iam.googleapis.com \
    confidentialcomputing.googleapis.com

Asigna valores a las variables para los nombres de recursos especificados anteriormente con el siguiente comando. Estas variables te permiten personalizar los nombres de los recursos según sea necesario y también usar los recursos existentes si ya se crearon. (p. ej., export PRIMUS_INPUT_STORAGE_BUCKET='my-input-bucket')

Puedes configurar las siguientes variables con nombres de recursos de Cloud existentes en el proyecto de Primus. Si se configura la variable, se usará el recurso de Cloud existente correspondiente del proyecto de Primus. Si no se configura la variable, el nombre del recurso de Cloud se generará a partir del nombre del proyecto y se creará un nuevo recurso de Cloud con ese nombre. A continuación, se muestran las variables admitidas para los nombres de recursos:

`$PRIMUS_INPUT_STORAGE_BUCKET`	Es el bucket que almacena el modelo de aprendizaje automático de Primus.
`$PRIMUS_WORKLOAD_IDENTITY_POOL`	Es el grupo de identidades para cargas de trabajo (WIP) de Primus que valida las declaraciones.
`$PRIMUS_WIP_PROVIDER`	Es el proveedor de grupos de identidades de cargas de trabajo de Primus que incluye la condición de autorización para usar los tokens firmados por el servicio de Attestation Verifier.
`$PRIMUS_SERVICE_ACCOUNT`	Cuenta de servicio de Primus que `$PRIMUS_WORKLOAD_IDENTITY_POOL` usa para acceder a los recursos protegidos (modelo de AA en este codelab). En este paso, tiene permiso para leer el modelo de aprendizaje automático almacenado en el bucket `$PRIMUS_INPUT_STORAGE_BUCKET`.
`$PRIMUS_ARTIFACT_REPOSITORY`	Es el repositorio de artefactos en el que se enviará la imagen de Docker de la carga de trabajo.

Puedes configurar las siguientes variables con nombres de recursos de Cloud existentes en el proyecto de Secundus. Si se configura la variable, se usará el recurso de Cloud existente correspondiente del proyecto de Secundus. Si no se configura la variable, el nombre del recurso de Cloud se generará a partir del nombre del proyecto y se creará un nuevo recurso de Cloud con ese nombre. A continuación, se muestran las variables admitidas para los nombres de recursos:

`$SECUNDUS_INPUT_STORAGE_BUCKET`	Es el bucket que almacena las imágenes de muestra que Secundus desea clasificar con el modelo proporcionado por Primus.
`$SECUNDUS_RESULT_STORAGE_BUCKET`	Es el bucket que almacena los resultados de la carga de trabajo.
`$WORKLOAD_IMAGE_NAME`	Nombre de la imagen del contenedor de la carga de trabajo.
`$WORKLOAD_IMAGE_TAG`	Es la etiqueta de la imagen del contenedor de la carga de trabajo.
`$WORKLOAD_SERVICE_ACCOUNT`	Es la cuenta de servicio que tiene permiso para acceder a la VM confidencial que ejecuta la carga de trabajo.

Necesitarás ciertos permisos para estos dos proyectos, y puedes consultar esta guía sobre cómo otorgar roles de IAM con la consola de GCP:
Para el $PRIMUS_PROJECT_ID, necesitarás los roles de administrador de Storage, administrador de Artifact Registry, administrador de cuentas de servicio y administrador de grupos de identidades para cargas de trabajo de IAM.
Para el $SECUNDUS_PROJECT_ID, necesitarás los roles de administrador de Compute, administrador de Storage, administrador de cuentas de servicio, administrador de grupos de identidades para cargas de trabajo de IAM y administrador de seguridad (opcional).
Ejecuta la siguiente secuencia de comandos para establecer los nombres de las variables restantes en valores basados en el ID de tu proyecto para los nombres de recursos.

source config_env.sh

Configura los recursos de la empresa de Primus

Como parte de este paso, configurarás los recursos de la nube necesarios para Primus. Ejecuta la siguiente secuencia de comandos para configurar los recursos de Primus. Se crearán los siguientes recursos como parte de la ejecución de la secuencia de comandos:

Bucket de Cloud Storage ($PRIMUS_INPUT_STORAGE_BUCKET) para almacenar el modelo de aprendizaje automático de Primus.
Grupo de identidades para cargas de trabajo ($PRIMUS_WORKLOAD_IDENTITY_POOL) para validar las declaraciones según las condiciones de atributos configuradas en su proveedor.
Cuenta de servicio ($PRIMUS_SERVICEACCOUNT) adjunta al grupo de identidades de cargas de trabajo mencionado anteriormente ($PRIMUS_WORKLOAD_IDENTITY_POOL) con acceso a IAM para leer datos del bucket de Cloud Storage (con el rol objectViewer) y para conectar esta cuenta de servicio al grupo de identidades de cargas de trabajo (con el rol roles/iam.workloadIdentityUser).

Como parte de esta configuración de recursos de Cloud, usaremos un modelo de TensorFlow. Podemos guardar todo el modelo, incluida su arquitectura, sus pesos y su configuración de entrenamiento, en un archivo ZIP. Para los fines de este codelab, usaremos el modelo MobileNet V1 entrenado en el conjunto de datos de ImageNet que se encuentra aquí.

./setup_primus_company_resources.sh

La secuencia de comandos mencionada anteriormente configurará el recurso de Cloud. Ahora descargaremos y publicaremos el modelo en el bucket de Cloud Storage que creó la secuencia de comandos.

Descarga el modelo previamente entrenado desde aquí.
Una vez que se descargue, cambia el nombre del archivo tar descargado a model.tar.gz.
Publica el archivo model.tar.gz en el bucket de Cloud Storage con el siguiente comando desde el directorio que contiene el archivo model.tar.gz.

gsutil cp model.tar.gz gs://${PRIMUS_INPUT_STORAGE_BUCKET}/

Configura los recursos de Secundus Company

Como parte de este paso, configurarás los recursos de la nube necesarios para Secundus. Ejecuta la siguiente secuencia de comandos para configurar los recursos de Secundus. Como parte de estos pasos, se crearán los siguientes recursos:

Bucket de Cloud Storage ($SECUNDUS_INPUT_STORAGE_BUCKET) para almacenar las imágenes de muestra y ejecutar inferencias con Secundus.
Bucket de Cloud Storage ($SECUNDUS_RESULT_STORAGE_BUCKET) para almacenar el resultado de la ejecución de la carga de trabajo de AA por parte de Secundus.

Encontrarás algunas imágenes de muestra disponibles aquí para este codelab.

./setup_secundus_company_resources.sh

3. Crear carga de trabajo

Crea una cuenta de servicio de carga de trabajo

Ahora, crearás una cuenta de servicio para la carga de trabajo con los roles y permisos requeridos. Ejecuta el siguiente script para crear una cuenta de servicio de carga de trabajo en el proyecto de Secundus. La VM que ejecuta la carga de trabajo de AA usaría esta cuenta de servicio.

Esta cuenta de servicio de cargas de trabajo ($WORKLOAD_SERVICEACCOUNT) tendrá los siguientes roles:

confidentialcomputing.workloadUser para obtener un token de certificación
logging.logWriter para escribir registros en Cloud Logging.
objectViewer para leer datos del bucket de almacenamiento en la nube $SECUNDUS_INPUT_STORAGE_BUCKET
objectUser para escribir el resultado de la carga de trabajo en el bucket de almacenamiento en la nube $SECUNDUS_RESULT_STORAGE_BUCKET

./create_workload_service_account.sh

Crear carga de trabajo

Como parte de este paso, crearás una imagen de Docker de carga de trabajo. Primus crearía la carga de trabajo. La carga de trabajo que se usa en este codelab es código de Python de aprendizaje automático que accede al modelo de AA almacenado en el bucket de almacenamiento de Primus y ejecuta inferencias con las imágenes de muestra que se almacenan en un bucket de almacenamiento.

Solo las cargas de trabajo que cumplan con las condiciones de atributos requeridas podrán acceder al modelo de aprendizaje automático almacenado en el bucket de almacenamiento de Primus. Estas condiciones de atributos se describen con más detalle en la siguiente sección sobre la autorización de la carga de trabajo.

A continuación, se muestra el método run_inference() de la carga de trabajo que se creará y usará en este codelab. Puedes encontrar el código completo de la carga de trabajo aquí.

def run_inference(image_path, model):
  try:
    # Read and preprocess the image
    image = tf.image.decode_image(tf.io.read_file(image_path), channels=3)
    image = tf.image.resize(image, (128, 128))
    image = tf.image.convert_image_dtype(image, tf.float32)
    image = tf.expand_dims(image, axis=0)

    # Get predictions from the model
    predictions = model(image)
    predicted_class = np.argmax(predictions)

    top_k = 5
    top_indices = np.argsort(predictions[0])[-top_k:][::-1]

    # Convert top_indices to a TensorFlow tensor
    top_indices_tensor = tf.convert_to_tensor(top_indices, dtype=tf.int32)

    # Use TensorFlow tensor for indexing
    top_scores = tf.gather(predictions[0], top_indices_tensor)

    return {
        "predicted_class": int(predicted_class),
        "top_k_predictions": [
            {"class_index": int(idx), "score": float(score)}
            for idx, score in zip(top_indices, top_scores)
        ],
    }
  except Exception as e:
    return {"error": str(e)}

Ejecuta la siguiente secuencia de comandos para crear una carga de trabajo en la que se realizan los siguientes pasos:

Crea un registro de artefactos($PRIMUS_ARTIFACT_REGISTRY) propiedad de Primus.
Actualiza el código de la carga de trabajo con los nombres de los recursos requeridos.
Compila la carga de trabajo de AA y crea un Dockerfile para compilar una imagen de Docker del código de la carga de trabajo. Aquí se encuentra el Dockerfile que se usa para este codelab.
Compila y publica la imagen de Docker en Artifact Registry ($PRIMUS_ARTIFACT_REGISTRY) propiedad de Primus.
Otorga permiso de lectura de $WORKLOAD_SERVICEACCOUNT para $PRIMUS_ARTIFACT_REGISTRY. Esto es necesario para que el contenedor de la carga de trabajo extraiga la imagen de Docker de la carga de trabajo desde Artifact Registry.

./create_workload.sh

Además, las cargas de trabajo se pueden codificar para garantizar que se cargue la versión esperada del modelo de aprendizaje automático. Para ello, se verifica el hash o la firma del modelo antes de usarlo. La ventaja de estas verificaciones adicionales es que garantizan la integridad del modelo de aprendizaje automático. Con esto, el operador de la carga de trabajo también debería actualizar la imagen de la carga de trabajo o sus parámetros cuando se espera que la carga de trabajo use diferentes versiones del modelo de AA.

4. Autoriza y ejecuta la carga de trabajo

Autoriza la carga de trabajo

Primus quiere autorizar cargas de trabajo para acceder a su modelo de aprendizaje automático en función de los atributos de los siguientes recursos:

Qué: Código que se verifica
Dónde: Un entorno seguro
Quién: Un operador de confianza

Primus usa la federación de Workload Identity para aplicar una política de acceso basada en estos requisitos. La federación de identidades para cargas de trabajo te permite especificar condiciones de atributo. Estas condiciones restringen qué identidades pueden autenticarse con el grupo de identidades para cargas de trabajo (WIP). Puedes agregar el servicio de verificador de certificación al WIP como un proveedor de grupos de identidades para cargas de trabajo para presentar mediciones y aplicar la política.

El grupo de identidades para cargas de trabajo ya se creó antes como parte del paso de configuración de los recursos de Cloud. Ahora Primus creará un nuevo proveedor de grupos de identidades para cargas de trabajo de OIDC. El --attribute-condition especificado autoriza el acceso al contenedor de la carga de trabajo. Requiere lo siguiente:

Qué: Se subió la versión más reciente de $WORKLOAD_IMAGE_NAME al repositorio de $PRIMUS_ARTIFACT_REPOSITORY.
Ubicación: El entorno de ejecución confiable de Confidential Space se ejecuta en la imagen de Confidential Space VM totalmente compatible.
Quién: Cuenta de servicio de Secundus $WORKLOAD_SERVICE_ACCOUNT.

export WORKLOAD_IMAGE_DIGEST=$(gcloud artifacts docker images describe ${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/$PRIMUS_PROJECT_ID/$PRIMUS_ARTIFACT_REPOSITORY/$WORKLOAD_IMAGE_NAME:$WORKLOAD_IMAGE_TAG  --format="value(image_summary.digest)" --project ${PRIMUS_PROJECT_ID})

gcloud config set project $PRIMUS_PROJECT_ID

gcloud iam workload-identity-pools providers create-oidc $PRIMUS_WIP_PROVIDER \
  --location="global" \
  --workload-identity-pool="$PRIMUS_WORKLOAD_IDENTITY_POOL" \
  --issuer-uri="https://confidentialcomputing.googleapis.com/" \
  --allowed-audiences="https://sts.googleapis.com" \
  --attribute-mapping="google.subject='assertion.sub'" \
  --attribute-condition="assertion.swname == 'CONFIDENTIAL_SPACE' && 
'STABLE' in assertion.submods.confidential_space.support_attributes && 
assertion.submods.container.image_digest == '${WORKLOAD_IMAGE_DIGEST}' &&
 assertion.submods.container.image_reference == '${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/$PRIMUS_PROJECT_ID/$PRIMUS_ARTIFACT_REPOSITORY/$WORKLOAD_IMAGE_NAME:$WORKLOAD_IMAGE_TAG' && 
'$WORKLOAD_SERVICEACCOUNT@$SECUNDUS_PROJECT_ID.iam.gserviceaccount.com' in assertion.google_service_accounts"

Ejecutar carga de trabajo

Como parte de este paso, ejecutaremos la carga de trabajo en la VM de Confidential Space. Los argumentos de TEE obligatorios se pasan con la marca de metadatos. Los argumentos para el contenedor de carga de trabajo se pasan con la parte "tee-cmd" de la marca. El resultado de la ejecución de la carga de trabajo se publicará en $SECUNDUS_RESULT_STORAGE_BUCKET.

gcloud compute instances create ${WORKLOAD_VM} \
 --confidential-compute-type=SEV \
 --shielded-secure-boot \
 --project=${SECUNDUS_PROJECT_ID} \
 --maintenance-policy=MIGRATE \
 --scopes=cloud-platform --zone=${SECUNDUS_PROJECT_ZONE} \
 --image-project=confidential-space-images \
 --image-family=confidential-space \
 --service-account=${WORKLOAD_SERVICEACCOUNT}@${SECUNDUS_PROJECT_ID}.iam.gserviceaccount.com \
 --metadata  ^~^tee-image-reference=${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/${PRIMUS_PROJECT_ID}/${PRIMUS_ARTIFACT_REPOSITORY}/${WORKLOAD_IMAGE_NAME}:${WORKLOAD_IMAGE_TAG}

Ver resultados

Una vez que la carga de trabajo se complete correctamente, el resultado de la carga de trabajo de AA se publicará en $SECUNDUS_RESULT_STORAGE_BUCKET.

gsutil cat gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

Estos son algunos ejemplos de cómo podrían verse los resultados de la inferencia en imágenes de muestra:

Image: sample_image_1.jpeg, Response: {'predicted_class': 531, 'top_k_predictions': [{'class_index': 531, 'score': 12.08437442779541}, {'class_index': 812, 'score': 10.269512176513672}, {'class_index': 557, 'score': 9.202644348144531}, {'class_index': 782, 'score': 9.08737564086914}, {'class_index': 828, 'score': 8.912498474121094}]}

Image: sample_image_2.jpeg, Response: {'predicted_class': 905, 'top_k_predictions': [{'class_index': 905, 'score': 9.53619384765625}, {'class_index': 557, 'score': 7.928380966186523}, {'class_index': 783, 'score': 7.70129919052124}, {'class_index': 531, 'score': 7.611623287200928}, {'class_index': 906, 'score': 7.021416187286377}]}

Image: sample_image_3.jpeg, Response: {'predicted_class': 905, 'top_k_predictions': [{'class_index': 905, 'score': 6.09878396987915}, {'class_index': 447, 'score': 5.992854118347168}, {'class_index': 444, 'score': 5.9582319259643555}, {'class_index': 816, 'score': 5.502010345458984}, {'class_index': 796, 'score': 5.450454235076904}]}

Verás una entrada en los resultados para cada imagen de muestra en un bucket de almacenamiento de Secundus. Esta entrada incluirá dos datos clave:

Índice de predicted_class: Es un índice numérico que representa la clase a la que el modelo predice que pertenece la imagen.
Top_k_predictions: Proporciona hasta k predicciones para la imagen, clasificadas de la más probable a la menos probable. El valor de k se establece en 5 en este codelab, pero puedes ajustarlo en el código de la carga de trabajo para obtener más o menos predicciones.

Para traducir el índice de clase a un nombre de clase legible, consulta la lista de etiquetas disponibles aquí. Por ejemplo, si ves un índice de clase de 2, corresponde a la etiqueta de clase "tench" en la lista de etiquetas.

En este codelab, demostramos que Primus posee un modelo que solo se lanza a la carga de trabajo que se ejecuta en un TEE. Secundus ejecuta la carga de trabajo de AA en un TEE, y esta carga de trabajo puede consumir el modelo que posee Primus, mientras que Primus conserva el control total sobre el modelo.

Ejecuta una carga de trabajo no autorizada

Secundus cambia la imagen de la carga de trabajo extrayendo una imagen de carga de trabajo diferente de su propio repositorio de artefactos, que no está autorizado por Primus. El grupo de identidades para cargas de trabajo de Primus solo autorizó la imagen de carga de trabajo ${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/$PRIMUS_PROJECT_ID/$PRIMUS_ARTIFACT_REPOSITORY/$WORKLOAD_IMAGE_NAME:$WORKLOAD_IMAGE_TAG.

Vuelve a ejecutar la carga de trabajo

Cuando Secundus intente ejecutar la carga de trabajo original con esta nueva imagen de carga de trabajo, fallará. Para ver el error, borra el archivo de resultados original y la instancia de VM, y, luego, intenta ejecutar la carga de trabajo de nuevo.

Asegúrate de que se haya publicado una nueva imagen de Docker en el registro de artefactos de Secundus (como us-docker.pkg.dev/${SECUNDUS_PROJECT_ID}/custom-image/${WORKLOAD_IMAGE_NAME}:${WORKLOAD_IMAGE_TAG}) y de que la cuenta de servicio de la carga de trabajo ($WORKLOAD_SERVICEACCOUNT) haya otorgado permiso de lectura del registro de artefactos para leer esta nueva imagen de la carga de trabajo. Esto garantiza que la carga de trabajo no salga antes de que la política de WIP de Primus rechace el token que presenta la carga de trabajo.

Borra el archivo de resultados y la instancia de VM existentes

Configura el proyecto como el proyecto de $SECUNDUS_PROJECT_ID.

gcloud config set project $SECUNDUS_PROJECT_ID

Borra el archivo de resultados.

gsutil rm gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

Borra la instancia de Confidential VM.

gcloud compute instances delete ${WORKLOAD_VM} --zone=${SECUNDUS_PROJECT_ZONE}

Ejecuta la carga de trabajo no autorizada:

gcloud compute instances create ${WORKLOAD_VM} \
 --confidential-compute-type=SEV \
 --shielded-secure-boot \
 --maintenance-policy=MIGRATE \
 --scopes=cloud-platform --zone=${SECUNDUS_PROJECT_ZONE} \
 --image-project=confidential-space-images \
 --image-family=confidential-space \
 --service-account=${WORKLOAD_SERVICEACCOUNT}@${SECUNDUS_PROJECT_ID}.iam.gserviceaccount.com \
 --metadata  ^~^tee-image-reference=us-docker.pkg.dev/${SECUNDUS_PROJECT_ID}/custom-image/${WORKLOAD_IMAGE_NAME}:${WORKLOAD_IMAGE_TAG}

Ver error

En lugar de los resultados de la carga de trabajo, verás un error (The given credential is rejected by the attribute condition).

gsutil cat gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

5. Limpieza

Aquí se encuentra la secuencia de comandos que se puede usar para limpiar los recursos que creamos como parte de este codelab. Como parte de esta limpieza, se borrarán los siguientes recursos:

Bucket de almacenamiento de entrada de Primus ($PRIMUS_INPUT_STORAGE_BUCKET).
Cuenta de servicio de Primus ($PRIMUS_SERVICEACCOUNT).
Es el repositorio de artefactos de Primus ($PRIMUS_ARTIFACT_REPOSITORY).
Es el grupo de identidades para cargas de trabajo de Primus ($PRIMUS_WORKLOAD_IDENTITY_POOL).
Cuenta de servicio de la carga de trabajo de Secundus ($WORKLOAD_SERVICEACCOUNT).
Es el bucket de almacenamiento de entrada de Secundus ($SECUNDUS_INPUT_STORAGE_BUCKET)).
Instancias de procesamiento de cargas de trabajo.
Bucket de almacenamiento de resultados de Secundus ($SECUNDUS_RESULT_STORAGE_BUCKET).

$ ./cleanup.sh

Si terminaste de explorar, considera borrar tu proyecto.

Ve a Cloud Platform Console.
Selecciona el proyecto que deseas cerrar y, luego, haz clic en "Borrar" en la parte superior para programar su eliminación.

¿Qué sigue?

Consulta algunos de estos codelabs similares…