Sprawa runnera, którego oskarżono dwa razy

Krótka historia detektywistyczna o runnerze CI oskarżonym o dwa przestępstwa jednego poranka. Pierwszego nie popełnił. W drugie wrobiło go jedno słowo dopisane do jego identyfikatora.

 ┌──────────────────────────────────────────────────────────────┐
 │                       TABLICA ŚLEDZTWA                       │
 ├──────────────────────────────────────────────────────────────┤
 │                                                              │
 │   SPRAWA 1: „pipeline'y ciągle się anulują”                  │
 │       podejrzany: nowy runner ........ NAWET ICH NIE DOTKNĄŁ │
 │       sprawca: ustawienie GitLaba, które robiło swoje        │
 │                                                              │
 │   SPRAWA 2: „buildy obrazów padają na nowym runnerze”        │
 │       podejrzany: nowy runner ........ WINNY, NA PAPIERZE    │
 │       sprawca: jeden tag, dopisany mu tego samego ranka      │
 │                                                              │
 │   dowody: 5 anulowanych pipeline'ów, 0 uruchomionych zadań   │
 │           7 projektów, 1 identyczny błąd, 1 zmieniony tag    │
 └──────────────────────────────────────────────────────────────┘

Punkt wyjścia

Firma przenosiła swoje CI w nowe miejsce. Stary runner GitLaba był klasykiem: jedna duża maszyna wirtualna, executor Dockera, kontenery uprzywilejowane. Działał, a nikt nie chciał tłumaczyć, dlaczego jest bezpieczny.

Nowy runner mieszkał na współdzielonym klastrze Kubernetes. Zadania stały się podami, węzły dostarczał Karpenter, a jedna zasada była celowo ostra: żadnych uprzywilejowanych podów. Zadania CI uruchamiają kod wielu zespołów, więc traktuje się je jako niezaufane.

Migracja szła według ostrożnego wzorca. Nowy runner miał własne tagi i odmawiał zadań bez tagów, więc nie brał niczego, o co pipeline wprost nie poprosił. Zespoły dołączały pojedynczo. Stary runner obsługiwał wszystkich pozostałych.

Właśnie ten wzorzec sprawił, że następny poranek był tak mylący.

Sprawa 1 — pipeline'y, które umarły przed narodzinami

Pierwsze zgłoszenie przyszło przed południem:

Zobacz pipeline'y w repo deployowym. Anulują się. Myślę, że to nowy runner. Choć jego pod wygląda dobrze.

Lista pipeline'ów rzucała się w oczy. Trzy anulowane z rzędu, potem jeden zielony. Wcześniej tego ranka: dwa anulowane, potem jeden zielony.

Pierwszym użytecznym krokiem było zestawienie obok siebie dwóch kolumn: kiedy anulowano każdy pipeline i kiedy powstał następny.

 anulowany o   następny pipeline utworzony o
 ───────────   ─────────────────────────────
  07:35:47      07:35:46
  07:36:05      07:36:04   ← ten się udał
  09:20:56      09:20:47
  09:21:23      09:21:17
  09:22:01      09:22:00   ← ten się udał

Każde anulowanie wypadało kilka sekund po pojawieniu się kolejnego pipeline'u. Potem same anulowane zadania: brak czasu startu, brak przypisanego runnera. Żadne nie dotarło do żadnego runnera, ani starego, ani nowego.

Robiło to coś, co stoi przed wszystkimi runnerami. Było to „auto-cancel redundant pipelines” GitLaba, włączone dla projektu. Gdy na gałęzi startuje nowy pipeline, starsze, które jeszcze nie wystartowały, są anulowane.

Ale te pipeline'y wystartowały. Prawda? Ich pierwszym etapem było zadanie-bramka z when: delayed i start_in: 5 minutes, które miało dać ArgoCD czas na wdrożenie, zanim odpalą się dalsze kontrole. Opóźnione zadanie siedzi w stanie scheduled, a GitLab liczy scheduled jako niewystartowane. Każdy pipeline przez pierwsze pięć minut dawał się więc anulować. Dowolne dwa merge'e w odstępie krótszym niż pięć minut zabijały starszy pipeline.

Programista scalił kilka MR-ów jeden po drugim. Zupełnie normalne zachowanie w repozytorium deployowym.

Werdykt w sprawie runnera: niewinny. Nigdy nie widział tych zadań.

Błędny trop

Pierwsze podsumowanie mówiło coś uspokajającego: „Nic nie zginęło. Najnowszy pipeline działa na najnowszym main, który zawiera wszystkie wcześniejsze zmiany.”

Potem padło kolejne pytanie: „To wyłączyć auto-cancel?” Żeby odpowiedzieć uczciwie, ktoś musiał przeczytać, co ocalały pipeline faktycznie robił. I tam uspokajające podsumowanie się rozsypało.

Zadanie sprawdzające zdrowie wdrożenia w tym pipelinie nie patrzyło na stan main. Porównywało ten push z poprzednim pushem:

git diff "$CI_COMMIT_BEFORE_SHA" "$CI_COMMIT_SHA"

Każdy merge to osobny push. Jedyny ocalały pipeline sprawdził więc zdrowie tylko ostatniego merge'a. Pozostałe trzy wdrożenia z tej serii nigdy nie dostały raportu o zdrowiu i nikt się o tym nie dowiedział.

„Najnowszy pipeline to pokrywa” jest prawdą tylko wtedy, gdy każde zadanie patrzy na gałąź, a nie na push. Auto-cancel został wyłączony. Wcześniejsze podsumowanie dostało jawną korektę zamiast cichej edycji.

Sprawa 2 — błąd, który miał być niemożliwy

Niecałą godzinę później przyszło drugie zgłoszenie, z wklejonym logiem:

error: failed to solve: failed to read dockerfile:
  failed to mount /tmp/buildkit-mount…: [{Type:bind …}]:
  … err: operation not permitted

Tym razem nowy runner uruchomił zadanie. Dowodziła tego nazwa poda w logu.

Sam błąd był znajomy. Kilka tygodni wcześniej, podczas pierwszej próby nowego runnera, zespół uderzył dokładnie w tę ścianę. Współdzielony szablon budowania używa buildctl-daemonless.sh z BuildKita, który uruchamia rootful demona BuildKit w kontenerze zadania. Rootful BuildKit musi bind-mountować swoje snapshoty i pisać do cgroups. Na Kubernetesie oznacza to privileged: true i nic węższego nie wystarczy. Dlatego nowy runner nigdy nie miał dostawać takich zadań.

Więc dlaczego je dostawał?

Historia zadań samego runnera opowiedziała to w jednym zapytaniu. Do około 09:15 uruchamiał tylko zadania infrastrukturalne zespołu platformowego. Po 09:15 budował obrazy aplikacji frontendowych, usług backendowych, wszystkiego.

 projekt               zadanie           runner   czas    wynik
 ───────────────────   ───────────────   ──────   ─────   ───────
 service-A             build_container   STARY    08:51   success
 service-A             build_container   STARY    08:58   success
 service-A             build_container   NOWY     09:15   failed
 service-A             build_container   NOWY     09:25   failed
 frontend-B            build_container   NOWY     09:37   failed
 service-C             build_container   NOWY     09:40   failed
 …siedem projektów, jeden identyczny błąd

Potem lista tagów runnera. Obok jego dwóch tagów opt-in siedział trzeci: współdzielony tag, który obsługuje stary runner, ten sam, który nosi każde zadanie budujące w organizacji. Ktoś dodał go tego ranka. Jedną edycją nowy runner przeszedł od „nie bierze niczego, o co go nie poproszą” do „konkuruje o wszystko”.

Lekkie zadania, takie jak lintery i aktualizacje manifestów, przechodziły na nim, przez co awaria wyglądała na częściową i losową. Padały tylko buildy obrazów i tylko wtedy, gdy nowy runner akurat wygrał wyścig o zadanie.

Werdykt w sprawie runnera: buildy faktycznie oblał. Ale został do tego ustawiony. Usunięcie tagu w ciągu kilku minut odesłało wszystkie buildy z powrotem do starego runnera.

Prawdziwa poprawka — i zwrot akcji w aktualizacji

„Usuń tag” tamuje krwawienie. Nie pozwala jednak kontynuować migracji. Oczywiste następne pytanie zadaje każdy: czy nie da się tego po prostu naprawić w konfiguracji runnera?

Technicznie tak: privileged = true. Ale to dałoby roota na węźle każdemu zadaniu CI na tym runnerze, łącznie z zadaniami infrastrukturalnymi, które niosą poświadczenia do chmury. Dokładnie tej architektury migracja miała uniknąć. Sprytniejszy hack po stronie runnera (podmiana skryptu budującego tak, by wskazywał na współdzielonego demona) przepchnąłby każdy build w firmie przez jeden nieuwierzytelniony socket. Nie.

Prawdziwa poprawka była w szablonie. Współdzielony komponent budujący, utrzymywany przez inny zespół, poszedł do przodu: nowsza wersja główna i opublikowany obraz rootless BuildKita. Rootless BuildKit działa w przestrzeni nazw użytkownika, nie potrzebuje uprawnień, a na Kubernetesie wymaga jednej flagi (--oci-worker-no-process-sandbox). Szablon po prostu przypinał starą wersję sprzed kilku miesięcy.

Czyli: podbić wersję, zmienić obraz, gotowe?

Niezupełnie. Lektura różnic między wersjami ujawniła zwrot akcji. Nowa wersja główna przeniosła całe swoje ciało, logowanie do rejestru i build, z before_script do script. Szablony-opakowania Firmy robiły to:

before_script:
  - !reference [.shared-build-job, before_script]   # ← w v2 już nie istnieje

Samo podbicie wersji skierowałoby każde opakowanie na klucz, którego już nie ma. Opakowania przepisano tak, by zostawiały tylko własne kroki. Zaktualizowany komponent dokleja potem swoje poświadczenia do rejestru do tego samego pliku konfiguracyjnego. Sprawdzono, że ten plik jest scalany (używa jq), a nie nadpisywany.

Dowód bez psucia nikomu

Zmiana miała trafić naraz do mniej więcej siedemdziesięciu projektów, więc udowodniono ją, zanim ktokolwiek zrobił przegląd.

Metoda: jednorazowa gałąź w jednym z projektów, w których buildy padły. Różnica była malutka: wskazać include na gałąź z poprawką i uruchomić ten sam build dwa razy z nadpisaniem tags: na poziomie zadania. Jedna kopia poszła na nowy runner, druga na stary.

 build_container          → nowy runner (bez uprawnień)   ✅ 2m33s
 build_container_on_old   → stary runner (uprzywilejowany) ❌ ...

Drugi błędny trop wziął się z tego testu, nie z poprawki. Build na starym runnerze skompilował wszystko, po czym padł na samym ostatnim kroku:

The image tag '…-<commit>' already exists … (immutable)

Oba zadania budowały ten sam commit, więc wytworzyły ten sam tag, a rejestr odmawia nadpisywania tagów. Wygrało zadanie, które skończyło pierwsze. Jednolinijkowy commit dla świeżego tagu, ponowne uruchomienie i oba runnery wróciły na zielono, z tym samym obrazem, cache'em, poświadczeniami i sekretami co wcześniej.

Potem pytanie, które naprawdę się liczy: czy to bezpieczne i czy pipeline'y wyprodukują to samo co wcześniej? To znaczyło więcej niż „raz się zbudowało”:

Ostatnia wpadka

Plan wdrożenia kończył się rozsądnie brzmiącym krokiem: „scal, a potem obserwuj pierwsze buildy na nowym runnerze”.

Inżynier, który go przeglądał, od razu zauważył dziurę:

Jeśli runner nie ma tagu, to jak mam to zobaczyć?

Słusznie. Po usunięciu współdzielonego tagu żaden build nigdy nie trafiłby po scaleniu na nowy runner. „Obserwuj nowy runner” oznaczałoby obserwowanie niczego. Plan zamienił się w trzy etapy, z których każdy odpowiada na inne pytanie:

 etap 1  scalenie          → nowy szablon, tylko STARY runner  (czy jest bezpieczny dla wszystkich?)
 etap 2  kanarek na zadaniu → jeden build MR na NOWY runner   (czy tam działa?)
 etap 3  przywrócenie tagu  → buildy dzielone między oba      (czy wytrzyma prawdziwy ruch?)
         wycofanie na każdym etapie: revert albo usunięcie tagu

Jest znana luka, zapisana, a nie ukryta: pipeline tagu wydania używa pliku CI z otagowanego commita, więc etap 2 nie może przetestować ścieżki wydań. Tę obserwuje się w etapie 3.

Wskazówki dla czytelnika