máquina virtual

Qué es

Una máquina virtual presenta un ordenador completo mediante
software: procesadores, memoria, discos y tarjetas de red
proporcionados por una capa de virtualización en un anfitrión
físico, sobre los que arranca un sistema operativo como si fueran
hardware dedicado. Suele abreviarse VM. Algunos dispositivos pueden
transferirse directamente desde el anfitrión en lugar de emularse.
La guía de virtualización completa de NIST, SP 800-125, la define en
una línea como «un entorno simulado creado mediante virtualización».
En el tipo de virtualización que trata esa guía, uno o varios
sistemas operativos se ejecutan con sus programas en hardware
virtual, cada uno en su propia VM, donde recibe el nombre de sistema
operativo invitado.

Dos palabras sostienen buena parte de la explicación. La máquina
real es el anfitrión y cada máquina virtual es un invitado. El
programa que reparte el anfitrión entre los invitados es el
hipervisor, también llamado monitor de máquinas virtuales. SP
800-125 lo describe como el componente que gestiona los sistemas
operativos invitados en un anfitrión y controla el flujo de
instrucciones entre ellos y el hardware físico: procesador, discos,
memoria y tarjetas de red. La misma guía señala dos propiedades que
hacen útil el sistema. El hipervisor puede dividir los recursos del
anfitrión para que cada invitado acceda a los que tiene asignados y
a los compartidos explícitamente; además, un invitado puede
encapsularse por completo, lo que permite trasladarlo de un
anfitrión a otro.

Una máquina virtual se distingue de un contenedor por dónde
establece el límite. Un contenedor es un proceso que usa el núcleo
de su anfitrión y tiene una vista restringida del sistema. Una
máquina virtual arranca su propio núcleo sobre el hardware que le
presenta el hipervisor. Por eso, un invitado Linux puede ejecutarse
en un anfitrión Windows o macOS, y también por eso cada invitado
necesita su propio sistema operativo: instalado, actualizado y con
memoria suficiente para funcionar.

Por qué importa

Un servidor alquilado a un proveedor de nube suele ser una máquina
virtual, y sobre ellas se construye la infraestructura como
servicio. El proveedor mantiene los hipervisores y la flota física;
el cliente obtiene máquinas que puede crear, redimensionar y
destruir mediante una API, en vez de pedirlas, recibirlas e
instalarlas en un bastidor. El hardware sigue siendo responsabilidad
ajena, mientras que el sistema operativo pasa a ser responsabilidad
del cliente.

El aislamiento es la segunda razón. La página del proyecto KVM
indica que cada máquina virtual dispone de hardware virtualizado
privado, con su propia tarjeta de red, disco y adaptador gráfico.
Los invitados no comparten núcleo: un fallo del núcleo o una mala
actualización dentro de un invitado se queda en él. Es el
hipervisor, y no los invitados, quien decide qué llega al hardware
físico. Dos clientes, o dos entornos de un mismo cliente, pueden
compartir una máquina física sin compartir sistema operativo.

En tercer lugar, con almacenamiento basado en imágenes, una máquina
puede convertirse en un conjunto de archivos. El disco de un
invitado puede ser un archivo de imagen en el anfitrión que se
copie, se conserve como plantilla o sirva para arrancar varias
máquinas idénticas. El formato qcow2 de QEMU puede registrar solo
las diferencias respecto a una imagen base y guardar instantáneas
del disco en el mismo archivo. Una plantilla más una capa ligera por
invitado resulta así una organización natural.

En cuarto lugar, la emulación permite ejecutar en una familia de
procesadores software creado para otra. En la emulación de sistemas
de QEMU, el sistema operativo invitado se ejecuta en una máquina
modelada por software, con su propio procesador, memoria y
dispositivos. Con un acelerador, como KVM en Linux, Hypervisor
Framework en macOS o Windows Hypervisor Platform en Windows, el
soporte de virtualización del procesador anfitrión realiza la parte
principal del trabajo. Sin uno, Tiny Code Generator de QEMU traduce
por software las instrucciones del invitado. La introducción de QEMU
muestra cómo arrancar así una máquina Arm64 con `-accel tcg`.

El coste es que cada invitado es un ordenador completo que hay que
mantener. Cada uno lleva su propio sistema operativo que actualizar,
su propia memoria reservada y su propio arranque. Los contenedores
lo evitan compartiendo el núcleo del anfitrión, lo que los hace más
ligeros a cambio de renunciar a un núcleo independiente como barrera
entre cargas de trabajo. Elegir entre ambos es decidir dónde debe
situarse esa barrera.

Cómo se aplica en la práctica

En Linux sobre x86, la pareja habitual es KVM y QEMU. KVM es la
parte del núcleo: un módulo cargable, `kvm.ko`, con otro específico
del procesador, `kvm-intel.ko` o `kvm-amd.ko`, incluido en la rama
principal de Linux desde 2.6.20. Necesita las extensiones de
virtualización del procesador, Intel VT o AMD-V. Las preguntas
frecuentes de KVM buscan sus indicadores, `vmx` y `svm`, en
`/proc/cpuinfo`. Su lista de diagnóstico incluye comprobar que
existe `/dev/kvm` y que el usuario tiene permiso para abrirlo:

```sh
grep -E -c '^flags.*(vmx|svm)' /proc/cpuinfo
ls -l /dev/kvm
```

Un recuento superior a cero significa que el procesador anuncia esas
extensiones. QEMU es la parte en espacio de usuario, que construye
la máquina alrededor de KVM. El disco de un invitado nuevo puede ser
una capa ligera sobre una imagen base compartida:

```sh
qemu-img create -f qcow2 -b debian-base.qcow2 -F qcow2 web1.qcow2
qemu-img info --backing-chain web1.qcow2
```

El manual de qemu-img indica que una imagen creada con un archivo
base solo registra las diferencias respecto a él, y que ese archivo
nunca se modifica salvo que las diferencias se vuelquen de nuevo
sobre él. El segundo comando enumera todos los archivos de la
cadena, algo que conviene leer antes de mover o borrar nada. El
arranque del invitado tiene este aspecto:

```sh
qemu-system-x86_64 -accel kvm -m 2G -smp 2 \
    -drive file=web1.qcow2,if=virtio,format=qcow2 \
    -nographic
```

`-accel kvm` entrega a KVM el trabajo del procesador, a través de
`/dev/kvm` de forma predeterminada. `-m` establece la memoria del
invitado y `-smp`, su número de procesadores. En `-drive`,
`if=virtio` conecta el disco mediante la interfaz virtio, uno de los
tipos que enumera el manual, y `format=qcow2` especifica el formato
para que QEMU no tenga que detectarlo. `-nographic` desactiva la
ventana gráfica: QEMU se convierte en un programa de línea de
comandos con la consola serie del invitado en el terminal,
compartida con el monitor de QEMU; Ctrl-a h muestra cómo alternar
entre ambos.

Con el invitado apagado, la misma herramienta toma y restaura
instantáneas del disco. `-c` crea una, `-l` las enumera y `-a`
devuelve el disco a un estado guardado:

```sh
qemu-img snapshot -c before-upgrade web1.qcow2
qemu-img snapshot -l web1.qcow2
qemu-img snapshot -a before-upgrade web1.qcow2
```

Dimensionar es una decisión de diseño, no un campo de un formulario.
La entrada del portafolio sobre ejecutar los servicios públicos de
la empresa en un servidor pequeño documenta una configuración de
septiembre de 2026 con un núcleo de procesador, un disco de 10 GB y
512 MB de memoria, de los que los programas pueden usar
aproximadamente

464 MB. Ese anfitrión sirve siete dominios mediante TLS y ejecuta
además la forja Git, con la automatización de las copias de
seguridad implementada por separado; la memoria es el límite al que
responde cada decisión de diseño. Para decidir si admitía también un
servicio onion de Tor se registró un día de muestras: la menor
lectura de memoria disponible rondaba los 310 MB. El ajuste `-m` de
cada invitado plantea la misma pregunta, y una medición la responde
mejor que un plan de alojamiento más grande.

La entrada sobre gestionar treinta instancias VPS Ubuntu Linux
muestra el otro extremo de la escala. Su configuración se había
acumulado a lo largo de los años en lugar de diseñarse, y las
instancias habían ido divergiendo. Desde entonces se gestionaron
como una sola flota: la misma configuración de red reforzada en
todas y restauraciones probadas en lugar de dadas por buenas.

Dónde surgen los problemas

La mayor parte de los problemas con máquinas virtuales surge al
olvidar que cada una es un ordenador real que requiere
mantenimiento, y que un disco basado en una imagen también es un
archivo corriente en otra máquina.

KVM no está disponible al arrancar el invitado. En la configuración
x86 anterior, la ausencia de extensiones del procesador o su
desactivación en el firmware impiden la aceleración KVM, y
`/dev/kvm` puede no existir. Un invitado iniciado con `-accel kvm`
se detiene de inmediato. Las preguntas frecuentes de KVM advierten
de que algunos fabricantes desactivan VT en la BIOS de forma
irreversible. Compruebe los indicadores como se mostró antes, busque
una opción del firmware que habilite la virtualización y confirme
que `/dev/kvm` existe y pertenece a un grupo del que forme parte el
usuario; las preguntas frecuentes proponen un grupo llamado `kvm`.

Un invitado iniciado sin tamaño de memoria recibe 128 MiB. Es el
valor predeterminado de QEMU para `-m` y se aplica con independencia
de la memoria libre del anfitrión. El invitado puede arrancar y
luego fallar de formas que parecen defectos del software que
ejecuta. Especifique siempre `-m` y `-smp` y dimensiónelos a partir
de mediciones, como hizo la entrada del servidor pequeño para
decidir sobre el servicio onion con un día de medidas.

Modificar una imagen mientras funciona el invitado puede destruirla.
El manual de qemu-img es tajante: editar una imagen mientras un
invitado u otro proceso la utiliza puede destruirla. Tomar una
instantánea del disco de un invitado activo con `qemu-img snapshot
i-c` es precisamente eso. Apague el invitado antes de que qemu-img		engineer.company	70
acceda a su disco e incluya ese paso en todos los procedimientos que
lo hagan.

Las instantáneas sustituyen a las copias de seguridad. Las creadas
con qemu-img residen en el mismo archivo de imagen, como muestra
`qemu-img info` al enumerarlas junto al disco. Si el archivo se
pierde o se daña, se pierden también todas sus instantáneas. Copie
las copias de seguridad a almacenamiento en otra máquina y pruebe la
restauración, porque una restauración que nunca se ha ejecutado no
demuestra nada.

La imagen base cambia o se mueve bajo sus capas. Una imagen ligera
solo contiene diferencias: no sirve sin la base exacta a partir de
la que se creó. El manual advierte de que cambiar el archivo base en
modo no seguro corrompe el contenido que ve el invitado si el nuevo
archivo no es el correcto. Una ruta relativa hacia el archivo base
se resuelve respecto al directorio de la propia capa, por lo que
mover un archivo sin el otro rompe la cadena. Trate las imágenes
base como solo lectura y dé un nombre nuevo a cada versión. Lea
`qemu-img info --backing-chain` antes de mover nada y ejecute
`qemu-img commit` solo deliberadamente, pues escribe sobre la base y
vacía la capa.

El formato del disco se deduce de la propia imagen. Sin `format=`,
QEMU detecta el formato a partir del contenido del archivo. El
manual recomienda `format=raw` para evitar interpretar una cabecera
de formato no fiable. Una imagen descargada de otro lugar, o sobre
la que haya escrito un invitado, no es fiable precisamente en ese
sentido. Especifique el formato en cada línea `-drive`.

Cada invitado termina siendo un caso particular. Las máquinas
configuradas a mano se separan cambio a cambio hasta que no quedan
dos iguales. Así estaba la flota VPS anterior antes de pasar a
gestionarse. Construya cada invitado desde la misma imagen y la
misma configuración, conserve esta en el control de versiones y
gestione las máquinas como una flota con una base común.

Lecturas adicionales

  * Guide to Security for Full Virtualization Technologies (NIST SP
800-125) — la definición de VM, el cometido del hipervisor y la
separación entre invitados.

  * KVM — la página del proyecto: módulos, extensiones del
procesador y versión de incorporación a la rama principal.

  * KVM FAQ — la comprobación de vmx y svm, los permisos de
`/dev/kvm` y la opción de la BIOS.

  * QEMU System Emulation introduction — los aceleradores, Tiny Code
Generator y un ejemplo completo de comando.

  * QEMU invocation — todas las opciones usadas: `-accel`, `-m`,
`-smp`, `-drive`, `-nographic`.

  * QEMU disk image utility — qcow2, archivos base, instantáneas y
la advertencia sobre imágenes en uso.

hEsta página en la web	URL:https://engineer.company/es/glossary/virtual-machine/	engineer.company	70
