Instructivo: Crea y administra una VM de Linux en Anthos VM Runtime

En este instructivo, se muestra cómo crear y administrar una máquina virtual (VM) de Linux en una instalación nueva de Anthos VM Runtime. Aprenderás el proceso para crear y definir las dependencias básicas, como una StorageClass y una red virtual, y luego crear una VM que use estos recursos. Luego, aprendes a editar la VM, por ejemplo, para agregar un disco nuevo.

Objetivos

Configura las dependencias básicas
- Crea una StorageClass para Anthos VM Runtime
- Crea una red virtual para que tus VM la usen
Crea un disco de arranque de máquina virtual
Cree una VM
Edita una VM para agregar un nuevo disco virtual

Antes de comenzar

Para completar este instructivo, necesitas acceso a los siguientes recursos y herramientas:

Acceso a la versión 1.12.0 (anthosBareMetalVersion: 1.12.0) o superior de los clústeres de Anthos alojados en equipos físicos. Puedes usar cualquier tipo de clúster capaz de ejecutar cargas de trabajo. Si es necesario, prueba los clústeres de Anthos alojados en equipos físicos 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 `StorageClass`

Usa una StorageClass a fin de definir el tipo de almacenamiento que estarás disponible para las VM. Las diferentes clases de almacenamiento pueden asignarse a un tipo diferente de hardware de almacenamiento, sistema de archivos o rendimiento.

En este instructivo, no se trata cómo proporcionar instrucciones específicas para cada StorageClass y socio de almacenamiento.

Los socios de almacenamiento de Anthos Ready proporcionan controladores calificados de Container Storage Interface (CSI) que instalan y configuran los recursos personalizados necesarios para tu almacenamiento. Para instalar el controlador de CSI en tu clúster, revisa la lista de socios de almacenamiento compatibles y sigue sus instrucciones.

Después de instalar el controlador de CSI para tu plataforma de almacenamiento, una o más clases de almacenamiento están disponibles en tu clúster. En este instructivo, se usa una de estas clases de almacenamiento para crear un disco duro virtual.

En el siguiente ejemplo básico de StorageClass de NFS, se usa el controlador de CSI de NFS. Define la dirección del servidor NFS y la ruta de acceso que se usará en la StorageClass. Todos los nodos de tu clúster pueden conectarse y usar este almacenamiento de NFS:

  apiVersion: storage.k8s.io/v1
  kind: StorageClass
  metadata:
    name: example-nfs
  provisioner: nfs.csi.k8s.io
  parameters:
    server: nfs-server.example.com
    path: /vm-share
  reclaimPolicy: Delete
  volumeBindingMode: Immediate
  mountOptions:
    - nconnect=8
    - nfsvers=4.1

En este instructivo, usa el nombre de una StorageClass en tu propio clúster.

El entorno de ejecución de VM de Anthos genera automáticamente un perfil de almacenamiento para cada StorageClass en un clúster. El perfil de almacenamiento tiene el mismo nombre que la StorageClass asociada. Los perfiles de almacenamiento proporcionan opciones de configuración adicionales asociadas con cada StorageClass. Para obtener más información sobre los perfiles de almacenamiento, incluidas las instrucciones de configuración, consulta Configura perfiles de almacenamiento.

Crea una red virtual

Las VM se conectan a una red virtual mediante una interfaz de red virtual. La red virtual les permite comunicarse con otras VM en el clúster o con recursos fuera del clúster.

En este instructivo, crearás una red virtual de capa 2 (L2) básica que puede usar un servidor DHCP externo. Cuando habilitas el uso de un servidor DHCP externo, puedes omitir la configuración de los ajustes de DNS y de puerta de enlace si los proporciona DHCP.

Para crear una red que use un servidor DHCP externo, completa los siguientes pasos:

Crea un manifiesto Network, como dhcp-network.yaml, en el editor que elijas:
```
nano dhcp-network.yaml
```
Copia y pega el siguiente manifiesto YAML:
```
apiVersion: networking.gke.io/v1
kind: Network
  name: NETWORK_NAME
spec:
  type: L2
  nodeInterfaceMatcher:
    interfaceName: INTERFACE_NAME
  externalDHCP4: true
```
Reemplaza los siguientes valores:
- NETWORK_NAME: Es el nombre de tu red.
- INTERFACE_NAME: Es el nombre de la interfaz en tu nodo de los clústeres de Anthos en equipos físicos al que se conectará la red. Todos los nodos deben tener el mismo nombre de interfaz.
En este manifiesto Network, se establecen los siguientes valores:
- Las cargas de trabajo solo pueden tener un adjunto L2 a esta red. Este es el único type de red que puedes crear en Anthos VM Runtime.
- La red tiene DHCP externo habilitado. El servidor DHCP externo es responsable de la asignación de direcciones IPv4, las rutas, la puerta de enlace y la configuración de DNS de las cargas de trabajo conectadas a esta red.
Guarda y cierra el manifiesto Network en tu editor.
Crea la red mediante kubectl:
```
kubectl apply -f use-dhcp-network.yaml
```

Crea un disco de arranque de VM

Una VM puede usar una imagen de disco creada con anterioridad o iniciarse desde una imagen ISO para instalar el SO de forma manual. Estas imágenes de disco se pueden almacenar y se puede acceder a ellas mediante HTTP, o en Cloud Storage acceder a ellas mediante un Secret.

En este instructivo, crearás un disco de arranque a partir de la imagen pública de Ubuntu Server 20.04 en la nube mediante HTTP.

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
  storageClassName: STORAGE_CLASS_NAME
  source:
    http:
      url: https://cloud-images.ubuntu.com/releases/focal/release/ubuntu-20.04-server-cloudimg-amd64.img
```
Reemplaza los siguientes valores:
- DISK_NAME: Es el nombre que deseas para tu disco. En este ejemplo, se crea un disco 20Gi (20 gibibytes) llamado DISK_NAME mediante una imagen pública de Ubuntu Server 20.04.
- STORAGE_CLASS_NAME: Es la StorageClass que deseas usar para tu VirtualMachineDisk.
  - Usa kubectl get storageclass para enumerar lo que está disponible en tu clúster.
Nota: Puede llevar entre 15 y 20 minutos descargar esta imagen pública, crear el VirtualMachineDisk y aplicar la imagen de SO en el disco nuevo. El proceso para crear el VirtualMachineDisk es mucho más rápido cuando usas una imagen almacenada de forma local. En la mayoría de las situaciones de producción, usa un repositorio de imágenes HTTP local en lugar de extraer desde una fuente pública externa cada vez.
Guarda y cierra el manifiesto VirtualMachineDisk en tu editor.
Crea el disco con kubectl:
```
kubectl apply -f my-disk.yaml
```

Cree una VM

Con una red virtual y un disco de arranque creados en las secciones anteriores, ahora crea una VM. La VM se conecta a la red virtual y se inicia desde el disco virtual.

Crea un manifiesto que defina una 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:
  osType: linux
  compute:
    cpu:
      vcpus: VCPU_NUMBER
    memory:
      capacity: MEMORY_SIZE
  interfaces:
    - name: eth0
      networkName: NETWORK_NAME
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: DISK_NAME
```
Reemplaza los siguientes valores:
- VM_NAME: el nombre de tu VM.
- VCPU_NUMBER: Es la cantidad de CPU virtuales que se asignan a la VM. Sin esta configuración, se asigna el valor predeterminado de 2 CPU virtuales.
  - Puedes asignar entre 1 y 96 CPU virtuales a una VM.
- MEMORY_SIZE: Es la cantidad de memoria que se asigna a la VM. Sin esta configuración, se asigna un valor predeterminado de 4 GiB de memoria.
  - Puedes asignar entre 1M y 1T de memoria a una VM. Para obtener más información, consulta Unidades de recursos de memoria.
- NETWORK_NAME: Es el nombre de la red que se creó en una sección anterior.
- DISK_NAME: Es el nombre del disco de arranque creado en la sección anterior. El disco está configurado como boot: true.
Guarda y cierra el manifiesto en tu editor.
Crea la VM y el disco con kubectl:
```
kubectl apply -f my-vm.yaml
```
La creación de la VM puede tomar unos minutos. Verifica el estado de la VM con el comando kubectl:
```
kubectl get gvm VM_NAME
```
En el siguiente resultado de ejemplo, se muestra la VM en un estado Running:
```
NAME    STATUS    AGE   IP
MY_VM   Running   64s   192.168.2.124
```

Conéctate a la VM.

Cuando tu VM esté en ejecución, conéctate a su consola. Esta conexión de consola te permite realizar tareas básicas, como configurar la VM o instalar una aplicación.

Para acceder a una VM desde la consola, usa kubectl.
```
kubectl virt ssh VM_NAME
```
Después de conectarte con éxito a la consola de la VM, sal de la sesión de la VM y de la consola:
```
Ctrl + ]
```

Edita la VM

Durante el ciclo de vida de la VM, es posible que quieras editarla. Por ejemplo, puede que quieras agregar almacenamiento para instalar una aplicación en un disco dedicado o usar almacenamiento adicional en tu aplicación.

En este instructivo, crea un disco en blanco y conéctalo a la VM. Esta situación te permite crear un disco de datos para almacenar datos de la aplicación.

Crea un manifiesto VirtualMachineDisk, como my-data-disk.yaml, en el editor que elijas:
```
nano my-data-disk.yaml
```
Copia y pega la siguiente definición de YAML:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DATA_DISK_NAME
spec:
  size: 10Gi
  storageClassName: STORAGE_CLASS_NAME
```
Reemplaza los siguientes valores:
- DATA_DISK_NAME: Es el nombre que deseas para tu disco de datos. En este ejemplo, se crea un disco 10Gi (10 gibibytes).
- STORAGE_CLASS_NAME: Es la StorageClass que deseas usar para tu VirtualMachineDisk.
  - Usa kubectl get storageclass para enumerar lo que está disponible en tu clúster.
Guarda y cierra el manifiesto del disco en el editor.
Crea el disco con kubectl:
```
kubectl apply -f my-data-disk.yaml
```
Usa kubectl para detener la VM antes de conectar el disco virtual nuevo:
```
kubectl virt stop VM_NAME
```

Edita tu recurso de VM:

kubectl edit gvm VM_NAME

Actualiza el manifiesto YAML VirtualMachine para conectar el disco al final de la sección spec.disks de la VM:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  ...
  disks:
    - boot: true
      virtualMachineDiskName: DISK_NAME
    - virtualMachineDiskName: DATA_DISK_NAME

Reemplaza DATA_DISK_NAME por el nombre de tu disco que creaste en el paso anterior.

Guarda y cierra el manifiesto de VM actualizado en el editor.
Usa kubectl para iniciar la VM:
```
kubectl virt start VM_NAME
```

Realiza una limpieza

Para borrar los recursos que se crearon en este instructivo, completa los siguientes pasos:

Borra tu VM:
```
kubectl delete -f my-vm.yaml
```

Borra tus recursos VirtualMachineDisk:

kubectl delete -f my-data-disk.yaml
kubectl delete -f my-disk.yaml

Si no deseas mantener las dependencias básicas en tu clúster, completa los siguientes pasos:

Borra tu red virtual:

kubectl delete -f use-dhcp-network.yaml

Para quitar el controlador de CSI del clúster, sigue las instrucciones de tu socio de almacenamiento.