# Para onde foram 23 segundos: iniciando a VM de um trabalho do GitHub Actions em 7

> Uma máquina virtual KVM nova para um trabalho do GitHub Actions levava 22,9 s para chegar ao executor nos hosts do Skipbox. Agora leva 7,25 s. Cada segundo e como foi medido, do executor a $39 fixos por mês com minutos ilimitados.

Uma máquina virtual nova para um trabalho do GitHub Actions levava 22,9 segundos em um host do Skipbox para ir de "o host aceitou o trabalho" até "o processo do executor começa". Agora leva 7,25 segundos. Este post mostra onde estavam os outros 15 segundos e como cada um foi medido.

O Skipbox é um executor do GitHub Actions a $39 fixos por mês com minutos ilimitados. Os seus trabalhos rodam em uma máquina que o Skipbox hospeda só para a sua conta, mantida entre os trabalhos, e os trabalhos que precisam de uma VM nova a recebem em 7 segundos. Troque uma linha de `runs-on` para mudar.

- Uma VM nova de trabalho chega ao executor em 7,25 s, contra 22,9 s antes
- Na sua máquina dedicada aquecida, os steps de setup de um trabalho levam 7 s contra 52 s no `ubuntu-latest` do GitHub
- 20.000 minutos por mês com 4 vCPU: $222 no GitHub, $39 no Skipbox

**GitHub Actions a preço fixo, minutos ilimitados** O Skipbox roda os seus trabalhos do GitHub Actions na sua própria máquina dedicada: $39 por mês, não importa quantos minutos você rode. As camadas Docker e o cache de dependências ficam entre os trabalhos, então o próximo trabalho começa na hora.

Um executor de 4 vCPU, 20.000 minutos por mês: GitHub $222 → Skipbox $39. Você economiza $183 todo mês.

A mudança é uma linha: `runs-on: skipbox`.

[Começar meu teste grátis de 7 dias](https://app.skipbox.dev/sign-in?ref=blog-github-actions-job-vm-boot-7-seconds-pt-br)

## O que é cronometrado, e onde

Um host do Skipbox roda máquinas virtuais KVM pelo Incus sobre um pool ZFS. A imagem do executor é uma VM parada com um snapshot. Um trabalho que precisa de uma VM nova recebe um clone ZFS desse snapshot, inicializa o clone, recebe uma configuração de executor just-in-time pelo guest agent, roda um trabalho e é excluído com o disco.

O daemon do host registra o fim de cada etapa de um início em milissegundos a partir do momento em que aceita o trabalho (`startMs`: `cloned`, `started`, `agent`). Os números abaixo são de um host Intel i7-7820X de 16 threads e de uma VM de 4 vCPU e 8 GB.

| | Da aceitação ao início do executor, 3 execuções cada |
|---|---|
| Antes | 22,9 s (21,7 a 24,2) |
| Depois | 7,25 s (7,1 a 8,1) |

Para onde foi o tempo, cada parte medida separadamente:

| Mudança | Medido | Economizado |
|---|---|---|
| SeaBIOS em vez de OVMF | Do início da VM à primeira resposta do agent, mediana de 3: 13,7 → 8,4 s | 5,3 s |
| `quiet` na linha de comando do kernel | 8,4 → 6,5 s | 1,9 s |
| Sem initrd | 6,5 → 5,1 s | 1,4 s |
| Uma imagem já do tamanho dos clones | Clone 1,5 → 0,1 s, primeiro início 2,35 → 1,8 s | 1,9 s |
| Esperar o socket do Docker, não o dockerd | O dockerd subia 3,6 s depois do agent | 3,6 s |
| Perguntar ao guest agent a cada 100 ms, não a cada segundo | 0,5 s em média, até 1 s | 0,5 s |

As partes somam 14,6 s da diferença de ponta a ponta de 15,65 s.

## Firmware: 5,3 segundos antes do GRUB

O Incus inicializa uma VM com OVMF e secure boot por padrão. Neste host, o OVMF levava 5,3 s para passar o controle ao GRUB. O SeaBIOS leva 0,5 s. Duas chaves da instância fazem a troca: `security.csm=true` e `security.secureboot=false`.

Esta foi a maior parte isolada, e a única que toca a segurança, então aqui está por inteiro. Com o SeaBIOS, a assinatura da cadeia de boot do guest não é verificada. O que essa verificação impede é alguém substituir o bootloader ou o kernel do guest. Na VM de um trabalho de CI, esse alguém é o próprio trabalho, e o trabalho já tem root na própria VM: ele pode rodar qualquer coisa com `sudo`, e a VM e o disco dela são excluídos quando o trabalho termina. O que mantém a VM de um cliente longe da de outro é o KVM e uma cadeia de firewall por VM na bridge do host, e nenhum dos dois depende do firmware do guest. A imagem inicializa com os dois, e uma flag no host traz o UEFI de volta.

## Um kernel silencioso, e nenhum initrd

A VM de um trabalho inicializa uma vez para cada trabalho, e ninguém lê o console serial dela. O `quiet` levou a mediana de 8,4 para 6,5 s.

O initrd existe para carregar os drivers que encontram o sistema de arquivos raiz. O kernel genérico do Ubuntu tem virtio-scsi e ext4 embutidos, e todo clone compartilha o UUID de partição da imagem, então o kernel monta `/` diretamente a partir de `root=PARTUUID=…`. Foram mais 1,4 s.

Duas proteções impedem que isso dê errado em silêncio. O GRUB do Ubuntu inicializa sozinho da próxima vez com o initrd se um boot sem ele deu panic (`GRUB_FORCE_PARTUUID`). Esse fallback traria de volta, em silêncio, os 1,4 s para cada trabalho, então o build da imagem inicializa um clone de teste e falha se o `dmesg` mostrar um initramfs sendo descompactado.

## Não redimensione um disco que você podia ter criado no tamanho certo

A imagem era criada em um disco menor, e cada clone era aumentado para o tamanho do plano no início. Aumentar custava 1,9 s por trabalho: o clone levava 1,5 s em vez de 0,1 s, e o primeiro início 2,35 s em vez de 1,8 s. Agora a imagem é criada com o tamanho de disco do menor plano (80 GB). O volume é thin, então a imagem continua guardando só o que foi gravado nela. O Incus não consegue encolher um clone, então a imagem nunca é maior que o menor plano; os planos maiores crescem no boot.

## O socket do Docker basta

O script de execução esperava o `docker.service` antes de iniciar o executor. O dockerd subia 3,6 s depois do guest agent. Mas o systemd escuta no socket do Docker desde o começo do boot, e um cliente que se conecta antes de o dockerd subir espera por ele. Então o script espera só o `docker.socket` e o DNS, com uma espera limitada, e o dockerd termina de subir enquanto o executor sobe.

## Polling a cada 100 ms

A configuração do executor é enviada para dentro da VM pelo guest agent, que só existe depois que o guest inicializou. O host tentava de novo uma vez por segundo, então um trabalho esperava 0,5 s em média depois que o agent subia. O Incus recusa um envio em 20 ms enquanto o agent está fora, então perguntar a cada 100 ms não custa nada. Depois dos primeiros 30 s de uma VM, o host volta a perguntar uma vez por segundo.

## Não é do boot: fsync em um disco que morre com o trabalho

Durante as medições, a coisa mais lenta na VM acabou não sendo o boot. Cada `fsync` no guest esperava o ZFS do host gravar o intent log. O disco de uma VM nova de trabalho é excluído com o trabalho, então nada nele precisa sobreviver a uma queda de energia. O script de execução remonta `/` com `nobarrier` antes de iniciar o executor.

Medianas de 3, em uma VM de 4 vCPU e 8 GB:

| | Antes | Depois |
|---|---|---|
| Gravações aleatórias de 4k com fsync | 227 por segundo | 2.505 por segundo |
| `yarn install`, 1 GB de node_modules a partir do cache | 12,92 s | 9,99 s (23% a menos) |
| `docker pull node:22` | 19,12 s | 15,45 s (19% a menos) |
| Um build Docker do redis | 92,89 s | 87,21 s |
| `make -j4`, `sysbench cpu` | sem mudança | sem mudança |

Só as VMs novas recebem isso. A sua máquina dedicada guarda os seus caches entre os trabalhos, e o ext4 dela mantém os barriers.

## A mesma caçada em servidores de nuvem alugados

Quando os hosts próprios do Skipbox estão cheios, um trabalho roda em um servidor de nuvem inicializado a partir de uma imagem de snapshot. Esse caminho tinha o próprio tempo perdido, em outro lugar. Em um servidor compartilhado Intel de 4 vCPU, o script do trabalho (os user data do servidor) começava 28,1 s depois do kernel. O cloud-init tinha o script em 19,3 s e o Docker subia em 22,2 s, mas o cloud-init roda os user data na última etapa, depois de todo o resto.

A imagem agora tem uma pequena unit do systemd que roda os user data assim que o cloud-init os grava. Ela lê o script por um descritor de arquivo de um arquivo que ela já removeu, então a última etapa do cloud-init não encontra nada para rodar uma segunda vez. A imagem também gera um tipo de chave de host SSH em vez de três (2,0 s no caminho que tudo espera; ninguém faz login nesses servidores), e não inicia mais o snapd, o apport, o rsyslog nem uma dúzia de timers de manutenção no boot.

Com essa imagem, em um servidor compartilhado AMD de 4 vCPU, o script do trabalho começa de 8 a 14 s depois do kernel.

## vCPUs fixadas mantêm certo o relógio de cada host

Em uma CPU híbrida (núcleos de desempenho e núcleos de eficiência, como o Core Ultra 7 265F), o KVM pode deixar de confiar no TSC. Durante uma noite de builds de imagem, o kernel registrou:

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

O KVM compara o TSC quando uma vCPU passa para outra CPU do host. Ele leu um valor menor no núcleo novo, entre tipos de núcleo, e marcou o TSC como instável. O kernel já tinha desativado o HPET no boot ("HPET dysfunctional in PC10"), então a única fonte de relógio que sobrou foi o acpi_pm, que nesta placa quase não avançava: cerca de 1 segundo de uptime em 30 minutos. O

O Skipbox resolve isso em duas etapas:

1. **Um fallback que funciona.** Limitar o C-state do pacote a C8 na BIOS mantém o HPET vivo. O KVM ainda derrubou o TSC, na rodada 11 de um loop de 20 rodadas que inicia e para uma VM de 8 vCPU sob carga, mas o relógio passou para o HPET e manteve a hora.
2. **Fixação.** O KVM só roda essa verificação quando uma vCPU muda de CPU. Com cada vCPU fixada em uma CPU do host, o mesmo loop rodou 40 rodadas no TSC sem nenhuma linha nova no log.

O daemon do host não aceita nenhum trabalho a menos que a fonte de relógio seja `tsc` e o `hpet` esteja disponível, então um host que perde o TSC se esvazia sozinho e os trabalhos dele vão para outras máquinas. Todo host do Skipbox fixa as vCPU.

## O boot mais rápido é o que você pula

Sete segundos são para os trabalhos que precisam de uma VM nova: código de pessoas sem acesso de escrita (como pull requests de forks), um trabalho que chega enquanto a sua máquina está ocupada, e as contas que escolhem uma VM limpa para cada trabalho. Todos os outros trabalhos não inicializam nada. Eles rodam na máquina dedicada da sua conta, com as camadas Docker, os caches de pacotes e as ferramentas do último trabalho ainda no disco.

É aí que estão os minutos. Os mesmos workflows no `ubuntu-latest` do GitHub (2 vCPU, o que um repositório privado recebe) e em um Skipbox S aquecido (4 vCPU), medianas de execuções aquecidas:

| | GitHub `ubuntu-latest` | Skipbox S, aquecido | |
|---|---|---|---|
| excalidraw: instalação, build e testes | 613 s | 450 s | 27% a menos |
| Steps de setup (checkout, Node, restauração do cache) | 52 s | 7 s | |
| Testes | 484 s | 354 s | |
| umami: build Docker multi-stage | 263 s | 188 s | 29% a menos |

Os steps de setup caem de 52 s para 7 s porque não há arquivo de cache para baixar e descompactar: o Node já está no cache de ferramentas e o cache do yarn está no disco. O build Docker usa o cache de camadas do próprio daemon, sem nada exportado ou importado. No Skipbox, o workflow não tem nenhum step de cache.

## Por que um preço fixo consegue manter uma máquina aquecida

Uma máquina ociosa parece desperdício. Pelo jeito como a computação é cobrada, ela é a opção mais barata, e é isso que faz um preço fixo funcionar.

Um servidor de nuvem alugado é cobrado por cada hora que ele inicia, por inteiro. Um trabalho de 3 minutos no próprio servidor paga 60 minutos. Em um dia do nosso próprio CI, 44 trabalhos de 2,5 minutos em média rodaram em 44 servidores e foram cobrados por 44 horas de servidor. Repetindo o mesmo dia com cada servidor mantido para o próximo trabalho da conta dentro da mesma hora, dá de 13 a 14 horas de servidor: cerca de 70% a menos. E um mês tem 730 horas: uma conta que roda mais de 730 trabalhos curtos por mês em servidores por trabalho paga mais horas do que uma máquina que nunca para.

Então a máquina mais rápida para você (caches no disco, nada para inicializar) também é a mais barata de manter. Os hosts que o Skipbox possui vêm primeiro porque não têm nenhuma fatura por hora, e os servidores alugados ficam com o excedente. É por isso que o Skipbox cobra pela máquina, não pelo minuto:

| Minutos por mês (4 vCPU) | GitHub | Skipbox S | Você economiza todo mês |
|---|---|---|---|
| 10.000 | $102 | $39 | **$63** |
| 20.000 | $222 | $39 | **$183** |
| 30.000 | $342 | $39 | **$303** |
| Sempre ligado | $500,40 | $39 | **$461,40** |

Em uso total, isso é 1/12 do preço do GitHub. Os valores do GitHub são a fatura depois da computação incluída no GitHub Team. Coloque os seus próprios minutos na [calculadora da página inicial](https://skipbox.dev/?ref=blog-github-actions-job-vm-boot-7-seconds-pt-br#cost); ela não pede login.

## Mudar é uma linha

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

1. Entre no Skipbox com o GitHub.
2. Instale o app do Skipbox no GitHub e escolha os repositórios.
3. Troque o `runs-on` e faça push.

## Teste

O teste não pede cartão: 7 dias ou 3.000 minutos de trabalhos, o que vier primeiro. Aponte o seu workflow mais lento para `runs-on: skipbox`, rode-o duas vezes e compare os tempos dos steps da segunda execução.

## Perguntas frequentes

### Quanto tempo uma VM nova para um trabalho do GitHub Actions leva para iniciar no Skipbox?

Nos hosts próprios do Skipbox, 7,25 segundos do host aceitar o trabalho até o processo do executor começar, contra 22,9 segundos antes. A maioria dos trabalhos não inicializa nada: eles rodam na máquina dedicada da sua conta, que é mantida entre os trabalhos.

### É seguro inicializar as VMs de trabalhos de CI com SeaBIOS em vez de UEFI com secure boot?

Sim, para a VM de um trabalho. O secure boot protege a cadeia de boot do guest contra substituição, e um trabalho de CI já tem root na própria VM, que é excluída depois do trabalho. No Skipbox, as VMs são mantidas separadas pelo KVM e por um firewall por VM no host, e nenhum dos dois depende do firmware do guest.

### Por que o fsync é lento em uma VM sobre ZFS, e como resolver isso para o CI?

Cada fsync no guest espera o ZFS do host gravar o intent log. O disco de uma VM nova de trabalho é excluído com o trabalho, então o Skipbox monta o ext4 dela sem barriers: o yarn install fica 23% mais rápido e o docker pull 19% mais rápido. Uma máquina mantida entre os trabalhos continua com os barriers.

### Por que o KVM marca o TSC como instável em uma CPU híbrida?

O KVM compara o TSC quando uma vCPU passa para outra CPU do host, e entre núcleos de desempenho e de eficiência ele pode ler um valor menor. Fixar cada vCPU em uma CPU do host impede a verificação de rodar: o loop de iniciar e parar do Skipbox então manteve o TSC por 40 rodadas.

### Como rodo os meus trabalhos no Skipbox?

Troque o runs-on para skipbox em um workflow. O teste não pede cartão: 7 dias ou 3.000 minutos de trabalhos, o que vier primeiro.

Atualizado em 2026-11-19 · https://skipbox.dev/pt-br/blog/github-actions-job-vm-boot-7-seconds
