# Playwright no GitHub Actions: execuções E2E mais rápidas com navegadores que continuam instalados

> Playwright no GitHub Actions é npm ci, npx playwright install --with-deps, npx playwright test. Ele é lento porque cada trabalho reinstala os navegadores em uma VM nova e roda 1 worker no ubuntu-latest de 2 núcleos de um repositório privado. No Skipbox, os navegadores ficam na sua máquina e um trabalho recebe até 16 vCPU, por $39 fixos por mês: com 20.000 minutos em 4 vCPU, $183 a menos por mês que o GitHub.

A sua suíte Playwright demora muito mais no GitHub Actions do que no seu notebook, e a equipe espera a lenta a cada pull request. Parte da diferença é a preparação: cada trabalho baixa três navegadores e instala os pacotes de sistema deles antes do primeiro teste. O resto são núcleos: no `ubuntu-latest` de um repositório privado, o Playwright roda um worker.

O Skipbox roda o mesmo workflow em uma máquina que ele hospeda só para a sua conta, onde os navegadores continuam instalados entre os trabalhos e um trabalho recebe até 16 vCPU, por $39 fixos por mês com minutos ilimitados. Mudar é uma linha, `runs-on: skipbox`.

- Os navegadores ficam na sua máquina: nenhum download do `playwright install` a cada trabalho, nenhum cache para gerenciar
- 4, 8 ou 16 vCPU, então os workers padrão do Playwright sobem junto
- 20.000 minutos por mês em 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=g-playwright-github-actions-pt-br)

## Como o Playwright roda no GitHub Actions

A configuração de CI do próprio Playwright são três comandos em um trabalho: `npm ci`, `npx playwright install --with-deps` (os navegadores e os pacotes de sistema de que eles precisam) e `npx playwright test`, com o relatório HTML enviado como artefato mesmo quando os testes falham. O `npm init playwright@latest` o escreve em `.github/workflows/playwright.yml`.

Duas coisas definem a velocidade dele:

| | Executor hospedado pelo GitHub | Skipbox |
|---|---|---|
| Navegadores | Baixados e instalados a cada trabalho. O Playwright desaconselha fazer cache deles, já que uma restauração leva quase o mesmo tempo | Continuam instalados na sua máquina entre os trabalhos |
| Workers (padrão: metade dos núcleos) | 1 no `ubuntu-latest` de 2 núcleos de um repositório privado | Metade de 4, 8 ou 16 vCPU, conforme o rótulo |

Os shards com `--shard=1/4` dividem a suíte entre trabalhos, mas cada shard repete o `npm ci` e a instalação dos navegadores, e na cobrança por minuto a preparação de cada shard é cobrada de novo.

## Quanto custa uma suíte lenta

Os testes end-to-end são a última verificação antes do merge, então a equipe inteira espera por eles. Uma suíte de 20 minutos em 30 pushes de pull request por dia são 10 horas de espera, e a mesma suíte em loop contra o staging roda o dia todo. As falhas instáveis que só aparecem em um executor lento acrescentam novas execuções por cima.

Na cobrança por minuto, cada um desses minutos é cobrado:

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

Os valores do GitHub são depois do uso incluído no GitHub Team. Os seus próprios minutos vão na [calculadora da página inicial](https://skipbox.dev/?ref=g-playwright-github-actions-pt-br#cost).

Os minutos de E2E são os que mais crescem. Os agentes de programação abrem pull requests a qualquer hora, cada um roda a suíte, e as equipes que rodavam E2E à noite agora o rodam a cada push.

## Deixar rápido por conta própria

Nos executores hospedados pelo GitHub, a lista de sempre:

- Dividir a suíte em shards em uma matriz, e depois juntar os relatórios blob em um trabalho final
- Aumentar os timeouts, porque um executor de 2 núcleos renderiza mais devagar que um notebook
- Mudar para a imagem Docker do Playwright e manter a tag dela em sincronia com a sua versão do Playwright
- Pagar por executores maiores por minuto, ou manter o seu próprio executor auto-hospedado e deixar os navegadores, os pacotes e o sistema operacional dele atualizados

Cada passo é mais YAML para cuidar e mais minutos para pagar. O Skipbox mantém os navegadores no disco e dá os núcleos ao trabalho.

## O que o Skipbox dá à sua suíte

**Navegadores que ficam.** Cada plano vem com a máquina dedicada da sua conta, mantida entre os trabalhos. Os navegadores do Playwright em `~/.cache/ms-playwright`, o cache do npm e as suas imagens Docker estão no disco quando o próximo trabalho começa, então o `npx playwright install --with-deps` os encontra lá.

**Workers que escalam.** Escolha o tamanho pelo rótulo. Mais vCPU significa mais workers padrão, e mais memória significa mais navegadores abertos ao mesmo tempo:

| Rótulo | Máquina | Preço |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | $39 por mês (S) |
| `skipbox-8x16` | 8 vCPU · 16 GB | $79 por mês (M) |
| `skipbox-16x32` | 16 vCPU · 32 GB | $149 por mês (L) |

**Minutos ilimitados.** Shards, novas tentativas e novas execuções não mudam a fatura, e os trabalhos do Skipbox não usam minutos do GitHub, então um orçamento do GitHub nunca os para.

**Nada para manter.** A imagem é Ubuntu 24.04 com `sudo` sem senha e as bibliotecas de sistema de que os navegadores do Playwright precisam. O Skipbox a atualiza, limpa tudo depois de cada trabalho e recria uma máquina que falha na verificação de integridade.

## Mudar é uma linha

```yaml
name: Playwright Tests
on: [push, pull_request]
jobs:
  test:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - uses: actions/setup-node@v6
        with:
          node-version: lts/*
      - run: npm ci
      - run: npx playwright install --with-deps
      - run: npx playwright test
      - uses: actions/upload-artifact@v5
        if: "!cancelled()"
        with:
          name: playwright-report
          path: playwright-report/
```

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. Os navegadores e os caches ficam. A partir de 13 de novembro de 2026, o seu checkout e a saída de build dele (o `target/` do Cargo) ficam na sua máquina dedicada para os próximos trabalhos; Limpar a cada trabalho dá a cada trabalho uma máquina nova.
- O código de pessoas sem acesso de escrita (como pull requests de forks) roda em uma máquina nova, descartável.

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

## Teste

O teste é grátis por 7 dias ou 3.000 minutos de trabalhos, o que vier primeiro, sem cartão. Troque o trabalho do Playwright para `runs-on: skipbox`, rode-o duas vezes e compare os tempos de cada step da segunda execução com os do GitHub.

## Perguntas frequentes

### Como rodar testes Playwright no GitHub Actions?

Em um trabalho: npm ci, npx playwright install --with-deps, npx playwright test, e depois envie a pasta playwright-report como artefato em um step que roda mesmo quando os testes falham. O npm init playwright@latest escreve esse workflow para você. Para rodá-lo no Skipbox, troque o runs-on para skipbox.

### Por que os testes Playwright são lentos no GitHub Actions?

Por dois motivos. Cada trabalho começa em uma VM nova, então ele baixa o Chromium, o Firefox e o WebKit e instala os pacotes de sistema deles antes do primeiro teste. E os workers padrão do Playwright são metade dos núcleos de CPU, o que dá 1 worker no ubuntu-latest de 2 núcleos de um repositório privado. O Skipbox mantém os navegadores na sua máquina entre os trabalhos e dá a um trabalho 4, 8 ou 16 vCPU.

### Devo fazer cache dos navegadores do Playwright no GitHub Actions?

O Playwright desaconselha isso em executores que começam de uma VM nova: restaurar o cache leva quase o mesmo tempo que baixar os navegadores, e no Linux os pacotes de sistema não podem ir para o cache. No Skipbox não há nada para colocar em cache. Os navegadores ficam em ~/.cache/ms-playwright na sua máquina, e o próximo trabalho os encontra lá.

### Quantos workers o Playwright usa no GitHub Actions?

Por padrão, metade dos núcleos lógicos de CPU da máquina: 1 no ubuntu-latest de um repositório privado, que tem 2. Cada worker controla o próprio navegador, então mais workers precisam de mais núcleos e mais memória. No Skipbox, runs-on: skipbox-8x16 dá 8 vCPU e 16 GB.

### Posso testar o Playwright no Skipbox de graça?

Sim. O teste dura 7 dias ou 3.000 minutos de trabalhos, o que vier primeiro, sem cartão, com 4 vCPU e 16 GB. Troque o runs-on do trabalho do Playwright para skipbox e rode-o duas vezes.

Atualizado em 2026-11-19 · https://skipbox.dev/pt-br/guides/playwright-github-actions
