Se usó la API de Cloud Translation para traducir esta página.

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 el espacio confidencial 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 desee usarlo. Específicamente, la empresa Primus tiene un modelo de aprendizaje automático que solo se lanzaría a una carga de trabajo que se ejecuta en Confidential Space, lo que le permite a Primus retener el control total de su propiedad intelectual. Company Secundus será el operador de la carga de trabajo y ejecutará la carga de trabajo de aprendizaje automático en un espacio confidencial. 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 escribe el código de la carga de trabajo y un colaborador que quiere 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 pueda compartir su modelo de AA propietario con otra sin perder el control sobre su propiedad intelectual

Requisitos

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

Roles involucrados en la configuración de un espacio confidencial

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

Configura los recursos de nube necesarios con un modelo de aprendizaje automático
Cómo escribir el código de la carga de trabajo
Publica la imagen de la carga de trabajo
Configura la política de Workload Identity Pool para proteger el modelo de AA contra un operador no confiable

Secundus Company será el operador y será responsable de lo siguiente:

Configura los recursos en la nube necesarios para almacenar las imágenes de muestra que usa la carga de trabajo y los resultados
Ejecutar la carga de trabajo de AA en Confidential Space con el modelo que proporciona Primus

Cómo funciona el Espacio confidencial

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 del grupo de identidades de carga de trabajo. Ofrece un token de servicio de verificador de certificación con reclamos de entorno y carga de trabajo.
Si los reclamos 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, 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 la opera y ejecuta 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 requeridas 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 artículo 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 de 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 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 nube existentes en el proyecto Primus. Si se configura la variable, se usará el recurso de nube existente correspondiente del proyecto Primus. Si no se establece la variable, el nombre del recurso de nube se generará a partir de project-name y se creará un nuevo recurso de nube 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`	El grupo de identidades para cargas de trabajo (WIP) de Primus que valida los reclamos
`$PRIMUS_WIP_PROVIDER`	El proveedor del grupo de identidades de las cargas de trabajo de Primus, que incluye la condición de autorización que se usará para los tokens firmados por el servicio de Verificador de certificación
`$PRIMUS_SERVICE_ACCOUNT`	Cuenta de servicio de Primus que `$PRIMUS_WORKLOAD_IDENTITY_POOL` usa para acceder a los recursos protegidos (modelo de IA 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 al que se enviará la imagen de Docker de la carga de trabajo.

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

`$SECUNDUS_INPUT_STORAGE_BUCKET`	El bucket que almacena las imágenes de muestra que Secundus desea clasificar con el modelo que proporcionó Primus.
`$SECUNDUS_RESULT_STORAGE_BUCKET`	Es el bucket que almacena los resultados de la carga de trabajo.
`$WORKLOAD_IMAGE_NAME`	Es el 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`	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. Puedes consultar esta guía para otorgar roles de IAM con GCP Console:
Para $PRIMUS_PROJECT_ID, necesitarás los roles de administrador de almacenamiento, administrador de Artifact Registry, administrador de cuentas de servicio y administrador de grupos de Workload Identity de IAM.
Para $SECUNDUS_PROJECT_ID, necesitarás los roles de administrador de Compute, administrador de almacenamiento, administrador de cuentas de servicio, administrador de grupos de Workload Identity 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 los recursos.

source config_env.sh

Configura los recursos de Primus Company

Como parte de este paso, configurarás los recursos de 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 Workload Identity ($PRIMUS_WORKLOAD_IDENTITY_POOL) para validar los reclamos según las condiciones de los atributos configuradas en su proveedor.
Cuenta de servicio ($PRIMUS_SERVICEACCOUNT) adjunta al grupo de identidad de la carga de trabajo ($PRIMUS_WORKLOAD_IDENTITY_POOL) mencionado anteriormente con acceso de IAM para leer datos del bucket de almacenamiento en la nube (con el rol objectViewer) y para conectar esta cuenta de servicio al grupo de identidad de la carga de trabajo (con el rol roles/iam.workloadIdentityUser).

Como parte de esta configuración de recursos en la nube, usaremos un modelo de TensorFlow. Podemos guardar todo el modelo que incluye la arquitectura, los pesos y la configuración de entrenamiento del modelo en un archivo ZIP. A los efectos 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 nube. 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 para ejecutar inferencias de 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.

Algunas imágenes de muestra están 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 necesarios. Ejecuta la siguiente secuencia de comandos para crear una cuenta de servicio de carga de trabajo en el proyecto Secundus. La VM que ejecuta la carga de trabajo de ML usaría esta cuenta de servicio.

Esta cuenta de servicio de la carga 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 Cloud Storage $SECUNDUS_INPUT_STORAGE_BUCKET.
objectUser para escribir el resultado de la carga de trabajo en el bucket de Cloud Storage $SECUNDUS_RESULT_STORAGE_BUCKET.

./create_workload_service_account.sh

Crea una carga de trabajo

Como parte de este paso, crearás una imagen de Docker de carga de trabajo. Primus sería el autor de la carga de trabajo. La carga de trabajo que se usa en este codelab es un código de Python de aprendizaje automático que accede al modelo de aprendizaje automático 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 los atributos requeridos 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.

Este es el método run_inference() de la carga de trabajo que se creará y usará en este codelab. Puedes encontrar todo el código 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 realicen los siguientes pasos:

Crea Artifact Registry($PRIMUS_ARTIFACT_REGISTRY) que pertenece a Primus.
Actualiza el código de la carga de trabajo con los nombres de los recursos necesarios.
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í está el Dockerfile que se usa para este codelab.
Compila y publica la imagen de Docker en Artifact Registry ($PRIMUS_ARTIFACT_REGISTRY) que pertenece a Primus.
Otorga permiso de lectura a $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 de 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 debe verificar 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 que accedan 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
Who: Un operador de confianza

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

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

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

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 del contenedor de la 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 IA 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}]}

Para cada imagen de muestra en un bucket de almacenamiento de Secundus, verás una entrada en los resultados. 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 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 por humanos, 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 un modelo propiedad de Primus solo se publica en 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 pertenece a Primus mientras Primus retiene 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 diferente de su propio repositorio de artefactos que Primus no autorizó. El grupo de Workload Identity 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, fallará. Para ver el error, borra el archivo de resultados original y la instancia de VM, y, luego, intenta volver a ejecutar la carga de trabajo.

Asegúrate de que haya una nueva imagen de Docker publicada 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) le haya otorgado al lector de registro de artefactos permiso para leer esta nueva imagen de carga de trabajo. Esto se hace para garantizar que la carga de trabajo no se cierre 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

Establece el proyecto en $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).
Grupo de identidades de cargas de trabajo de Primus ($PRIMUS_WORKLOAD_IDENTITY_POOL).
Cuenta de servicio de la carga de trabajo de Secundus ($WORKLOAD_SERVICEACCOUNT).
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 ya terminaste de explorar, considera borrar tu proyecto.

Ve a la consola de Cloud Platform.
Selecciona el proyecto que deseas cerrar y, luego, haz clic en "Borrar" en la parte superior. De esta forma, se programará la eliminación del proyecto.

¿Qué sigue?

Consulta algunos de estos codelabs similares…