# "No space left on device" no GitHub Actions: descubra o que enche o disco, libere espaço ou use um disco maior

> O GitHub garante só 14 GB de espaço livre no executor Linux padrão, e imagens Docker, restaurações de cache e árvores de build o enchem. Como ver o que enche o disco, o que apagar da imagem do executor e de onde vem um disco maior: os executores maiores do GitHub no Team e no Enterprise, ou a máquina dedicada do Skipbox com 80 GB no S, 160 GB no M e 320 GB no L a preço fixo.

"No space left on device" no GitHub Actions significa que o trabalho escreveu mais do que o executor tinha livre, e no executor Linux padrão do GitHub isso é cerca de 14 GB: um mantenedor do runner-images escreveu que o GitHub garante só 14 GB de espaço livre tanto para repositórios privados quanto públicos, porque as ferramentas pré-instaladas da imagem ocupam o resto (a listagem de um usuário no `ubuntu-latest`: 12 GB de Android SDK, 8,5 GB de cache de ferramentas hospedado, 5,5 GB de GHC). Imagens Docker, um cache restaurado descompactado no disco e árvores de build enchem 14 GB rápido. Resolva nesta ordem: veja o que enche o disco (`df -h`, `df -i`, `du`, `docker system df`), escreva menos, apague as ferramentas pré-instaladas que o trabalho não usa e, se ainda não couber, rode o trabalho em um disco maior. Os executores maiores do GitHub têm 75 GB ou mais, só no GitHub Team e no Enterprise Cloud.

O Skipbox roda os seus trabalhos em uma máquina que ele hospeda só para a sua conta, com 80 GB de disco no S, 160 GB no M e 320 GB no L, a preço fixo com minutos ilimitados. Os caches que ele mantém entre os trabalhos ficam nesse disco, e ele reduz os mais antigos quando o disco enche, então nada precisa ser apagado no início de um trabalho.

- 80 GB de disco no S, 160 GB no M, 320 GB no L, contra cerca de 14 GB livres no executor padrão do GitHub
- As imagens e camadas do Docker e os caches de pacotes ficam nesse disco entre os trabalhos
- Passando de 85% depois de um trabalho, o disco é reduzido de volta a 75%, começando pelo que foi usado há mais tempo

**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=g-github-actions-no-space-left-on-device-pt-br)

## Quanto disco tem um executor do GitHub

A página [executores hospedados pelo GitHub](https://docs.github.com/en/actions/reference/runners/github-hosted-runners) lista 14 GB de SSD para o executor Linux padrão, em repositórios privados e públicos. Na [discussão #9329 do runner-images](https://github.com/actions/runner-images/discussions/9329), depois que uma mudança na imagem cortou o espaço livre nos executores Ubuntu de mais de 31 GB para mais de 17 GB, um mantenedor respondeu que eles de fato garantem só 14 GB de espaço livre para repositórios privados e públicos. Planeje com 14 GB.

O resto do disco é a imagem. Na [issue #10386](https://github.com/actions/runner-images/issues/10386), em que restavam 72 MB livres, o `du` de um usuário no `ubuntu-latest` mostrou:

| Diretório | Tamanho |
|---|---|
| `/usr/local/lib/android` | 12 GB |
| `/opt/hostedtoolcache` | 8,5 GB (só o CodeQL, 5 GB) |
| `/usr/local/.ghcup` | 5,5 GB |

## 1. Veja o que enche o disco

Acrescente um step depois do que falha, com `if: always()`:

```yaml
- name: Disk usage
  if: always()
  run: |
    df -h
    df -i /
    sudo du -xh --max-depth=1 / 2>/dev/null | sort -rh | head -15
    docker system df || true
```

- `df -h` mostra cada sistema de arquivos e quanto ele está cheio. Anote em qual o seu trabalho escreve: o workspace, os dados do Docker em `/var/lib/docker` ou o diretório temporário.
- `df -i` mostra os inodes. Um disco pode ficar sem inodes (um por arquivo) com bytes ainda livres, e o erro é o mesmo.
- `du` mostra os maiores diretórios.
- [`docker system df`](https://docs.docker.com/reference/cli/docker/system/df/) mostra quanto ocupam as imagens, os contêineres, os volumes e o cache de build do Docker.

## 2. Escreva menos

- **Limpe o Docker entre os builds.** O [`docker system prune`](https://docs.docker.com/reference/cli/docker/system/prune/) remove contêineres parados, redes sem uso, imagens órfãs e cache de build sem uso; `-a` remove todas as imagens sem uso, e `--volumes` também os volumes anônimos.
- **Faça cache do que compensa.** Um cache restaurado é descompactado no disco do executor, então um arquivo de cache grande ocupa mais espaço que o download dele. Divida-o por trabalho, ou deixe de fora o que é rápido de buscar de novo.
- **Limpe as árvores de build** de que um step posterior não precisa, antes do step que precisa do espaço.

## 3. Apague as ferramentas pré-instaladas que o trabalho não usa

Segundo a [issue #2875](https://github.com/actions/runner-images/issues/2875) e a #10386:

```yaml
- name: Free disk space
  run: |
    sudo rm -rf /usr/local/lib/android /usr/local/.ghcup /opt/hostedtoolcache/CodeQL
    sudo rm -rf /usr/share/dotnet /usr/local/share/boost
    df -h /
```

Dois custos. Apagar gigabytes leva tempo a cada execução, já que a VM do próximo trabalho os tem de novo. E remover o `$AGENT_TOOLSDIRECTORY` (o cache de ferramentas hospedado inteiro) libera mais, mas, como o autor da #2875 descobriu, quebra as ferramentas que os steps esperam encontrar. A action [free-disk-space](https://github.com/marketplace/actions/free-disk-space-ubuntu) reúne essas exclusões; o autor dela acrescentou a opção do cache de ferramentas depois da discussão, dizendo que ela libera 6 GB a mais.

## 4. Rode o trabalho em um disco maior

| Executor | Disco | Quem pode usar |
|---|---|---|
| Executor Linux padrão do GitHub | SSD de 14 GB, cerca de 14 GB livres | Todos |
| Executor maior do GitHub, de 2 a 96 vCPU | 75 GB com 2 vCPU, 150 GB com 4, 300 GB com 8, até 2.040 GB ([executores maiores](https://docs.github.com/en/actions/reference/runners/larger-runners)) | Organizações no GitHub Team e no Enterprise Cloud, por minuto ([sobre os executores maiores](https://docs.github.com/en/actions/concepts/runners/larger-runners)) |
| Executor auto-hospedado | O que você der a ele; um executor mantido entre os trabalhos enche de imagens e workspaces antigos, a menos que algo o limpe | Qualquer um, e você o mantém |
| Máquina dedicada do Skipbox | 80 GB no S, 160 GB no M, 320 GB no L, reduzida quando enche | Organizações e contas pessoais, preço fixo |

## O que o Skipbox faz com o disco

Cada plano vem com a máquina dedicada da sua conta, mantida entre os trabalhos, com o disco do tamanho dela:

- **O disco tem 80 GB no S, 160 GB no M, 320 GB no L.**
- **O que fica nele é o seu estado:** as imagens, as camadas e o cache de build do Docker, o `~/.npm`, o store do pnpm, o `~/.cache`, os caches do Go, do Gradle, do Maven e do Cargo, e as ferramentas que os `setup-*` instalaram. O que o `actions/cache` salva fica ao lado da máquina, até a metade do disco.
- **Ele não enche.** Nada é apagado até o disco estar mais de 85% cheio depois de um trabalho. Aí ele é reduzido de volta a 75%, começando pelo que foi usado há mais tempo: imagens órfãs, depois o cache de build do Docker, depois caches de pacotes inteiros e builds mantidos. Só se ainda passar de 85% a máquina é redefinida.
- **Mais disco fica a um plano acima.** Um trabalho que escreve dezenas de gigabytes por conta própria, como imagens grandes ou uma árvore de build grande, tem 160 GB no M e 320 GB no L.

| Rótulo | Máquina | Disco | Plano |
|---|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | 80 GB | S, $39 por mês |
| `skipbox-8x16` | 8 vCPU · 16 GB | 160 GB | M, $79 por mês |
| `skipbox-16x32` | 16 vCPU · 32 GB | 320 GB | L, $149 por mês |

Os minutos são ilimitados. Com 20.000 minutos por mês em 4 vCPU, o GitHub cobra $222; o Skipbox S custa $39.

## Mudar é uma linha

```yaml
jobs:
  build:
    runs-on: skipbox-8x16 # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      # the "Free disk space" step can go
      - run: docker build -t app .
```

O `skipbox-8x16` roda em um plano M; `runs-on: skipbox` roda no S e no teste.

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.

## Segurança

- A máquina é só da sua conta. Nenhum trabalho de outra empresa roda nela.
- Depois de cada trabalho, as credenciais, os processos e os contêineres do executor são apagados, e também os arquivos de credenciais no diretório home. Limpar a cada trabalho dá, em vez disso, uma máquina nova a cada trabalho.
- O código de pessoas sem acesso de escrita (como pull requests de forks) roda em uma VM nova que lê os seus caches mas não pode alterá-los.

Os detalhes estão em [como os trabalhos são isolados](https://docs.skipbox.dev/pt-br/isolation).

## Teste no trabalho que fica sem disco

O teste é grátis por 7 dias ou 3.000 minutos de trabalhos, o que vier primeiro, e não pede cartão. Ele roda `runs-on: skipbox` na máquina do S, com 80 GB. Mova o trabalho para lá, tire o step que apaga ferramentas pré-instaladas e rode-o.

## Perguntas frequentes

### Quanto espaço em disco tem um executor do GitHub Actions?

A documentação do GitHub lista 14 GB de SSD para o executor Linux padrão, em repositórios privados e públicos, e um mantenedor do runner-images escreveu que o GitHub garante só 14 GB de espaço livre nos dois casos. O disco em si é maior, mas as ferramentas pré-instaladas da imagem do executor ocupam o resto, então planeje com 14 GB.

### Como resolver No space left on device no GitHub Actions?

Primeiro veja o que o encheu: df -h para cada sistema de arquivos, df -i para os inodes, sudo du -xh --max-depth=1 / para os maiores diretórios e docker system df para as imagens e o cache de build do Docker. Depois escreva menos (limpe o Docker entre os builds, faça cache só do que compensa), apague as ferramentas pré-instaladas que o trabalho não usa (o Android SDK, o GHC, o CodeQL, o .NET) e, se o trabalho ainda precisar de mais, rode-o em um executor com disco maior.

### O que posso apagar do ubuntu-latest para liberar espaço em disco?

As ferramentas que o trabalho não usa. Os usuários nas issues do runner-images do GitHub removem /usr/local/lib/android (12 GB na listagem de um usuário), /usr/local/.ghcup, /opt/hostedtoolcache/CodeQL, /usr/share/dotnet e /usr/local/share/boost. Remover o $AGENT_TOOLSDIRECTORY libera também o cache de ferramentas hospedado, mas quebra os steps de setup que esperam as ferramentas lá. Apagar gigabytes leva tempo a cada execução.

### Os executores maiores do GitHub têm mais disco?

Sim: 75 GB com 2 vCPU, 150 GB com 4, 300 GB com 8, até 2.040 GB com 64 e 96 vCPU. Eles são só para organizações no GitHub Team ou no GitHub Enterprise Cloud, cobrados por minuto.

### Quanto disco o Skipbox dá a um trabalho?

A máquina dedicada da sua conta tem 80 GB no S, 160 GB no M e 320 GB no L. Os caches mantidos entre os trabalhos dividem esse disco: depois de um trabalho que o deixa mais de 85% cheio, ele é reduzido de volta a 75%, começando pelo que foi usado há mais tempo, então ele não enche como o disco de um executor auto-hospedado. Para um trabalho que escreve dezenas de gigabytes por conta própria, o M e o L dão o espaço.

### Quanto custa testar?

Nada. O teste dura 7 dias ou 3.000 minutos de trabalhos, o que vier primeiro, sem cartão, na máquina do S. Mova o trabalho que fica sem disco para runs-on: skipbox e tire os steps que apagam ferramentas pré-instaladas.

Atualizado em 2026-11-19 · https://skipbox.dev/pt-br/guides/github-actions-no-space-left-on-device
