# A dónde se fueron 23 segundos: arrancar la VM de un trabajo de GitHub Actions en 7

> Una máquina virtual KVM nueva para un trabajo de GitHub Actions tardaba 22,9 s en llegar a su ejecutor en los hosts de Skipbox. Ahora tarda 7,25 s. Cada segundo y cómo se midió, desde el ejecutor de $39 fijos al mes con minutos ilimitados.

Una máquina virtual nueva para un trabajo de GitHub Actions tardaba 22,9 segundos en un host de Skipbox en ir de “el host aceptó el trabajo” a “se inicia el proceso del ejecutor”. Ahora tarda 7,25 segundos. Este artículo cuenta dónde estaban los otros 15 segundos y cómo se midió cada uno.

Skipbox es un ejecutor de GitHub Actions por $39 fijos al mes con minutos ilimitados. Tus trabajos se ejecutan en la máquina dedicada de tu cuenta, que se mantiene entre trabajos, y los trabajos que necesitan una VM nueva la reciben en 7 segundos. Cambia una línea `runs-on` para pasarte.

- La VM nueva de un trabajo llega a su ejecutor en 7,25 s, frente a 22,9 s antes
- En tu máquina dedicada en caliente, los pasos de preparación de un trabajo tardan 7 s frente a 52 s en el `ubuntu-latest` de GitHub
- 20.000 minutos al mes en 4 vCPU: $222 en GitHub, $39 en Skipbox

**GitHub Actions a precio fijo, minutos ilimitados** Skipbox ejecuta tus trabajos de GitHub Actions en tu propia máquina dedicada: $39 al mes, ejecutes los minutos que ejecutes. Las capas de Docker y las cachés de dependencias se conservan entre trabajos, así que el siguiente trabajo empieza enseguida.

Un ejecutor de 4 vCPU, 20.000 minutos al mes: GitHub $222 → Skipbox $39. Ahorras $183 cada mes.

Pasarte lleva una sola línea: `runs-on: skipbox`.

[Empezar mi prueba gratuita de 7 días](https://app.skipbox.dev/sign-in?ref=blog-github-actions-job-vm-boot-7-seconds-es)

## Qué se cronometra, y en qué

Un host de Skipbox ejecuta máquinas virtuales KVM a través de Incus sobre un pool de ZFS. La imagen del ejecutor es una VM detenida con un snapshot. Un trabajo que necesita una VM nueva recibe un clon ZFS de ese snapshot, lo arranca, recibe una configuración de ejecutor just-in-time a través del agente del invitado, ejecuta un trabajo y se elimina con su disco.

El daemon del host registra el final de cada paso de un arranque en milisegundos desde el momento en que acepta el trabajo (`startMs`: `cloned`, `started`, `agent`). Las cifras de abajo son de un host Intel i7-7820X de 16 hilos y una VM de 4 vCPU y 8 GB.

| | De la aceptación al inicio del ejecutor, 3 ejecuciones cada uno |
|---|---|
| Antes | 22,9 s (de 21,7 a 24,2) |
| Después | 7,25 s (de 7,1 a 8,1) |

A dónde se fue, cada parte medida por separado:

| Cambio | Medido | Ahorrado |
|---|---|---|
| SeaBIOS en lugar de OVMF | Del inicio de la VM a la primera respuesta del agente, mediana de 3: 13,7 → 8,4 s | 5,3 s |
| `quiet` en la línea de comandos del kernel | 8,4 → 6,5 s | 1,9 s |
| Sin initrd | 6,5 → 5,1 s | 1,4 s |
| Una imagen que ya tiene el tamaño de sus clones | Clon 1,5 → 0,1 s, primer arranque 2,35 → 1,8 s | 1,9 s |
| Esperar al socket de Docker, no a dockerd | dockerd estaba listo 3,6 s después del agente | 3,6 s |
| Preguntar al agente del invitado cada 100 ms, no cada segundo | 0,5 s de media, hasta 1 s | 0,5 s |

Las partes suman 14,6 s de los 15,65 s de diferencia de extremo a extremo.

## Firmware: 5,3 segundos antes de GRUB

Incus arranca una VM con OVMF y secure boot de forma predeterminada. En este host, OVMF tardaba 5,3 s en pasarle el control a GRUB. SeaBIOS tarda 0,5 s. Dos claves de la instancia lo cambian: `security.csm=true` y `security.secureboot=false`.

Fue la parte individual más grande, y la única que toca la seguridad, así que aquí va completa. Con SeaBIOS, la cadena de arranque del invitado no se comprueba por firma. Lo que esa comprobación protege es que alguien reemplace el bootloader o el kernel del invitado. En la VM de un trabajo de CI ese alguien es el trabajo, y el trabajo ya tiene root en su propia VM: puede hacer `sudo` de cualquier cosa, y la VM y su disco se eliminan cuando termina el trabajo. Lo que mantiene la VM de un cliente lejos de la de otro es KVM y una cadena de firewall por VM en el bridge del host, y ninguno de los dos depende del firmware del invitado. La imagen arranca con los dos, y un indicador en el host vuelve a poner UEFI.

## Un kernel silencioso, y sin initrd

La VM de un trabajo arranca una vez por cada trabajo, y nadie lee su consola serie. `quiet` llevó la mediana de 8,4 a 6,5 s.

El initrd existe para cargar los drivers que encuentran el sistema de archivos raíz. El kernel genérico de Ubuntu trae virtio-scsi y ext4 integrados, y todos los clones comparten el UUID de partición de la imagen, así que el kernel monta `/` directamente desde `root=PARTUUID=…`. Eso fueron otros 1,4 s.

Dos salvaguardas evitan que algo falle en silencio. El GRUB de Ubuntu vuelve a arrancar por sí solo con el initrd la vez siguiente si un arranque sin él entró en pánico (`GRUB_FORCE_PARTUUID`). Ese respaldo devolvería en silencio los 1,4 s a cada trabajo, así que la compilación de la imagen arranca un clon de prueba y falla si `dmesg` muestra que se desempaqueta un initramfs.

## No redimensiones un disco que podías haber creado del tamaño correcto

La imagen se creaba en un disco más pequeño, y cada clon se agrandaba al tamaño de su plan al arrancar. Agrandarlo costaba 1,9 s por trabajo: el clon tardaba 1,5 s en lugar de 0,1 s, y el primer arranque 2,35 s en lugar de 1,8 s. Ahora la imagen se crea con el tamaño de disco del plan más pequeño (80 GB). El volumen es thin, así que la imagen sigue ocupando solo lo que se escribió en ella. Incus no puede encoger un clon, así que la imagen nunca es más grande que el plan más pequeño; los planes más grandes crecen al arrancar.

## El socket de Docker es suficiente

El script de ejecución esperaba a `docker.service` antes de iniciar el ejecutor. dockerd estaba listo 3,6 s después del agente del invitado. Pero systemd escucha en el socket de Docker desde el principio del arranque, y un cliente que se conecta antes de que dockerd esté listo lo espera. Así que el script espera solo a `docker.socket` y al DNS, con una espera acotada, y dockerd termina de arrancar mientras lo hace el ejecutor.

## Sondear cada 100 ms

La configuración del ejecutor se envía a la VM a través del agente del invitado, que no está ahí hasta que el invitado ha arrancado. El host reintentaba una vez por segundo, así que un trabajo esperaba 0,5 s de media después de que apareciera el agente. Incus rechaza un envío en 20 ms mientras el agente no está, así que preguntar cada 100 ms no cuesta nada. Pasados los primeros 30 s de una VM, el host vuelve a una vez por segundo.

## No es un arreglo del arranque: fsync en un disco que muere con el trabajo

Mientras medíamos, lo más lento de la VM resultó no ser el arranque. Cada `fsync` del invitado esperaba a que el ZFS del host confirmara su intent log. El disco de la VM nueva de un trabajo se elimina con el trabajo, así que nada en él tiene que sobrevivir a un corte de luz. El script de ejecución vuelve a montar `/` con `nobarrier` antes de iniciar el ejecutor.

Medianas de 3, en una VM de 4 vCPU y 8 GB:

| | Antes | Después |
|---|---|---|
| Escrituras aleatorias de 4k con fsync | 227 por segundo | 2.505 por segundo |
| `yarn install`, 1 GB de node_modules desde su caché | 12,92 s | 9,99 s (un 23 % menos) |
| `docker pull node:22` | 19,12 s | 15,45 s (un 19 % menos) |
| Una compilación de Docker de redis | 92,89 s | 87,21 s |
| `make -j4`, `sysbench cpu` | sin cambios | sin cambios |

Solo las VM nuevas reciben esto. Tu máquina dedicada guarda tus cachés entre trabajos, y su ext4 conserva sus barreras.

## La misma búsqueda en servidores de nube alquilados

Cuando los propios hosts de Skipbox están llenos, un trabajo se ejecuta en un servidor de nube arrancado desde una imagen snapshot. Ese camino tenía su propio tiempo perdido, en otro sitio. En un servidor compartido Intel de 4 vCPU, el script del trabajo (los user data del servidor) empezaba 28,1 s después del kernel. cloud-init tenía el script a los 19,3 s y Docker estaba listo a los 22,2 s, pero cloud-init ejecuta los user data en su última etapa, después de todo lo demás.

Ahora la imagen tiene una pequeña unidad de systemd que ejecuta los user data en cuanto cloud-init los ha escrito. Lee el script a través de un descriptor de archivo de un archivo que ya ha borrado, así que la última etapa de cloud-init no encuentra nada que ejecutar por segunda vez. La imagen además crea un solo tipo de clave de host SSH en lugar de tres (2,0 s en el camino del que depende todo; nadie inicia sesión en estos servidores), y ya no inicia snapd, apport, rsyslog ni una docena de temporizadores de mantenimiento al arrancar.

Con esa imagen, en un servidor compartido AMD de 4 vCPU, el script del trabajo empieza entre 8 y 14 s después del kernel.

## Las vCPU fijadas mantienen en hora el reloj de cada host

En una CPU híbrida (núcleos de rendimiento y núcleos de eficiencia, como el Core Ultra 7 265F), KVM puede dejar de confiar en el TSC. Durante una noche de compilaciones de imágenes, el kernel registró:

```
tsc: Marking TSC unstable due to KVM discovered backwards TSC
clocksource: Switched to clocksource acpi_pm
```

KVM compara el TSC cuando una vCPU se mueve a otra CPU del host. Leyó un valor más bajo en el núcleo nuevo, entre tipos de núcleo, y marcó el TSC como inestable. El kernel ya había desactivado HPET al arrancar (“HPET dysfunctional in PC10”), así que la única fuente de reloj que quedaba era acpi_pm, que en esta placa apenas avanzaba: alrededor de 1 segundo de uptime en 30 minutos.

Skipbox lo resuelve en dos pasos:

1. **Un respaldo que funciona.** Limitar el C-state del paquete a C8 en la BIOS mantiene vivo HPET. KVM siguió descartando el TSC, en la ronda 11 de un bucle de 20 rondas que arranca y detiene una VM de 8 vCPU bajo carga, pero el reloj pasó a HPET y mantuvo la hora.
2. **Fijar las vCPU.** KVM ejecuta esa comprobación solo cuando una vCPU se mueve. Con cada vCPU fijada a una CPU del host, el mismo bucle hizo 40 rondas sobre el TSC sin ninguna línea nueva en el log.

El daemon del host no acepta ningún trabajo salvo que la fuente de reloj sea `tsc` y `hpet` esté disponible, así que un host que pierde su TSC se vacía solo y sus trabajos van a otras máquinas. Todos los hosts de Skipbox fijan sus vCPU.

## El arranque más rápido es el que te saltas

Los siete segundos son para los trabajos que necesitan una VM nueva: el código de personas sin acceso de escritura (como los pull requests desde forks), un trabajo que llega mientras tu máquina está ocupada, y las cuentas que eligen una VM limpia para cada trabajo. Todos los demás trabajos no arrancan nada. Se ejecutan en la máquina dedicada de tu cuenta, con las capas de Docker, las cachés de paquetes y las herramientas del último trabajo todavía en su disco.

Ahí es donde están los minutos. Los mismos flujos de trabajo en el `ubuntu-latest` de GitHub (2 vCPU, lo que recibe un repositorio privado) y en un Skipbox S en caliente (4 vCPU), medianas de las ejecuciones en caliente:

| | `ubuntu-latest` de GitHub | Skipbox S, en caliente | |
|---|---|---|---|
| excalidraw: instalación, compilación y pruebas | 613 s | 450 s | un 27 % menos |
| Pasos de preparación (checkout, Node, restauración de caché) | 52 s | 7 s | |
| Pruebas | 484 s | 354 s | |
| umami: compilación de Docker multietapa | 263 s | 188 s | un 29 % menos |

Los pasos de preparación bajan de 52 s a 7 s porque no hay ningún archivo de caché que descargar y descomprimir: Node ya está en la caché de herramientas y la caché de yarn está en el disco. La compilación de Docker usa la propia caché de capas del daemon, sin nada que exportar ni importar. En Skipbox, el flujo de trabajo no tiene ningún paso de caché.

## Por qué un precio fijo puede mantener una máquina en caliente

Una máquina inactiva parece un desperdicio. Por la forma en que se factura el cómputo, es la opción más barata, y eso es lo que hace que funcione un precio fijo.

Un servidor de nube alquilado se cobra por cada hora que empieza, completa. Un trabajo de 3 minutos en su propio servidor paga 60 minutos. En un día de nuestra propia CI, 44 trabajos de 2,5 minutos de media se ejecutaron en 44 servidores y se cobraron 44 horas de servidor. Reproducir el mismo día conservando cada servidor para el siguiente trabajo de la cuenta dentro de su hora da entre 13 y 14 horas de servidor: alrededor de un 70 % menos. Y un mes tiene 730 horas: una cuenta que ejecuta más de 730 trabajos cortos al mes en servidores por trabajo paga más horas que una máquina que nunca se detiene.

Así que la máquina que es más rápida para ti (cachés en el disco, nada que arrancar) también es la que menos cuesta mantener en marcha. Los hosts propios de Skipbox van primero porque no tienen ninguna factura por hora, y los servidores alquilados se llevan el excedente. Por eso Skipbox cobra por la máquina, no por el minuto:

| Minutos al mes (4 vCPU) | GitHub | Skipbox S | Lo que ahorras cada mes |
|---|---|---|---|
| 10.000 | $102 | $39 | **$63** |
| 20.000 | $222 | $39 | **$183** |
| 30.000 | $342 | $39 | **$303** |
| Siempre encendido | $500,40 | $39 | **$461,40** |

A pleno uso, eso es 1/12 del precio de GitHub. Las cifras de GitHub son la factura después del cómputo incluido en GitHub Team. Pon tus propios minutos en la [calculadora de la página de inicio](https://skipbox.dev/?ref=blog-github-actions-job-vm-boot-7-seconds-es#cost); no hace falta iniciar sesión.

## Pasarte es una línea

```yaml
jobs:
  build:
    runs-on: skipbox # was ubuntu-latest
```

1. Inicia sesión en Skipbox con GitHub.
2. Instala la app de GitHub de Skipbox y elige los repositorios.
3. Cambia `runs-on` y haz push.

## Pruébalo

La prueba no pide tarjeta: 7 días o 3000 minutos de trabajos, lo que ocurra primero. Apunta tu flujo de trabajo más lento a `runs-on: skipbox`, ejecútalo dos veces y compara los tiempos de los pasos de la segunda ejecución.

## Preguntas frecuentes

### ¿Cuánto tarda en arrancar en Skipbox una VM nueva para un trabajo de GitHub Actions?

En los propios hosts de Skipbox, 7,25 segundos desde que el host acepta el trabajo hasta que se inicia el proceso del ejecutor, frente a 22,9 segundos antes. La mayoría de los trabajos no arrancan nada: se ejecutan en la máquina dedicada de tu cuenta, que se mantiene entre trabajos.

### ¿Es seguro arrancar las VM de los trabajos de CI con SeaBIOS en lugar de UEFI secure boot?

Sí, para la VM de un trabajo. Secure boot protege la cadena de arranque del invitado frente a un reemplazo, y un trabajo de CI ya tiene root en su propia VM, que se elimina después del trabajo. En Skipbox, las VM se mantienen separadas mediante KVM y un firewall por VM en el host, y ninguno de los dos depende del firmware del invitado.

### ¿Por qué fsync es lento en una VM sobre ZFS, y cómo se arregla para la CI?

Cada fsync del invitado espera a que el ZFS del host confirme su intent log. El disco de la VM nueva de un trabajo se elimina con el trabajo, así que Skipbox monta su ext4 sin barreras: yarn install es un 23 % más rápido y docker pull un 19 % más rápido. Una máquina que se mantiene entre trabajos conserva sus barreras.

### ¿Por qué KVM marca el TSC como inestable en una CPU híbrida?

KVM compara el TSC cuando una vCPU se mueve a otra CPU del host, y entre núcleos de rendimiento y de eficiencia puede leer un valor más bajo. Fijar cada vCPU a una CPU del host evita que se ejecute la comprobación: el bucle de arranque y parada de Skipbox mantuvo entonces el TSC durante 40 rondas.

### ¿Cómo ejecuto mis trabajos en Skipbox?

Cambia runs-on a skipbox en un flujo de trabajo. La prueba no pide tarjeta: 7 días o 3000 minutos de trabajos, lo que ocurra primero.

Actualizado el 2026-11-19 · https://skipbox.dev/es/blog/github-actions-job-vm-boot-7-seconds
