Pular para o conteúdo
LatchkeyLatchkey home

O Que É uma Fila de Merge?

Uma fila de merge serializa merges de pull requests e testa cada um contra a main mais recente, para que a branch main nunca quebre por merges concorrentes.

Uma fila de merge resolve um problema sutil em repositórios movimentados. Dois pull requests podem cada um passar no CI por conta própria, mas quebrar a main quando ambos fazem merge, porque nenhum foi testado contra o outro. Uma fila de merge fecha essa lacuna testando as mudanças contra a main atualizada, uma de cada vez, antes que elas aterrissem.

O problema que ela resolve

Quando muitos PRs passam no CI em paralelo, cada um foi testado contra uma main mais antiga. Fazer merge deles em rápida sucessão pode produzir uma combinação que nenhum pipeline jamais executou, quebrando a branch. Essa corrida piora à medida que a equipe e sua taxa de merge crescem.

Como uma fila de merge funciona

Em vez de fazer merge diretamente, PRs aprovados entram em uma fila. O sistema constrói cada um sobre a main atual (e as mudanças enfileiradas à sua frente), executa o CI e só faz merge se passar. Entradas que falham são removidas para que não possam quebrar a branch.

Por que isso importa

Uma fila de merge garante que o que aterrissa na main foi de fato testado contra o estado exato no qual faz merge. O resultado é uma branch main que permanece verde mesmo sob merges pesados e concorrentes, eliminando o combate a incêndios que vem de uma quebra surpresa que nenhum PR isolado causou.

Filas de merge e CI/CD

Uma fila de merge pode disparar muitas execuções especulativas de CI conforme valida entradas enfileiradas, então ela impõe demanda real aos seus runners; runners lentos ou com capacidade limitada transformam a fila em um gargalo. Capacidade de runners ampla e rápida, do tipo que plataformas gerenciadas como a Latchkey oferecem, mantém uma fila movimentada fluindo para que os merges não travem.

Quando adotar uma

  • Útil quando merges concorrentes começam a quebrar a main.
  • Combina com status checks obrigatórios e proteção de branch.
  • Precisa de capacidade de CI suficiente para validar entradas enfileiradas rapidamente.
  • Mantém a main verde para equipes de alta velocidade.

Applying this to your pipeline

  • Measure before changing. Most CI optimisation targets the wrong step because the slow one is assumed rather than timed.
  • Cache what is expensive to produce and cheap to validate, and key the cache to the exact tool version.
  • Fail fast: run the cheapest checks that can reject a change first, so an expensive job never starts on code that cannot pass.
  • Prefer determinism over speed when they conflict. A fast pipeline nobody trusts gets re-run, which is slower than a slow one that is believed.

Principais conclusões

  • Uma fila de merge serializa merges e testa cada um contra a main mais recente.
  • Ela evita as corridas de main quebrada que PRs independentes podem causar.
  • Ela precisa de capacidade de CI ampla e rápida para manter a fila fluindo.

Perguntas frequentes

What is What is a merge Queue??
A merge queue solves a subtle problem in busy repositories. Two pull requests can each pass CI on their own, yet break main when both merge, because neither was tested against the other. A merge queue closes that gap by testing changes against the up-to-date main, one at a time, before they land.
The problem it solves?
When many PRs pass CI in parallel, each was tested against an older main. Merging them in quick succession can produce a combination no pipeline ever ran, breaking the branch. This race grows worse as a team and its merge rate scale up.
How a merge queue works?
Instead of merging directly, approved PRs enter a queue. The system builds each one on top of the current main (and the queued changes ahead of it), runs CI, and merges only if it passes. Failing entries are kicked out so they cannot break the branch.
Why it matters?
A merge queue guarantees that what lands on main was actually tested against the exact state it merges into. The result is a main branch that stays green even under heavy, concurrent merging, eliminating the firefighting that comes from a surprise breakage no single PR caused.

Guias relacionados