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 los nodos confidenciales de Google Kubernetes Engine pueden acceder a las funciones de seguridad y de integridad de la plataforma, como los módulos de plataforma de confianza 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 y, así, realizar tareas como la certificación remota, el sellado secreto y la generación de números aleatorios.

Ya deberías conocer los siguientes recursos:

La tecnología de Confidential Computing específica que uses dependerá 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 módulos de hardware y vTPM desde los Pods que se ejecutan en Confidential GKE Nodes. Puedes usar estos módulos para realizar operaciones criptográficas, como el sellado de secretos 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 de secretos: En todas las tecnologías de Confidential Computing, las cargas de trabajo pueden usar el vTPM de la VM protegida como raíz de confianza para el sellado de secretos.
Certificación remota: Las cargas de trabajo pueden usar uno de los siguientes módulos para la certificación remota:
- AMD SEV: Es el vTPM de la VM protegida.
- AMD SEV-SNP: Es el procesador seguro de AMD basado en hardware.
- Intel TDX: Es 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 gcloud CLI. Si ya instalaste la 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 que se indican en este documento.
Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar la propiedad compute/region. 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 desees acceder:
- vTPMs: Cualquier versión de GKE
- Dispositivos basados en hardware con SEV-SNP de AMD: GKE versión 1.33.5-gke.1350000 y versiones posteriores, o 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 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áquina correspondientes. Para obtener más información sobre la disponibilidad regional, consulta Tipos de máquinas, CPUs 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, debes instalar un complemento de 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: Es la región o 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, los Pods que se ejecutan en los nodos de Confidential GKE Node podrán ver los dispositivos de Confidential Computing.

Accede a dispositivos de Confidential Computing desde 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 de AMD SEV-SNP y de Intel TDX.

Accede a los vTPM desde los Pods

Para acceder al vTPM de la VM protegida desde cualquier Pod que se ejecute en nodos de GKE confidenciales, 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, significa que 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 la SEV de AMD, también puedes usar el vTPM para realizar la certificación remota de la instancia de Confidential VM.

Cómo acceder a módulos basados en hardware desde Pods

Si usas AMD SEV-SNP o Intel TDX, también puedes acceder a los módulos basados en hardware correspondientes en los Pods especificando 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 y TDX de Intel, 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 TDX de Intel:

Guarda uno de los siguientes Pods de ejemplo:

Solicita dispositivos con 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, significa que el Pod puede acceder al dispositivo.

¿Qué sigue?

Obtén más información para atestiguar 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.