Codelab de Trusted Space

1. Descripción general

¿Todo listo para mejorar la seguridad y la privacidad de tus cargas de trabajo aceleradas por GPU? Este codelab te guiará por las capacidades de Trusted Space, una oferta para proporcionar un aislamiento sólido del operador y compatibilidad con aceleradores para tus cargas de trabajo sensibles de IA/AA.

Proteger los datos, los modelos y las claves valiosos es más importante que nunca. Trusted Space ofrece una solución que garantiza que tus cargas de trabajo operen en un entorno seguro y confiable en el que incluso el operador de la carga de trabajo no tenga acceso.

Esto es lo que ofrece Trusted Space:

• Privacidad y seguridad mejoradas: Trusted Space proporciona un entorno de ejecución confiable en el que tus recursos sensibles (p.ej., modelos, datos y claves valiosos) permanecen protegidos, respaldados por pruebas criptográficas.
• Aislamiento del operador: Elimina las preocupaciones sobre la interferencia del operador. Con Trusted Space, incluso los operadores de tu carga de trabajo no tienen acceso, lo que les impide establecer una conexión SSH, acceder a los datos, instalar software o manipular tu código.
• Compatibilidad con aceleradores: Trusted Space está diseñado para funcionar sin problemas con una amplia gama de aceleradores de hardware, incluidas las GPUs como H100, A100, T4 y L4. Esto garantiza que tus aplicaciones de IA/AA fundamentales para el rendimiento se ejecuten sin problemas.

Qué aprenderás

• Obtén información sobre las ofertas clave de Trusted Space.
• Aprende a implementar y configurar un entorno de Trusted Space para proteger los recursos valiosos de tu carga de trabajo de IA/AA.

Requisitos

• Un proyecto de Google Cloud Platform
• Conocimientos básicos de Google Compute Engine y aceleradores.
• Conocimientos básicos de cuentas de servicio, administración de claves, federación de Workload Identity y condiciones de atributos.
• Conocimientos básicos de contenedores y Artifact Registry

Protege los mensajes sensibles de generación de código con Primus Company

En este codelab, nos pondremos en la piel de Primus, una empresa que prioriza la privacidad y la seguridad de los datos de sus empleados. Primus quiere implementar un modelo de generación de código para ayudar a sus desarrolladores con sus tareas de codificación. Sin embargo, les preocupa proteger la confidencialidad de los mensajes que envían sus empleados, ya que estos suelen contener fragmentos de código sensibles, detalles internos del proyecto o algoritmos patentados.

¿Por qué Primus Company no confía en el operador ?

Primus Corp opera en un mercado altamente competitivo. Su base de código contiene propiedad intelectual valiosa, incluidos algoritmos patentados y fragmentos de código sensibles que proporcionan una ventaja competitiva. Les preocupa la posibilidad de espionaje corporativo por parte de los operadores de cargas de trabajo. Además, los mensajes de los empleados pueden incluir partes confidenciales de código que Primus Corp quiere proteger.

Para abordar esta preocupación, Primus Corp aprovechará Trusted Space para aislar el servidor de inferencia que ejecuta el modelo para la generación de código. Aquí te mostramos cómo funciona:

• Encriptación de mensajes: Antes de enviar un mensaje al servidor de inferencia, cada empleado lo encriptará con una clave de KMS administrada por Primus Corp en Google Cloud. Esto garantiza que solo el entorno de Trusted Space, en el que está disponible la clave de desencriptación correspondiente, pueda desencriptarlo y acceder al mensaje de texto sin formato. En una situación real, las bibliotecas disponibles (p.ej., tink) pueden controlar la encriptación del cliente. Como parte de este codelab, usaremos esta aplicación cliente de muestra con encriptación de sobre.
• Aislamiento del operador: Solo el servidor de inferencia, que se ejecuta en un entorno de Trusted Space, tendrá acceso a la clave que se usa para la encriptación y podrá desencriptar el mensaje en un entorno confiable. El acceso a la clave de encriptación estará protegido por el grupo de Workload Identity. Debido a las garantías de aislamiento de Trusted Space, incluso el operador de la carga de trabajo no puede acceder a la clave que se usa para la encriptación y el contenido desencriptado.
• Inferencia segura con aceleradores: El servidor de inferencia se iniciará en una VM protegida (como parte de la configuración de Trusted Space), lo que garantizará que el software malicioso y los rootkits a nivel de inicio y kernel no vulneren la instancia de la carga de trabajo. Este servidor desencripta el mensaje en el entorno de Trusted Space, realiza la inferencia con el modelo de generación de código y muestra el código generado al empleado.

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/trusted_space_codelab/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 la configuración de un proyecto de GCP, consulta este codelab. Puedes consultar este documento 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>

• 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 \
    cloudkms.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_SERVICE_ACCOUNT='my-service-account')

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

$PRIMUS_PROJECT_REGION	Región en la que se crearán los recursos regionales para la empresa Primus
$PRIMUS_SERVICE_LOCATION	Ubicación en la que se crearán los recursos para la empresa Primus
$PRIMUS_PROJECT_ZONE	Zona en la que se crearán los recursos zonales para la empresa Primus
$PRIMUS_WORKLOAD_IDENTITY_POOL	Grupo de Workload Identity de la empresa Primus para proteger los recursos de la nube
$PRIMUS_WIP_PROVIDER	Proveedor de grupos de Workload Identity de la empresa Primus que incluye la condición de autorización para usar los tokens firmados por el servicio de verificador de certificación
$PRIMUS_SERVICEACCOUNT	Cuenta de servicio de la empresa Primus que $PRIMUS_WORKLOAD_IDENTITY_POOL usa para acceder a los recursos protegidos En este paso, tiene permiso para ver los datos del cliente que se almacenan en el bucket $PRIMUS_INPUT_STORAGE_BUCKET.
$PRIMUS_ENC_KEY	La clave de KMS se usa para encriptar los mensajes que proporcionan los empleados de la empresa Primus.
$PRIMUS_ENC_KEYRING	El llavero de claves de KMS que se usará para crear la clave de encriptación $PRIMUS_ENC_KEY para la empresa Primus
$PRIMUS_ENC_KEYVERSION	La versión de clave de KMS de la clave de encriptación $PRIMUS_ENC_KEY El valor predeterminado es 1. Actualiza este valor si usas una clave existente que se rotó en el pasado y se actualizó su versión.
$PRIMUS_ARTIFACT_REPOSITORY	El repositorio de artefactos en el que se enviará la imagen de Docker de la carga de trabajo
$PRIMUS_PROJECT_REPOSITORY_REGION	La región del repositorio de artefactos que tendría la imagen de Docker de la carga de trabajo publicada
$WORKLOAD_VM	Nombre de la VM de la carga de trabajo
$WORKLOAD_IMAGE_NAME	Nombre de la imagen de Docker de la carga de trabajo
$WORKLOAD_IMAGE_TAG	Etiqueta de la imagen del contenedor de la carga de trabajo
$WORKLOAD_SERVICEACCOUNT	La cuenta de servicio que tiene permiso para acceder a la VM protegida que ejecuta la carga de trabajo
$CLIENT_VM	Nombre de la VM del cliente que ejecutaría la aplicación cliente del servidor de inferencia
$CLIENT_SERVICEACCOUNT	La cuenta de servicio que usa $CLIENT_VM

• Necesitarás los roles de administrador de Storage, administrador de Artifact Registry, administrador de Cloud KMS, administrador de cuentas de servicio y administrador de grupos de Workload Identity de IAM para el proyecto $PRIMUS_PROJECT_ID. Puedes consultar esta guía para obtener información sobre cómo otorgar roles de IAM con GCP Console.
• Para $PRIMUS_PROJECT_ID, ejecuta la siguiente secuencia de comandos para configurar los nombres de variables restantes en valores basados en el ID de tu proyecto para los nombres de recursos.

source config_env.sh

Nota: Para una experiencia sin problemas, considera usar Cloud Shell para este codelab. Si usas una terminal normal, deberás volver a ejecutar este paso si cierras la terminal y vuelves a acceder. Cloud Shell controla las reconexiones automáticamente.

Configura los recursos de Primus Company

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. Como parte de la ejecución de la secuencia de comandos, se crearán los siguientes recursos:

• Clave de encriptación ($PRIMUS_ENC_KEY) y llavero de claves ($PRIMUS_ENC_KEYRING) en KMS para encriptar el archivo de datos del cliente de la empresa Primus
• Grupo de Workload Identity ($PRIMUS_WORKLOAD_IDENTITY_POOL) para validar las reclamaciones en función de las condiciones de atributos configuradas en su proveedor
• La cuenta de servicio ($PRIMUS_SERVICE_ACCOUNT) adjunta al grupo de Workload Identity mencionado anteriormente ($PRIMUS_WORKLOAD_IDENTITY_POOL) tiene acceso para desencriptar datos con la clave de KMS (con el rol roles/cloudkms.cryptoKeyDecrypter), encriptar datos con la clave de KMS (con el rol roles/cloudkms.cryptoKeyEncrypter), leer datos del bucket de Cloud Storage (con el rol objectViewer) y conectar la cuenta de servicio al grupo de Workload Identity (con roles/iam.workloadIdentityUser).

./setup_primus_resources.sh

Nota: Si vuelves a ejecutar este codelab y encuentras errores como ALREADY_EXISTS durante la creación de la clave de KMS o del grupo de Workload Identity, es probable que se deba a que los recursos se borraron temporalmente de ejecuciones anteriores. Como estos recursos no se pueden reutilizar durante 30 días, deberás crearlos con nombres diferentes.

Para ello, usa los siguientes comandos para establecer nombres nuevos para el grupo de Workload Identity y la clave de KMS:

export PRIMUS_WORKLOAD_IDENTITY_POOL=<new name of Workload Identity Pool>

export PRIMUS_ENC_KEY=<new name of KMS Key>

Luego, vuelve a ejecutar la secuencia de comandos ./setup_primus_resources.sh como se indicó anteriormente.

3. Crea una 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 de Primus. La VM que ejecuta el servidor de inferencia 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

./create_workload_service_account.sh

Crea una carga de trabajo

Como parte de este paso, crearás una imagen de Docker de la carga de trabajo. La empresa Primus creará la carga de trabajo. La carga de trabajo que se usa en este codelab es código de Python que usa el modelo codegemma del bucket de GCS disponible públicamente (del jardín de modelos de Vertex). La carga de trabajo cargará el modelo codegemma y lanzará el servidor de inferencia que entregará las solicitudes de generación de código de los desarrolladores de Primus.

En la solicitud de generación de código, la carga de trabajo obtendrá la DEK encapsulada junto con un mensaje encriptado. Luego, la carga de trabajo realizará la llamada a la API de KMS para desencriptar la DEK y, luego, desencriptará el mensaje con esta DEK. Las claves de encriptación (para DEK) se protegerán a través del grupo de Workload Identity, y se otorgará acceso a las cargas de trabajo que cumplan con las condiciones de atributos. Estas condiciones de atributos se describen con más detalle en la siguiente sección sobre la autorización de la carga de trabajo. Una vez que el servidor de inferencia tenga el mensaje desencriptado, generará el código con un modelo cargado y mostrará la respuesta.

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

• Crea Artifact Registry($PRIMUS_ARTIFACT_REGISTRY) propiedad de Primus.
• Actualiza el código de la carga de trabajo con los nombres de recursos necesarios.
• Compila la carga de trabajo del servidor de inferencia y crea 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) propiedad de Primus.
• Otorga permiso de lectura $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

Para tu referencia, aquí está el método generate() de la carga de trabajo que se crea y se usa en este codelab (puedes encontrar el código completo de la carga de trabajo aquí).

def generate():
  try:
    data = request.get_json()
    ciphertext = base64.b64decode(data["ciphertext"])
    wrapped_dek = base64.b64decode(data["wrapped_dek"])
    unwrapped_dek_response = kms_client.decrypt(
        request={"name": key_name, "ciphertext": wrapped_dek}
    )
    unwrapped_dek = unwrapped_dek_response.plaintext
    f = Fernet(unwrapped_dek)
    plaintext = f.decrypt(ciphertext)
    prompt = plaintext.decode("utf-8")
    tokens = tokenizer(prompt, return_tensors="pt")
    outputs = model.generate(**tokens, max_new_tokens=128)
    generated_code = tokenizer.decode(outputs[0])
    generated_code_bytes = generated_code.encode("utf-8")

    response = f.encrypt(generated_code_bytes)
    ciphertext_base64 = base64.b64encode(response).decode("utf-8")
    response = {"generated_code_ciphertext": ciphertext_base64}
    return jsonify(response)

  except (ValueError, TypeError, KeyError) as e:
    return jsonify({"error": str(e)}), 500

4. Autoriza y ejecuta la carga de trabajo

Autoriza la carga de trabajo

Primus quiere autorizar las cargas de trabajo para que accedan a su clave de KMS que se usa para la encriptación de mensajes en función de los atributos de los siguientes recursos:

• Qué: Código verificado
• Dónde: Un entorno seguro
• Quién: Un operador confiable

Primus usa la federación de Workload Identity para aplicar una política de acceso basada en estos requisitos. La federación de Workload Identity te permite especificar condiciones de atributos. Estas condiciones restringen qué identidades pueden autenticarse con el grupo de Workload Identity (WIP). Puedes agregar el servicio de verificador de certificación al WIP como un proveedor de grupos de Workload Identity 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 los recursos de la nube. Ahora, Primus creará un nuevo proveedor de grupos de Workload Identity de OIDC. El --attribute-condition especificado autoriza el acceso al contenedor de la carga de trabajo. Requiere lo siguiente:

• Qué: El $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 Primus

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 iam workload-identity-pools providers create-oidc $PRIMUS_WIP_PROVIDER \
  --location="global" \
  --project="$PRIMUS_PROJECT_ID" \
  --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 == 'HARDENED_SHIELDED' && assertion.hwmodel == 'GCP_SHIELDED_VM' && 
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@$PRIMUS_PROJECT_ID.iam.gserviceaccount.com' in assertion.google_service_accounts"

El comando anterior verifica que la carga de trabajo se ejecute en un entorno de espacio confiable. Para ello, comprueba que hwmodel esté configurado como "GCP_SHIELDED_VM" y swname esté configurado como "HARDENED_SHIELDED". Además, incluye aserciones específicas de la carga de trabajo, como image_digest y image_reference, para mejorar la seguridad y garantizar la integridad de la carga de trabajo en ejecución.

Ejecuta la carga de trabajo

Como parte de este paso, ejecutaremos la carga de trabajo en la VM de Trusted Space que tendrá un acelerador adjunto. Los argumentos de TEE necesarios se pasan con la marca de metadatos. Los argumentos para el contenedor de la carga de trabajo se pasan con la parte "tee-cmd" de la marca. Para equipar la VM de la carga de trabajo con una GPU Nvidia Tesla T4, usaremos la marca --accelerator=type=nvidia-tesla-t4,count=1. Esto adjuntará una GPU a la VM. También deberemos incluir tee-install-gpu-driver=true en las marcas de metadatos para activar la instalación del controlador de GPU adecuado.

gcloud compute instances create ${WORKLOAD_VM} \
  --accelerator=type=nvidia-tesla-t4,count=1 \
  --machine-type=n1-standard-16 \
  --shielded-secure-boot \
  --image-project=conf-space-images-preview \
  --image=confidential-space-0-gpupreview-796705b \
  --zone=${PRIMUS_PROJECT_ZONE} \
  --maintenance-policy=TERMINATE \
  --boot-disk-size=40 \
  --scopes=cloud-platform \
  --service-account=${WORKLOAD_SERVICEACCOUNT}@${PRIMUS_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}~tee-install-gpu-driver=true~tee-restart-policy=Never"

Nota: Hay dos imágenes que puedes usar para la instancia: confidential-space-0-gpupreview-796705b y confidential-space-debug-0-gpupreview-796705b. Puedes usar cualquiera de ellas. La diferencia principal es que confidential-space-0-gpupreview-796705b tiene servicios inhabilitados que no permiten que el operador interfiera con la carga de trabajo, mientras que confidential-space-debug-0-gpupreview-796705b tendrá SSH habilitado y el operador podrá establecer una conexión SSH a la VM. Esto permitirá que el operador depure (pero el servicio de certificación tomará nota en el token de certificación de que el estado de depuración está habilitado). Sin embargo, deberás apagar la VM de forma manual después.

Ejecuta la consulta de inferencia

Después de que se inicie correctamente el servidor de inferencia de la carga de trabajo, los empleados de la empresa Primus podrán enviar las solicitudes de generación de código al servidor de inferencia.

Nota: El servidor de inferencia tarda aproximadamente entre 8 y 10 minutos en iniciarse. Espera hasta que el servidor esté completamente listo antes de ejecutar los siguientes comandos.

Como parte de este codelab, usaremos la siguiente secuencia de comandos para configurar la aplicación cliente que interactuará con el servidor de inferencia. Ejecuta esta secuencia de comandos para configurar la VM del cliente.

./setup_client.sh

En los siguientes pasos, se muestra cómo establecer una conexión SSH a la VM del cliente y ejecutar una aplicación cliente de muestra en un entorno virtual de Python. Esta aplicación de ejemplo utiliza la encriptación de sobre con la biblioteca de Fernet, pero ten en cuenta que las bibliotecas de encriptación específicas se pueden adaptar para satisfacer diferentes casos de uso.

gcloud compute ssh ${CLIENT_VM} --zone=${PRIMUS_PROJECT_ZONE}

Ejecuta los siguientes comandos para activar el entorno virtual de Python en la VM del cliente y ejecutar la aplicación cliente.

source venv/bin/activate

python3 inference_client.py

El resultado de esta aplicación cliente de muestra mostrará las solicitudes de encriptación y de mensajes de texto sin formato, y sus respuestas encriptadas y desencriptadas correspondientes.

5. Limpieza

Aquí está 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:

• Cuenta de servicio de Primus ($PRIMUS_SERVICEACCOUNT)
• Clave de encriptación de Primus ($PRIMUS_ENC_KEY)
• Repositorio de artefactos de Primus ($PRIMUS_ARTIFACT_REPOSITORY)
• Grupo de Workload Identity de Primus ($PRIMUS_WORKLOAD_IDENTITY_POOL) con su proveedor
• Cuenta de servicio de carga de trabajo de Primus ($WORKLOAD_SERVICEACCOUNT)
• VM de carga de trabajo ($WORKLOAD_VM) y VM del cliente ($CLIENT_VM)

./cleanup.sh

Si terminaste de explorar, considera borrar tu proyecto.

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