Esta página se ha traducido con Cloud Translation API.

Tutorial: Crear y gestionar una máquina virtual Linux en el tiempo de ejecución de máquinas virtuales de GDC

En este tutorial se muestra cómo crear y gestionar una máquina virtual Linux en una nueva instalación de VM Runtime en GDC. Aprenderás el proceso para crear y definir las dependencias básicas, como un StorageClass y una red virtual, y, a continuación, crear una VM que utilice estos recursos. Después, aprenderás a editar la VM, por ejemplo, para añadir un disco.

Objetivos

Configurar dependencias básicas
- Crea un StorageClass para el tiempo de ejecución de máquinas virtuales en GDC
- Crear una red virtual para que la usen tus máquinas virtuales
Crear un disco de arranque de máquina virtual
Crear VM
Editar una VM para añadir un disco virtual

Antes de empezar

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

Acceso a un clúster de Google Distributed Cloud versión 1.12.0 (anthosBareMetalVersion: 1.12.0) o posterior. Puedes usar cualquier tipo de clúster que pueda 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 complemento de kubectl. Si es necesario, instala la herramienta de cliente virtctl.

Crear un `StorageClass`

Utiliza un StorageClass para definir el tipo de almacenamiento que pones a disposición de las máquinas virtuales. Las diferentes clases de almacenamiento pueden corresponder a un tipo de hardware de almacenamiento, sistema de archivos o rendimiento diferente.

No es el objetivo de este tutorial proporcionar instrucciones específicas para cada StorageClass y partner de almacenamiento.

Los partners de almacenamiento de Google Distributed Cloud Ready proporcionan controladores Container Storage Interface (CSI) cualificados que instalan y configuran los recursos personalizados necesarios para tu almacenamiento. Para instalar el controlador CSI en tu clúster, consulta la lista de partners de almacenamiento compatibles y sigue sus instrucciones.

Después de instalar el controlador CSI de tu plataforma de almacenamiento, habrá una o varias clases de almacenamiento disponibles en tu clúster. En este tutorial, usarás una de estas clases de almacenamiento para crear un disco duro virtual.

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

  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 tutorial, usa el nombre de un StorageClass de tu clúster.

VM Runtime en GDC genera automáticamente un perfil de almacenamiento para cada StorageClass de un clúster. El perfil de almacenamiento tiene el mismo nombre que el StorageClass asociado. Los perfiles de almacenamiento ofrecen opciones de configuración adicionales asociadas a cada StorageClass. Para obtener más información sobre los perfiles de almacenamiento, incluidas las instrucciones de configuración, consulta Configurar perfiles de almacenamiento.

Crear una red virtual

Las máquinas virtuales se conectan a una red virtual mediante una interfaz de red virtual. La red virtual les permite comunicarse con otras VMs del clúster o con recursos fuera del clúster.

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

Para crear una red que use un servidor DHCP externo, sigue estos pasos:

Crea un manifiesto Network, como dhcp-network.yaml, en el editor que prefieras:
```
nano dhcp-network.yaml
```
Copia y pega el siguiente manifiesto YAML:
```
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: NETWORK_NAME
spec:
  type: L2
  nodeInterfaceMatcher:
    interfaceName: INTERFACE_NAME
  externalDHCP4: true
```
Sustituye los siguientes valores:
- NETWORK_NAME: el nombre de tu red.
- INTERFACE_NAME: el nombre de la interfaz de tu nodo de Google Distributed Cloud al que quieres asociar la red. Todos los nodos deben tener el mismo nombre de interfaz.
En este manifiesto de Network, se han definido los siguientes valores:
- Las cargas de trabajo solo pueden tener un archivo adjunto L2 a esta red. Esta es la única red type que puedes crear en el tiempo de ejecución de máquinas virtuales de GDC.
- La red tiene habilitado el protocolo DHCP externo. El servidor DHCP externo se encarga de la asignación de direcciones IPv4, las rutas, la pasarela y la configuración de DNS de las cargas de trabajo conectadas a esta red.
Guarda y cierra el manifiesto de Network en tu editor.
Crea la red con kubectl:
```
kubectl apply -f use-dhcp-network.yaml
```

Crear un disco de arranque de VM

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

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

Para crear un disco a partir de una imagen, sigue estos pasos:

Crea un archivo de manifiesto VirtualMachineDisk, como my-disk.yaml, en el editor que prefieras:
```
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
```
Sustituye los siguientes valores:
- DISK_NAME: el nombre que quieras darle al disco. En este ejemplo se crea un disco de 20Gi (20 gibibytes) llamado DISK_NAME con una imagen pública de Ubuntu Server 20.04.
- STORAGE_CLASS_NAME: el StorageClass que quieras usar en tu VirtualMachineDisk.
  - Usa kubectl get storageclass para ver lo que está disponible en tu clúster.
Nota: Se tarda entre 15 y 20 minutos en descargar esta imagen pública, crear el VirtualMachineDisk y aplicar la imagen del SO al nuevo disco. El proceso para crear el VirtualMachineDisk es mucho más rápido cuando se usa una imagen almacenada localmente. En la mayoría de los casos de producción, se recomienda usar un repositorio de imágenes HTTP local en lugar de extraerlas de una fuente pública externa cada vez.
Guarda y cierra el manifiesto de VirtualMachineDisk en tu editor.
Crea el disco con kubectl:
```
kubectl apply -f my-disk.yaml
```

Crear VM

Ahora que has creado una red virtual y un disco de arranque en las secciones anteriores, crea una VM. La máquina virtual se conecta a la red virtual y arranca desde el disco virtual. Las siguientes instrucciones crean una VM aplicando directamente un archivo de manifiesto YAML VirtualMachine con la CLI de kubectl.

Crea un archivo de manifiesto que defina un VirtualMachine, como my-vm.yaml, en el editor que prefieras:
```
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
```
Sustituye los siguientes valores:
- VM_NAME: el nombre de tu máquina virtual.
- VCPU_NUMBER: número opcional de vCPUs que se asignarán a la VM. Si no se define este ajuste, se asignan 2 vCPUs de forma predeterminada.
  - Puedes asignar entre 1 y 96 vCPUs a una VM.
- MEMORY_SIZE: cantidad de memoria opcional que se asignará a la VM. Si no se define este ajuste, se asigna el valor predeterminado de 4 GiB de memoria.
  - Puedes asignar entre 1 M y 1 T de memoria a una VM. Para obtener más información, consulta Unidades de recursos de memoria.
- NETWORK_NAME: el nombre de la red que has creado en una sección anterior.
- DISK_NAME: el nombre del disco de arranque que has creado en la sección anterior. Este disco está configurado como boot: true.
Guarda y cierra el archivo de 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 tardar unos minutos. Consulta el estado de la VM con el comando kubectl:
```
kubectl get gvm VM_NAME
```
En el siguiente ejemplo de salida se muestra la máquina virtual en estado Running:
```
NAME    STATUS    AGE   IP
MY_VM   Running   64s   192.168.2.124
```

Conéctate a la VM.

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

Para acceder a una VM desde la consola, usa kubectl:
```
kubectl virt console VM_NAME
```
Cuando se te pida, introduce las credenciales de usuario que especificaste para crear la VM.
Una vez que te hayas conectado correctamente a la consola de la VM, sal de la sesión de la VM y de la consola:
```
Ctrl + ]
```

Editar la VM

Durante el ciclo de vida de tu máquina virtual, es posible que quieras editarla. Por ejemplo, puede que quieras añadir almacenamiento para instalar una aplicación en un disco específico o usar almacenamiento adicional para tu aplicación.

En este tutorial, crea un disco en blanco y conéctalo a la máquina virtual. Este caso práctico te permite crear un disco de datos para almacenar datos de aplicaciones.

Crea un archivo de manifiesto VirtualMachineDisk, como my-data-disk.yaml, en el editor que prefieras:
```
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
```
Sustituye los siguientes valores:
- DATA_DISK_NAME: el nombre que quieras darle al disco de datos. En este ejemplo, se crea un disco de 10Gi (10 gibibytes).
- STORAGE_CLASS_NAME: el StorageClass que quieras usar en tu VirtualMachineDisk.
  - Usa kubectl get storageclass para ver lo que está disponible en tu clúster.
Guarda y cierra el manifiesto del disco en tu editor.
Crea el disco con kubectl:
```
kubectl apply -f my-data-disk.yaml
```
Usa kubectl para detener la VM antes de adjuntar el nuevo disco virtual:
```
kubectl virt stop VM_NAME
```

Edita el recurso de la VM:

kubectl edit gvm VM_NAME

Actualice el archivo de manifiesto VirtualMachine YAML para adjuntar el disco al final de la sección spec.disks de la máquina virtual:

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

Sustituye DATA_DISK_NAME por el nombre del disco que has creado en el paso anterior.

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

Limpieza

Para eliminar los recursos creados en este tutorial, sigue estos pasos:

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

Elimina tus recursos de VirtualMachineDisk:

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

Si no quieres conservar las dependencias básicas en tu clúster, sigue estos pasos:

Elimina tu red virtual:

kubectl delete -f use-dhcp-network.yaml

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