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 de propiedad con otra empresa que quiera usar el modelo. 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 mantener el control total sobre 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 a Secundus.

Aquí, Primus es el autor de la carga de trabajo y un colaborador que quiere proteger su propiedad intelectual del operador de cargas 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 propio 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), Confidential VM, contenedores y repositorios remotos
• Conocimientos básicos sobre las cuentas de servicio, la federación de identidades para cargas de trabajo y las condiciones de los atributos.

Roles involucrados en un entorno de Confidential Space

En este codelab, la Empresa Primus será la propietaria de los recursos y la de autor de la carga de trabajo, y será responsable de lo siguiente:

1. Configurar los recursos de nube necesarios con un modelo de aprendizaje automático
2. Escribe el código de la carga de trabajo
3. Publica la imagen de carga de trabajo
4. Configuración de la política de grupo de Workload Identity para proteger el modelo de AA de un operador no confiable

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

1. Configurar los recursos de nube necesarios para almacenar las imágenes de muestra que utiliza la carga de trabajo y los resultados
2. Cómo ejecutar la carga de trabajo de AA en un espacio confidencial con el modelo que proporciona 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:

1. La carga de trabajo solicita un token de acceso general de Google para $PRIMUS_SERVICEACCOUNT del grupo de Workload Identity. Ofrece un token de servicio del verificador de certificación con reclamaciones de cargas de trabajo y de entorno.
2. Si las reclamaciones de medición de cargas de trabajo en el token del servicio del verificador de certificación coinciden con la condición del atributo en el trabajo en curso, se muestra el token de acceso para $PRIMUS_SERVICEACCOUNT..
3. 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.
4. 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.
5. 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 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 establecido las variables de entorno necesarias del proyecto 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 esta página 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.
• Habilitar 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 los recursos especificados anteriormente con el siguiente comando. Estas variables te permiten personalizar los nombres de los recursos según sea necesario y, además, usar los recursos existentes si ya se crearon. (p. ej. export PRIMUS_INPUT_STORAGE_BUCKET='my-input-bucket')

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

$PRIMUS_INPUT_STORAGE_BUCKET	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 reclamaciones.
$PRIMUS_WIP_PROVIDER	El proveedor de grupos de identidades para cargas de trabajo de Primus, que incluye la condición de autorización para usar los tokens firmados por el servicio del verificador de certificación.
$PRIMUS_SERVICE_ACCOUNT	Cuenta de servicio de Primus que usa $PRIMUS_WORKLOAD_IDENTITY_POOL 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	El repositorio de artefactos al que se enviará la imagen de Docker de la carga de trabajo.

2. Puedes establecer las siguientes variables con nombres de recursos de nube existentes en el proyecto de Secundus. Si se configura la variable, se usará el recurso de nube existente correspondiente del proyecto de Secundus. Si no se establece la variable, el nombre del recurso en la nube se generará a partir del nombre del proyecto y se creará un nuevo recurso en la 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 proporciona Primus.
$SECUNDUS_RESULT_STORAGE_BUCKET	El bucket que almacena los resultados de la carga de trabajo.
$WORKLOAD_IMAGE_NAME	El nombre de la imagen de contenedor de la carga de trabajo.
$WORKLOAD_IMAGE_TAG	La etiqueta de la imagen de contenedor de la carga de trabajo.
$WORKLOAD_SERVICE_ACCOUNT	La cuenta de servicio que tiene permiso para acceder a la Confidential VM que ejecuta la carga de trabajo.

• Necesitarás ciertos permisos para estos dos proyectos. Puedes consultar esta guía sobre cómo otorgar roles de IAM con la consola de GCP:
• Para $PRIMUS_PROJECT_ID, necesitarás administrador de almacenamiento, administrador de Artifact Registry, administrador de la cuenta de servicio y administrador de IAM Workload Identity Pool Admin.
• Para el $SECUNDUS_PROJECT_ID, necesitarás administrador de Compute, administrador de almacenamiento, administrador de cuenta de servicio, administrador de grupo de identidades para cargas de trabajo de IAM y administrador de seguridad (opcional).
• Ejecuta la siguiente secuencia de comandos para establecer los nombres de variables restantes en valores basados en el ID del proyecto para los nombres de recursos.

source config_env.sh

Configura los recursos de Primus Company

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

• 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 reclamaciones según las condiciones de atributos configuradas en el proveedor.
• La cuenta de servicio ($PRIMUS_SERVICEACCOUNT) vinculada al grupo de identidades para cargas de trabajo ($PRIMUS_WORKLOAD_IDENTITY_POOL) mencionado anteriormente con acceso de IAM para leer datos del bucket de Cloud Storage (con el rol objectViewer) y para conectar esta cuenta de servicio al grupo de identidades para cargas de trabajo (con el rol roles/iam.workloadIdentityUser).

Como parte de la configuración de los recursos en la nube, usaremos un modelo de TensorFlow. Podemos guardar todo el modelo en un archivo ZIP, incluidos sus pesos, su arquitectura y su configuración de entrenamiento. A los fines de este codelab, usaremos el modelo MobileNet V1 entrenado con el conjunto de datos 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.

1. Descarga el modelo previamente entrenado desde aquí.
2. Una vez descargado, cambia el nombre del archivo tar descargado a model.tar.gz.
3. 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 en la nube necesarios para Secundus. Ejecuta la siguiente secuencia de comandos a fin de configurar los recursos para 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 ejemplo están disponibles aquí para este codelab.

./setup_secundus_company_resources.sh

3. Crear carga de trabajo

Crear 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 de Secundus. La VM que ejecuta la carga de trabajo de AA usará esta cuenta de servicio.

Esta cuenta de servicio de 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

Crear carga de trabajo

Como parte de este paso, crearás una imagen de Docker de carga de trabajo. Workload es creado por Primus. 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 están 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.

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 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:

• Crear Artifact Registry($PRIMUS_ARTIFACT_REGISTRY) que es propiedad de Primus.
• Actualiza el código de la carga de trabajo con los nombres de los recursos necesarios.
• Crear la carga de trabajo de AA y crear un Dockerfile para crear 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), que es propiedad de Primus.
• Otorga a $WORKLOAD_SERVICEACCOUNT permiso de lectura para $PRIMUS_ARTIFACT_REGISTRY. Esto es necesario para que el contenedor de 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 carguen la versión esperada del modelo de aprendizaje automático verificando el hash o la firma del modelo antes de usarlos. La ventaja de estas verificaciones adicionales es que garantiza la integridad del modelo de aprendizaje automático. Con esto, el operador de la carga de trabajo también tendría que 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. Autorizar y ejecutar cargas de trabajo

Autorizar carga de trabajo

Primus quiere autorizar a las 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 verificado
• Dónde: Un entorno que es seguro
• Quién: Un operador de confianza

Primus usa la federación de identidades para cargas de trabajo 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 atributos. Estas condiciones restringen qué identidades se pueden autenticar con el grupo de identidades para cargas de trabajo (WIP). Puedes agregar el servicio de verificador de certificación al WIP como 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ó como parte del paso de configuración de recursos en la nube. 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 subieron los $WORKLOAD_IMAGE_NAME más recientes al repositorio $PRIMUS_ARTIFACT_REPOSITORY.
• Dónde: El entorno de ejecución de confianza de Confidential Space se ejecuta en la imagen de VM de Confidential Space totalmente compatible.
• Quién: La cuenta de servicio de Secundus $WORKLOAD_SERVICE_ACCOUNT.

export WORKLOAD_IMAGE_DIGEST=$(docker images –digests ${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/${PRIMUS_PROJECT_ID}/${PRIMUS_ARTIFACT_REPOSITORY}/${WORKLOAD_IMAGE_NAME}:${WORKLOAD_IMAGE_TAG}| awk 'NR>1{ print $3 }')

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 necesarios se pasan usando la marca de metadatos. Los argumentos del contenedor de carga de trabajo se pasan con “tee-cmd”. parte de la marca. El resultado de la ejecución de la carga de trabajo se publicará en $SECUNDUS_RESULT_STORAGE_BUCKET.

gcloud config set project $SECUNDUS_PROJECT_ID

gcloud compute instances create ${WORKLOAD_VM} \
 --confidential-compute-type=SEV \
 --shielded-secure-boot \
 --maintenance-policy=TERMINATE \
 --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}

Nota: Hay dos familias de imágenes que puedes usar para la instancia: confidential-space-debug y confidential-space. Puedes usar cualquiera de ellas. La principal diferencia es que confidential-space tiene servicios inhabilitados, lo que no permite que el operador interfiera en la carga de trabajo, mientras que confidential-space-debug tendrá SSH habilitado y podrá establecer una conexión SSH en la VM. Esto permitirá al operador realizar la depuración (pero el servicio de certificación registrará en el token de certificación que el estado de depuración está habilitado). Sin embargo, después necesitarás apagar la VM de forma manual.

Ver resultados

Después de que la carga de trabajo se complete de forma correcta, 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 inferencia en las 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 en un nombre de clase legible, consulta la lista de etiquetas disponible aquí. Por ejemplo, si ves un índice de clase 2, corresponde a la etiqueta de clase "tench". en la lista de etiquetas.

En este codelab, demostramos que un modelo propiedad de Primus que solo se lanza para la carga de trabajo que se ejecuta en un TEE. Secundus ejecuta la carga de trabajo de AA en un TEE. Esta carga de trabajo puede consumir el modelo que es propiedad de Primus, mientras que Primus mantiene el control total sobre el modelo.

Ejecuta cargas de trabajo no autorizadas

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

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 originales y la instancia de VM y, luego, vuelve a ejecutar la carga de trabajo.

Asegúrate de que haya una nueva imagen de Docker publicada en Artifact Registry de Secundus (como us-docker.pkg.dev/${SECUNDUS_PROJECT_ID}/custom-image/${WORKLOAD_IMAGE_NAME}:${WORKLOAD_IMAGE_TAG}) y la cuenta de servicio de carga de trabajo ($WORKLOAD_SERVICEACCOUNT) le otorgó permiso de lector de Artifact Registry para leer esta nueva imagen de carga de trabajo. Esto es para garantizar que la carga de trabajo no salga antes de que la política WIP de Primus rechace el token que presenta la carga de trabajo.

Borrar el archivo de resultados y la instancia de VM existentes

1. Configura el proyecto como el proyecto $SECUNDUS_PROJECT_ID.

gcloud config set project $SECUNDUS_PROJECT_ID

2. Borra el archivo de resultados.

gsutil rm gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

3. Borra la instancia de Confidential VM.

gcloud compute instances delete ${WORKLOAD_VM}

Ejecuta la carga de trabajo no autorizada:

gcloud compute instances create ${WORKLOAD_VM} \
 --confidential-compute-type=SEV \
 --shielded-secure-boot \
 --maintenance-policy=TERMINATE \
 --scopes=cloud-platform --zone=${SECUNDUS_PROJECT_ZONE} \
 --image-project=confidential-space-images \
 --image-family=confidential-space \ 
--service-account=${WORKLOAD_SERVICE_ACCOUNT}@${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. Realiza una 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).
• Repositorio de artefactos de Primus ($PRIMUS_ARTIFACT_REPOSITORY).
• Grupo de Workload Identity de Primus ($PRIMUS_WORKLOAD_IDENTITY_POOL).
• Cuenta de servicio de 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 terminaste de explorar, considera borrar tu proyecto.

• Ve a la consola de Google Cloud.
• Selecciona el proyecto que deseas cerrar y haz clic en “Borrar”. en la parte superior: esta opción programa la eliminación del proyecto.

¿Qué sigue?

Echa un vistazo a algunos de estos codelabs similares...

• Protege los datos compartidos en uso con Confidential Space
• Cómo realizar transacciones de activos digitales con el procesamiento de varias partes y los espacios confidenciales
• Analiza datos confidenciales con Confidential Space