Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Cómo acceder a los vTPM y a la información de certificación en Confidential GKE Nodes

Estándar

Las cargas de trabajo que ejecutas en Confidential Google Kubernetes Engine Nodes pueden acceder a la integridad de la plataforma y a las funciones de seguridad, como los módulos de plataforma segura virtuales (vTPM) y los informes de certificación de Confidential Computing, y usarlas. En este documento, se muestra a los ingenieros de seguridad cómo hacer que los vTPM y los dispositivos basados en hardware sean visibles para las cargas de trabajo de GKE para realizar tareas como la certificación remota, el sellado secreto y la generación de números aleatorios.

Ya deberías estar familiarizado con los siguientes recursos:

La tecnología específica de Confidential Computing que uses depende del modelo de amenazas y los requisitos de seguridad de tu organización. Para obtener más información, consulta Tecnologías de Confidential Computing.

Tareas de Confidential Computing

Puedes acceder a los vTPM y a los módulos de hardware desde los Pods que se ejecutan en Confidential GKE Nodes. Puedes usar estos módulos para realizar operaciones criptográficas, como el sellado secreto o la certificación remota. Los módulos específicos que se usan para estas tareas dependen de la tecnología de Confidential Computing que usan los nodos, de la siguiente manera:

Sellado secreto: En todas las tecnologías de Confidential Computing, las cargas de trabajo pueden usar el vTPM de la VM protegida como la raíz de confianza para el sellado secreto.
Certificación remota: Las cargas de trabajo pueden usar uno de los siguientes módulos para la certificación remota:
- AMD SEV: El vTPM de la VM protegida.
- AMD SEV-SNP: El procesador seguro de AMD basado en hardware.
- Intel TDX: El módulo Intel TDX basado en hardware.
Para obtener más información sobre cómo funciona la certificación remota en cada una de estas tecnologías de Confidential Computing, consulta Arquitectura y evidencia del certificador.

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

Habilita la API de Google Kubernetes Engine.

Habilitar la API de Google Kubernetes Engine

Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa the gcloud CLI. Si ya instalaste gcloud CLI, ejecuta el comando gcloud components update para obtener la versión más reciente. Es posible que las versiones anteriores de gcloud CLI no admitan la ejecución de los comandos de este documento.
Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar la compute/region propiedad. Si usas principalmente clústeres zonales, configura compute/zone en su lugar. Cuando configuras una ubicación predeterminada, puedes evitar errores en gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location. Es posible que debas especificar la ubicación en ciertos comandos si la ubicación de tu clúster difiere de la predeterminada que estableciste.

Habilita Confidential GKE Nodes en un clúster o grupo de nodos que cumpla con todas las condiciones de la sección Requisitos. Para obtener más información, consulta Configura Confidential GKE Nodes a nivel del clúster o Configura Confidential GKE Nodes a nivel del grupo de nodos.

Requisitos

Puedes usar Confidential GKE Nodes en las siguientes condiciones:

El clúster y los grupos de nodos deben ejecutar una de las siguientes versiones, según el módulo de Confidential Computing al que deseas acceder:
- vTPMs: Cualquier versión de GKE.
- Dispositivos basados en hardware AMD SEV-SNP: Versión 1.33.5-gke.1350000 de GKE y versiones posteriores, o la versión 1.34.1-gke.2037000 y versiones posteriores.
- Dispositivos basados en hardware Intel TDX: Versión 1.33.5-gke.1697000 de GKE y versiones posteriores, o la versión 1.34.1-gke.2909000 y versiones posteriores.
Los grupos de nodos deben estar en una ubicación de Compute Engine que tenga los tipos de máquinas correspondientes. Para obtener más información sobre la disponibilidad regional , consulta Tipos de máquinas, CPU y zonas.
Los nodos deben usar la imagen de nodo de Container-Optimized OS.

Instala el complemento del dispositivo

Para que la información de integridad y seguridad sea visible para los Pods de GKE, instala un complemento del dispositivo. Para usar un DaemonSet para instalar el complemento, sigue estos pasos:

Conéctate a tu clúster:
```
gcloud container clusters get-credentials CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION
```
Reemplaza lo siguiente:
- CLUSTER_NAME: El nombre de tu clúster.
- CONTROL_PLANE_LOCATION: la región o la zona de tu plano de control del clúster, como us-central1 o us-central1-a.

Crea el DaemonSet cc-device-plugin:

kubectl create -f https://raw.githubusercontent.com/google/cc-device-plugin/main/manifests/cc-device-plugin.yaml

Después de crear el DaemonSet, cualquier dispositivo de Confidential Computing en tus Confidential GKE Nodes se vuelve visible para los Pods que se ejecutan en esos nodos.

Accede a los dispositivos de Confidential Computing desde los Pods

Después de crear el DaemonSet para instalar el complemento del dispositivo, puedes acceder a los vTPM y a los dispositivos basados en hardware desde los Pods de manera similar a como solicitas otros recursos extendidos en Kubernetes. En las siguientes secciones, se muestra cómo acceder a los vTPM desde cualquier Pod y cómo acceder a los módulos basados en hardware en los nodos AMD SEV-SNP e Intel TDX.

Accede a los vTPM desde los Pods

Para acceder al vTPM de la VM protegida desde cualquier Pod que se ejecute en Confidential GKE Nodes, agrega el dispositivo google.com/cc a los límites de recursos del contenedor. En los siguientes pasos, se solicita acceso a un vTPM en un Pod de ejemplo:

Guarda el siguiente manifiesto del Pod como example-vtpm-pod.yaml:

apiVersion: v1
kind: Pod
metadata:
name: my-vtpm-pod
spec:
containers:
- name: test-vtpm
  image: ubuntu
  command: ["/bin/sh", "-c", "ls -l /dev/tpmrm0; sleep 3600"]
  ports:
  - containerPort: 8080
    name: http
  resources:
    limits:
      google.com/cc: 1

Crea el Pod:
```
kubectl apply -f example-vtpm-pod.yaml
```
El Pod obtiene acceso al dispositivo /dev/tpmrm0.
Para verificar que el Pod pueda acceder al vTPM, consulta los registros del Pod:
```
kubectl logs my-vtpm-pod
```
Si el resultado contiene información del archivo, el Pod puede acceder al dispositivo.

Puedes interactuar con el dispositivo desde el código de tu aplicación. Por ejemplo, puedes usar la biblioteca Go-TPM para comunicarte con el vTPM y realizar tareas como el sellado. Si usas AMD SEV, también puedes usar el vTPM para realizar la certificación remota de la instancia de Confidential VM.

Accede a los módulos basados en hardware desde los Pods

Si usas AMD SEV-SNP o Intel TDX, también puedes acceder a los módulos basados en hardware correspondientes en los Pods si especificas el selector correspondiente en los límites de recursos del contenedor. Debes usar estos módulos para realizar la certificación remota de los nodos que usan AMD SEV-SNP e Intel TDX, ya que el vTPM no es la raíz de confianza para las mediciones en estas tecnologías.

En los siguientes pasos, se muestra cómo solicitar acceso al procesador seguro de AMD o al módulo Intel TDX:

Guarda uno de los siguientes Pods de ejemplo:

Solicita dispositivos AMD SEV-SNP:

apiVersion: v1
kind: Pod
metadata:
  name: snp-test-pod
spec:
  containers:
  - name: test-container
    image: alpine
    command: ["/bin/sh", "-c"]
    args:
      - |
        echo "Checking for SEV-SNP device..."
        ls -l /dev/sev-guest
        echo "SNP container started successfully"
        sleep 3600
    resources:
      limits:
        amd.com/sev-snp: "1"
      requests:
        amd.com/sev-snp: "1"
  nodeSelector:
    cloud.google.com/gke-confidential-nodes-instance-type: SEV_SNP

Solicita dispositivos Intel TDX:

apiVersion: v1
kind: Pod
metadata:
  name: tdx-test-pod
spec:
  containers:
  - name: test-container
    image: alpine
    command: ["/bin/sh", "-c"]
    args:
      - |
        echo "Checking for TDX device..."
        ls -l /dev/tdx*
        echo "TDX container started successfully"
        sleep 3600
    resources:
      limits:
        intel.com/tdx: "1"
      requests:
        intel.com/tdx: "1"
  nodeSelector:
    cloud.google.com/gke-confidential-nodes-instance-type: TDX

Crea el Pod:
```
kubectl create -f PATH_TO_POD_MANIFEST
```
Reemplaza PATH_TO_POD_MANIFEST por la ruta de acceso al archivo de manifiesto del Pod que guardaste.

Los Pods obtienen acceso a uno de los siguientes dispositivos:
- /dev/sev-guest para AMD SEV-SNP.
- /dev/tdx_guest para Intel TDX.
Para verificar que el Pod pueda acceder al dispositivo, consulta los registros del Pod:
```
kubectl logs POD_NAME
```
Reemplaza POD_NAME por el nombre del Pod de ejemplo que implementaste en el paso anterior.

Si el resultado contiene información del archivo, el Pod puede acceder al dispositivo.

¿Qué sigue?

Obtén información para certificar de forma remota que las cargas de trabajo se ejecutan en Confidential VM.

Cómo acceder a los vTPM y a la información de certificación en Confidential GKE Nodes Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.