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

Crea y administra discos virtuales en Google Distributed Cloud

Este documento está dirigido a los propietarios de aplicaciones que ejecutan Google Distributed Cloud. En este documento, se muestra cómo crear y administrar recursos de disco para máquinas virtuales (VMs) que usan el entorno de ejecución de VM en GDC.

Antes de comenzar

Para completar este documento, necesitas acceso a los siguientes recursos:

Acceso al clúster de Google Distributed Cloud 1.12.0 (anthosBareMetalVersion: 1.12.0) o superior. Puedes usar cualquier tipo de clúster capaz de ejecutar cargas de trabajo. Si es necesario, prueba Google Distributed Cloud en Compute Engine o consulta la descripción general de la creación de clústeres.
La herramienta de cliente virtctl instalada como un complemento para kubectl. Si es necesario, instala la herramienta cliente de virtctl.

Crea una VM con un disco conectado

Cuando creas una VM, puedes conectar un disco de arranque o de datos existente, crear un disco a partir de una imagen (incluido el disco de arranque) o crear un disco en blanco.

Disco en blanco

En esta situación, debes crear un disco en blanco y conectarlo a la VM. Esta situación te permite crear un disco de datos para almacenar datos de la aplicación.

Crea un manifiesto que defina un VirtualMachineDisk y un VirtualMachine, como my-vm.yaml, en el editor que elijas:
```
nano my-vm.yaml
```
Copia y pega la siguiente definición de YAML:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 10Gi
---
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv
    - virtualMachineDiskName: DISK_NAME
```
Reemplaza lo siguiente:
- DISK_NAME: Es el nombre del disco en blanco que creas y conectas a tu VM.
  
  Nota: A partir de la versión 1.13.0 de Google Distributed Cloud, cuando creas una VM, el entorno de ejecución de VM en GDC establece los nombres de disco especificados con virtualMachineDiskName como el número de serie del disco. Para obtener más información, consulta Localiza discos.
- VM_NAME: Es el nombre de la VM que estás creando.
  
  En este ejemplo, se crea un disco 10Gi en blanco (10 gibibyte) llamado DISK_NAME. En la sección spec.disks de la VM, también debes adjuntar un disco de arranque, como a partir de una imagen tal como se muestra en la siguiente sección.
Guarda y cierra el archivo de manifiesto en tu editor.
Crea la VM y el disco con kubectl:
```
kubectl apply -f my-vm.yaml --kubeconfig KUBECONFIG
```
Reemplaza KUBECONFIG por la ruta de acceso al archivo kubeconfig del clúster.

Desde la imagen

En esta situación, crearás un disco a partir de una imagen y lo conectará a la VM. Esta situación te permite crear un disco de arranque, por ejemplo, a partir de una imagen. También puedes crear y adjuntar discos de datos a partir de una imagen.

Fuentes de imágenes compatibles

El entorno de ejecución de VM en GDC admite una variedad de formatos de imagen y admite tres tipos de fuentes de imagen que se pueden especificar en la especificación VirtualMachineDisk. En cada uno de los siguientes ejemplos, se crea un disco de 20 gibibyte a partir de una fuente de imagen compatible diferente.

Protocolo de transferencia de hipertexto (HTTP)

En el siguiente ejemplo de VirtualMachineDisk, se muestra la estructura básica de una fuente de imagen HTTP. El campo url espera una URL HTTP o HTTPS.

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: my-disk
spec:
  source:
    http:
      url: https://download.cirros-cloud.net/0.4.0/cirros-0.4.0-x86_64-disk.img
  size: 20GiB
  storageClassName: local-shared

Cloud Storage

En el siguiente ejemplo, se muestra cómo crear un disco a partir de una imagen en un bucket de Cloud Storage. Si las credenciales predeterminadas de la aplicación en la máquina no son suficientes para acceder a la URL de Cloud Storage, debes proporcionar credenciales. En el siguiente ejemplo, my-gcs es un secreto que contiene una clave de cuenta de servicio codificada en base64.
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: my-disk
spec:
  source:
    gcs:
      url: gs://kubevirt-ci-vm-images/rhel8.2/rhel8_2_cloud.qcow2
      secretRef: my-gcs
  size: 20GiB
  storageClassName: local-shared
```
Si usaste claves de cuenta de servicio descargadas para crear tu clúster, puedes usar la clave de cuenta de servicio de Container Registry para acceder a Cloud Storage. Si creas una cuenta de servicio separada para acceder a Cloud Storage, consulta Configura una cuenta de servicio que pueda acceder a un bucket de Cloud Storage.

Usa el siguiente comando para crear un Secret de Kubernetes a partir del archivo de claves de la cuenta de servicio descargado:
```
kubectl create secret generic SECRET_NAME --from-file=KEY_FILE --namespace default \
    --kubeconfig KUBECONFIG
```
Reemplaza lo siguiente:
- SECRET_NAME: Es el nombre de tu Secret.
- KEY_FILE: Es la ruta de acceso al archivo JSON de claves de la cuenta de servicio descargado. Por ejemplo, bmctl-workspace/.sa-keys/my-project-anthos-baremetal-gcr.json
- KUBECONFIG: Es la ruta de acceso al archivo kubeconfig del clúster.
Si quieres obtener más información sobre el uso de credenciales para acceder a Cloud Storage, consulta Crea y usa credenciales para importar imágenes desde Cloud Storage.
Ejemplo de Container Registry

Se admiten los registros de contenedores que cumplen con distribution-spec de Open Container Initiative (OCI). En el siguiente ejemplo, se crea un disco a partir de una imagen almacenada en un registro de Docker.
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: my-disk
spec:
  source:
    registry:
      url: docker://kubevirt/fedora-cloud-registry-disk-demo
  size: 20GiB
  storageClassName: local-shared
```

Formatos de imagen válidos

Puedes usar cualquiera de los siguientes formatos de imagen cuando creas un disco a partir de una imagen:

Archivo GNU zip (gzip) (.gz)
RAW (.raw, .img)
Copia de QEMU en imagen de disco (.qcow2) de la versión de escritura 2 (qcow2)
Archivo comprimido en XZ (.xz)
Archivo de disco de máquina virtual (VMDK) (.vmdk)
Archivo de imagen de disco virtual (VDI) de VirtualBox (.vdi)
Archivo de imagen de disco duro virtual (VHD) (.vdh)
Archivo de la versión 2 de disco duro virtual (VDHX) (.vdhx)
Archivo de imagen de disco ISO (.iso)

Ejemplo de un disco creado a partir de una imagen HTTP

Sigue estos pasos para crear un disco de arranque a partir de una imagen de Ubuntu:

Crea un manifiesto que defina VirtualMachineDisk y VirtualMachine, como my-vm.yaml, en el editor que elijas:
```
nano my-vm.yaml
```

Copia y pega la siguiente definición de YAML:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: VM_NAME-boot-dv
spec:
  size: 20Gi
  source:
    http:
      url: https://cloud-images.ubuntu.com/releases/focal/release/ubuntu-20.04-server-cloudimg-amd64.img
---
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv

En este ejemplo, se crea un disco 20Gi (20 gibibyte) llamado VM_NAME-boot-dv con una imagen de Ubuntu pública. En la sección spec.disks de la VM, el disco se establece en boot: true.

Guarda y cierra el manifiesto en tu editor.
Crea la VM y el disco con kubectl:
```
kubectl apply -f my-vm.yaml --kubeconfig KUBECONFIG
```
Reemplaza KUBECONFIG por la ruta de acceso al archivo kubeconfig del clúster.

Disco existente

En esta situación, debes crear un disco en blanco y conectarlo a la VM. Esta situación te permite crear un disco de datos para almacenar datos de la aplicación.

Crea un manifiesto VirtualMachine, como my-vm.yaml,, en el editor que elijas:
```
nano my-vm.yaml
```

Copia y pega la siguiente definición de YAML:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv
    - virtualMachineDiskName: EXISTING_DISK_NAME

En este ejemplo, se conecta un disco existente llamado EXISTING_DISK_NAME.

En la sección spec.disks de la VM, también debes adjuntar un disco de arranque, como a partir de una imagen tal como se muestra en la sección anterior.

Guarda y cierra el manifiesto de la VM en el editor.
Crea la VM mediante kubectl:
```
kubectl apply -f my-vm.yaml --kubeconfig KUBECONFIG
```
Reemplaza KUBECONFIG por la ruta de acceso al archivo kubeconfig del clúster.

Ubica discos

A partir de la versión 1.13.0 de Google Distributed Cloud, cuando creas una VM, el entorno de ejecución de VM en GDC usa los nombres de disco que especificas en el recurso de VM para configurar los números de serie del disco. En particular, los nombres que especificas con spec.disks.virtualMachineDiskName en el recurso personalizado VirtualMachine se usan en el número de serie de los discos. Esta función facilita la ubicación de tus discos en la VM cuando necesitas realizar operaciones de disco, como formatear o activar.

Por ejemplo, si creaste una VM y especificaste un disco de arranque llamado sample-boot-dv, tu recurso personalizado VirtualMachine tendrá un aspecto similar al siguiente:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: sample-vm
spec:
  osType: Linux
  compute:
    cpu:
      vcpus: 2
    memory:
      capacity: 4Gi
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: sample-vm-boot-dv
    - virtualMachineDiskName: attached-disk

En el caso de las VMs de Linux, cuando accedes a la VM, puedes ejecutar el siguiente comando para enumerar los discos por su número de serie:

ls -l /dev/disk/by-id/

Tu respuesta debería ser similar a este resultado de ejemplo, en el que los nombres de los discos aparecen como números de serie:

total 0
lrwxrwxrwx 1 root root  9 Oct 19 17:17 ata-QEMU_HARDDISK_agentInstallation -> ../../sdb
lrwxrwxrwx 1 root root  9 Oct 19 17:17 ata-QEMU_HARDDISK_agentSADisk -> ../../sda
lrwxrwxrwx 1 root root  9 Oct 19 17:17 virtio-sample-boot-dv -> ../../vda
lrwxrwxrwx 1 root root 10 Oct 19 17:17 virtio-sample-boot-dv-part1 -> ../../vda1
lrwxrwxrwx 1 root root 11 Oct 19 17:17 virtio-sample-boot-dv-part14 -> ../../vda14
lrwxrwxrwx 1 root root 11 Oct 19 17:17 virtio-sample-boot-dv-part15 -> ../../vda15
lrwxrwxrwx 1 root root 11 Oct 19 17:17 virtio-attached-disk -> ../../vdb

Ten en cuenta el siguiente comportamiento situacional de los atributos:

Si el valor virtualMachineDiskName tiene más de 20 caracteres, el entorno de ejecución de VM en GDC usa solo los primeros 20 caracteres como número de serie.
Si hay dos discos con los mismos primeros 20 caracteres, solo el primer disco tendrá un número de serie.

Crea y conecta discos a la VM existente

Si tienes una VM existente, puedes crear y adjuntar discos para respaldar los ciclos de vida de las aplicaciones. La VM debe estar detenida antes de conectar un disco.

Disco en blanco

En esta situación, debes crear un disco en blanco y conectarlo a la VM. Esta situación te permite crear un disco de datos para almacenar datos de la aplicación.

Usa kubectl para detener la VM, si es necesario:
```
kubectl virt stop vm VM_NAME --kubeconfig KUBECONFIG
```
Reemplaza lo siguiente:
- VM_NAME: Es el nombre de la VM que deseas detener.
- KUBECONFIG: Es la ruta de acceso al archivo kubeconfig del clúster.

Edita el recurso de VM existente, como my-vm:

kubectl edit gvm VM_NAME --kubeconfig KUBECONFIG

Actualiza el manifiesto YAML VirtualMachine para agregar una sección VirtualMachineDisk en la parte superior y, luego, conecta el disco al final de la sección spec.disks de la VM:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 10Gi
---
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv
    - virtualMachineDiskName: DISK_NAME

En este ejemplo, se crea un disco 10Gi en blanco (10 gibibyte) llamado DISK_NAME.

Guarda y cierra el manifiesto de VM actualizado en el editor.

Usa kubectl para iniciar la VM:

kubectl virt start vm VM_NAME --kubeconfig KUBECONFIG

Desde la imagen

En esta situación, debes crear un disco a partir de una imagen de origen y conectarlo a la VM.

Usa kubectl para detener la VM, si es necesario:
```
kubectl virt stop vm VM_NAME --kubeconfig KUBECONFIG
```
Reemplaza lo siguiente:
- VM_NAME: Es el nombre de la VM que deseas detener.
- KUBECONFIG: Es la ruta de acceso al archivo kubeconfig del clúster.

Edita el recurso de VM existente, como my-vm:

kubectl edit gvm VM_NAME --kubeconfig KUBECONFIG

Actualiza el manifiesto VirtualMachine para agregar una sección VirtualMachineDisk en la parte superior y, luego, conecta el disco al final de la sección spec.disks de la VM:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 10Gi
  source:
    http:
      url: http://example.com/my-disk-img.qcow2
---
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv
    - virtualMachineDiskName: DISK_NAME

En este ejemplo, se crea un disco 10Gi (10 gibibyte) llamado DISK_NAME desde la fuente HTTP http://example.com/my-disk-img.qcow2.

Guarda y cierra el manifiesto de VM actualizado en el editor.

Usa kubectl para iniciar la VM:

kubectl virt start vm VM_NAME --kubeconfig KUBECONFIG

Crear un disco

En esta situación, debes crear los recursos de discos por separado de los recursos de la VM. Esta situación te permite crear discos con anticipación y, luego, conectarte a las VM según sea necesario.

Disco en blanco

Para crear un disco en blanco, completa los siguientes pasos.

Crea un manifiesto VirtualMachineDisk, como my-disk.yaml, en el editor que elijas:
```
nano my-disk.yaml
```
Copia y pega la siguiente definición de YAML:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 10Gi
```
En este ejemplo, se crea un disco 10Gi en blanco (10 gibibyte) llamado DISK_NAME.
Guarda y cierra el manifiesto del disco en el editor.
Crea el disco con kubectl:
```
kubectl apply -f my-disk.yaml --kubeconfig KUBECONFIG
```
Reemplaza KUBECONFIG por la ruta de acceso al archivo kubeconfig del clúster.

Desde la imagen

Para crear un disco a partir de una imagen, completa los siguientes pasos.

Crea un manifiesto VirtualMachineDisk, como my-disk.yaml, en el editor que elijas:
```
nano my-disk.yaml
```

Copia y pega la siguiente definición de YAML:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 20Gi
  source:
    http:
      url: https://cloud-images.ubuntu.com/releases/focal/release/ubuntu-20.04-server-cloudimg-amd64.img

En este ejemplo, se crea un disco 20Gi (20 gibibyte) llamado DISK_NAME con una imagen de Ubuntu pública.

Guarda y cierra el manifiesto del disco en el editor.
Crea el disco con kubectl:
```
kubectl apply -f my-disk.yaml --kubeconfig KUBECONFIG
```
Reemplaza KUBECONFIG por la ruta de acceso al archivo kubeconfig del clúster.

¿Qué sigue?

Crea y usa credenciales para importar imágenes desde Cloud Storage.
Crea y usa clases de almacenamiento en Google Distributed Cloud.
Cuando ya no necesites VM o sus recursos de disco virtual, borra una VM en Google Distributed Cloud.