CI/CD i wdrożenia deklaratywne

Jeden wersjonowany szablon pipeline’u w GitLab CI, niezmienne tagi obrazów z wersją i skrótem commita oraz wdrażanie przez pętlę uzgadniania w Argo CD zamiast skryptu.

CI/CDKubernetes i GitOps

Pipeline kopiowany między repozytoriami rozchodzi się na wiele plików o wspólnym przodku, tag latest odbiera wdrożeniu powtarzalność i możliwość wycofania, a skrypt wykonujący kubectl apply nie widzi zmian wprowadzonych na klastrze po jego zakończeniu. Dokument opisuje trzy elementy jednego łańcucha dostarczania: wspólny szablon pipeline’u w GitLab CI, tag obrazu jako niezmienną wersję oraz wdrażanie przez kontroler GitOps (Argo CD) zamiast skryptu.

Szablon pipeline’u: include i zmienne

Logika pipeline’u leży w jednym repozytorium z szablonami, dołączanym przez include, wersjonowanym tagami i testowanym przed każdym wydaniem. Plik .gitlab-ci.yml projektu zawiera klucz include z polami project (ścieżka repozytorium z szablonami), ref (gałąź, tag lub SHA commita) i file (ścieżka pliku, może być listą) oraz sekcję variables: z czterema wartościami: nazwą aplikacji (APP_NAME), katalogiem w monorepozytorium (APP_PATH), obrazem środowiska uruchomieniowego (RUNTIME_IMAGE) i poleceniem testów (TEST_COMMAND). GitLab scala dołączoną konfigurację z lokalną, a wartości zdefiniowane w projekcie mają pierwszeństwo, więc zmienne projektu nadpisują wartości domyślne szablonu o tej samej nazwie. Repozytorium szablonów musi być czytelne dla osób uruchamiających pipeline’y; najprościej nadać mu widoczność wewnętrzną w instancji.

Projekt nie definiuje własnych zadań. Pojawienie się script: w jego pliku oznacza, że szablonowi brakuje punktu rozszerzenia. GitLab pozwala wprawdzie nadpisać w projekcie dowolny klucz zadania z szablonu, ale to początek kolejnej kopii. Sekcja variables: jest jawna dla każdego, kto czyta repozytorium, więc tokeny i hasła nie mają w niej miejsca: trafiają do zmiennych projektu lub grupy oznaczonych jako maskowane i chronione albo do zewnętrznego menedżera sekretów. Ten sam wzorzec można zbudować na komponentach CI/CD z parametrami spec: inputs, które walidują typy i dozwolone wartości (komponenty są dostępne ogólnie od GitLab 17.0). Wersję komponentu podaje się po znaku @ jako tag, SHA lub gałąź, a skrócone wersje, takie jak @1, działają tylko dla komponentów opublikowanych w katalogu CI/CD, więc częściowo zastępują ręczny wskaźnik wersji opisany niżej.

Etapy szablonu mają stałą kolejność: lint, testy, budowanie, publikacja, aktualizacja manifestów. Projekt może wyłączyć etap zmienną (np. SKIP_TESTS), ale nie zmienia jego treści. Dwie wymagane zmienne sprawdza osobne zadanie w etapie .pre, wykonywanym zawsze jako pierwszy, więc brak zmiennej kończy pipeline czytelnym komunikatem, a nie błędem pobierania obrazu. Budowanie odbywa się bez demona Dockera, w ukrytym zadaniu .kaniko-build dziedziczonym przez zadania build-*, więc runner nie potrzebuje trybu privileged. Strona dokumentacji GitLab o kaniko jest oznaczona jako usunięta, a kaniko nie jest już utrzymywanym projektem; alternatywami są Docker, Buildah i Podman. Publikacja używa tagu z wersją (opisanego w następnej sekcji), a ostatni etap zmienia tag w repozytorium manifestów, z którego wdraża kontroler GitOps. Punkty rozszerzenia opisuje dokumentacja szablonu: zmienna spoza niej nie jest częścią kontraktu i może zniknąć w następnej wersji.

stages: [lint, test, build, publish, deploy]

variables:
  APP_NAME: ""            # wymagana w projekcie
  APP_PATH: "."
  RUNTIME_IMAGE: ""       # wymagana w projekcie
  LINT_COMMAND: "make lint"
  TEST_COMMAND: "make test"
  SKIP_TESTS: "false"
  DOCKERFILE: Dockerfile

check-variables:
  stage: .pre
  image: busybox:1.36
  script:
    - test -n "$APP_NAME" || { echo "Brak zmiennej APP_NAME"; exit 1; }
    - test -n "$RUNTIME_IMAGE" || { echo "Brak zmiennej RUNTIME_IMAGE"; exit 1; }

# Budowanie obrazu bez demona Dockera: zadania build-* dziedziczą obraz i logowanie do rejestru
.kaniko-build:
  stage: build
  image:
    name: gcr.io/kaniko-project/executor:v1.23.2-debug
    entrypoint: [""]
  before_script:
    - mkdir -p /kaniko/.docker
    - printf '{"auths":{"%s":{"auth":"%s"}}}' "$CI_REGISTRY" "$(printf '%s:%s' "$CI_REGISTRY_USER" "$CI_REGISTRY_PASSWORD" | base64 | tr -d '\n')" > /kaniko/.docker/config.json

test:
  stage: test
  image: $RUNTIME_IMAGE
  script:
    - cd "$APP_PATH"
    - sh -c "$TEST_COMMAND"
  rules:
    - if: $SKIP_TESTS == "true"
      when: never
    - when: on_success

Wersjonowanie: tagi wydań i wskaźnik wersji głównej

Wydania szablonu to tagi vX.Y.Z, objęte ochroną (Settings › Repository › Protected tags), która ogranicza, kto może utworzyć lub usunąć tag wydania; jest dostępna w planach Free, Premium i Ultimate. Projekty nie odwołują się jednak do konkretnego tagu, tylko do wskaźnika wersji głównej: chronionej gałęzi v2, przesuwanej po każdym wydaniu zgodnym wstecz. Poprawka trafia wtedy do wszystkich projektów bez osobnych merge requestów, a zmiana niezgodna wstecz oznacza nową gałąź v3 i migrację w tempie projektów. Wskaźnik przesuwa się poleceniem git push origin 'v2.4.0^{commit}:refs/heads/v2' po wypchnięciu tagu v2.4.0; bez --force Git odrzuca każdą zmianę inną niż fast-forward, więc wskaźnik porusza się tylko do przodu.

Rys. 1. Projekty dołączają wersjonowany szablon i podają tylko zmienne; poprawka trafia do wszystkich po przesunięciu wskaźnika v2, a kontrola dryfu wyłapuje projekty na starych wersjach i z własną logiką.
ref w projekcieCo projekt dostajeZastosowanie
mainkażdą scaloną zmianę, także błędnątylko projekt referencyjny
v2 (gałąź-wskaźnik)kolejne wydania zgodne wsteczdomyślnie dla projektów
v2.4.0 (tag)dokładnie to wydanieprojekty wymagające pełnej powtarzalności
SHA commitadokładnie ten standiagnoza problemu

Proces zmiany szablonu i migracja projektów

Gałąź main repozytorium szablonów jest chroniona, a zmiany wchodzą do niej wyłącznie przez merge request zatwierdzany przez zespół odpowiedzialny za platformę. Wymuszenie zatwierdzeń przez wskazane osoby (reguły zatwierdzeń i plik CODEOWNERS) jest funkcją planów Premium i Ultimate; w planie Free zostaje ochrona gałęzi i umowa zespołu. Zmiana przechodzi cztery kroki:

  1. Zmiana w gałęzi szablonu i merge request z opisem: co się zmienia, dlaczego i czy jest zgodne wstecz.
  2. Sprawdzenie na projekcie pilotażowym: w jego gałęzi testowej ref wskazuje gałąź zmiany, a pipeline musi przejść w całości.
  3. Po scaleniu do main pipeline repozytorium szablonów uruchamia pipeline projektu referencyjnego, czyli minimalnej aplikacji istniejącej tylko po to, by przejść całą ścieżkę do wdrożenia na środowisko testowe. Służy do tego zadanie z kluczem trigger (project, branch: main) i strategy: mirror, które przejmuje status pipeline’u projektu referencyjnego, więc błąd w szablonie zatrzymuje pipeline szablonu, zanim ktokolwiek nada tag.
  4. Tag wydania, przesunięcie wskaźnika i wpis w dzienniku zmian.

Migracja istniejących projektów zaczyna się od pilotażowego: jego plik CI zastępują include i zmienne, a każda różnica względem szablonu to sygnał, że brakuje punktu rozszerzenia. Po dopisaniu go w wydaniu zgodnym wstecz migrują kolejne projekty, od najmniej odbiegających od wzorca. Jeden projekt to jeden merge request, a jego pipeline dowodzi, że etapy i schemat tagu obrazu są takie same jak przed zmianą. Projekty z logiką niewyrażalną zmiennymi dostają nowy punkt rozszerzenia w szablonie albo pozostają wyjątkiem z nazwanym właścicielem i terminem przeglądu.

Kontrola dryfu

Raport uruchamiany co tydzień jako zaplanowany pipeline (Build › Pipeline schedules) przegląda przez API projekty grupy i czyta ich .gitlab-ci.yml. Dla każdego projektu wypisuje wersję dołączonego szablonu i liczbę własnych sekcji script:.

#!/bin/sh
# Zmienne CI: GITLAB_API (https://gitlab.example.com/api/v4), GROUP_ID, REPORT_TOKEN (zakres read_api); lista obejmuje tylko pierwszą stronę, maks. 100 projektów
auth="PRIVATE-TOKEN: $REPORT_TOKEN"
curl -sf -H "$auth" "$GITLAB_API/groups/$GROUP_ID/projects?include_subgroups=true&simple=true&per_page=100" |
  jq -r '.[] | "\(.id) \(.path_with_namespace)"' |
  while read -r id path; do
    ci=$(curl -sf -H "$auth" "$GITLAB_API/projects/$id/repository/files/.gitlab-ci.yml/raw?ref=HEAD") ||
      { echo "$path: brak .gitlab-ci.yml"; continue; }
    ref=$(printf '%s\n' "$ci" | sed -n 's/^ *ref: *//p' | head -n 1)
    own=$(printf '%s\n' "$ci" | grep -c '^ *script:')
    echo "$path: szablon ${ref:-BRAK}, własnych sekcji script: $own"
  done

Wynik wymaga decyzji dla trzech grup. Projekt na poprzedniej wersji głównej potrzebuje terminu migracji. Projekt z własnymi sekcjami wymaga rozmowy z zespołem: szablon dostaje nowy punkt rozszerzenia albo nadpisanie znika. Projekt bez szablonu jest poza układem i trafia na listę do migracji. Lista jest krótka, jeśli reguły obowiązują od początku.

Tag obrazu jako wersja

latest nie znaczy „najnowsza stabilna wersja”. To zwykły tag nadawany domyślnie, gdy nie podano innego, który w każdej chwili można przestawić na dowolny obraz. Skutki są trzy. Ten sam manifest na dwóch węzłach może uruchomić dwa różne obrazy, zależnie od tego, kiedy który węzeł go pobrał. Nie ma zapisu, na jaki obraz wskazywał latest tydzień temu, więc nie ma do czego wrócić. Wreszcie Kubernetes przy latest ustawia domyślnie imagePullPolicy: Always, a runtime kontaktuje się wtedy z rejestrem przy każdym starcie kontenera, więc awaria rejestru albo wyczerpany limit zapytań może uniemożliwić restart poda, nawet jeśli obraz leży na węźle. Ustawienie IfNotPresent przy latest problemu nie rozwiązuje, tylko go ukrywa: każdy węzeł zostaje przy wersji pobranej jako pierwsza i różne węzły uruchamiają różny kod pod tą samą nazwą.

Odwołanie w manifeścieDomyślne imagePullPolicySkutek
app:latestAlwayskażdy start kontenera odpytuje rejestr; gdy rejestr nie odpowiada, pod nie wystartuje
app (bez tagu)Alwaysjak wyżej, bo brak tagu oznacza latest
app:1.4.2-3f9c2a1bIfNotPresentobraz z węzła, jeśli już tam jest
app@sha256:…IfNotPresentobraz identyfikowany treścią

Schemat tagów

Tag odpowiada na dwa pytania: która to wersja i z jakiego kodu powstała. Format 1.4.2-3f9c2a1b łączy wersję semantyczną (kolejność i zgodność czytelne dla ludzi) ze skrótem commita (jednoznaczne powiązanie z kodem). W GitLab CI wersja pochodzi z tagu Git v1.4.2, a skrót ze zmiennej CI_COMMIT_SHORT_SHA, która ma osiem znaków. Skrót zostaje w nazwie mimo tagu Git: tag Git można przestawić, a tag obrazu zapisuje, z którego kodu obraz faktycznie powstał, co widać w kubectl describe bez zaglądania do Git.

Zadanie build-release w szablonie uruchamia się dla tagów Git pasujących do ^v\d+\.\d+\.\d+$, wylicza VERSION="${CI_COMMIT_TAG#v}" i buduje obraz z dwoma celami: ${VERSION}-${CI_COMMIT_SHORT_SHA} oraz ${VERSION}. Opcja --digest-file zapisuje digest wypchniętego obrazu jako artefakt dla zadania zmieniającego manifest. Zadanie build-branch dla gałęzi roboczych innych niż domyślna publikuje wyłącznie tag sha-3f9c2a1b, więc po samym tagu widać, czy obraz jest wydaniem, a polityka sprzątania łatwo je rozróżnia.

Separatorem jest myślnik, bo semver zapisuje metadane builda po plusie (1.4.2+3f9c2a1b), a tag obrazu dopuszcza tylko litery, cyfry, podkreślenie, kropkę i myślnik, do 128 znaków. W semver część po myślniku oznacza wersję przedpremierową, więc jeśli narzędzie sortuje tagi według semver, wydania powinny mieć też czysty tag 1.4.2.

Niezmienność tagów w rejestrze

Schemat tagów nic nie daje, jeśli ktoś może wypchnąć inny obraz pod istniejący tag. Reguły ochrony tagów kontenerów w GitLabie ograniczają wypychanie i usuwanie tagów pasujących do wzorca do wybranych ról; są dostępne w planach Free, Premium i Ultimate, ogólnie od GitLab 17.11. Pełna niezmienność, niezależna od roli, jest funkcją planu Ultimate, ogólnie dostępną od GitLab 18.10. Harbor ma reguły niezmienności tagów w ustawieniach projektu, a Amazon ECR ustawienie repozytorium imageTagMutability na IMMUTABLE. Niezależnie od rejestru pipeline może sam odmówić nadpisania: zadanie uruchamiane przed budowaniem sprawdza, czy tag już istnieje, i przerywa build.

Przypinanie po digest

Digest (sha256:…) to skrót treści manifestu obrazu. Tag można przestawić, digestu nie, bo inny obraz ma inny digest. Kubernetes akceptuje zapis z tagiem i digestem jednocześnie, na przykład registry.example.com/shop/app:1.4.2-3f9c2a1b@sha256:6f1c9e…: obraz jest wtedy identyfikowany po digeście, a tag zostaje czytelną informacją dla ludzi. Przypinanie jest obowiązkowe tam, gdzie nie ma kontroli nad niezmiennością tagów: dla obrazów bazowych, obrazów narzędzi w CI i obrazów z publicznych chartów Helm. Dla własnych obrazów w rejestrze z ochroną tagów wystarcza tag z wersją i commitem; digest dodaje się dla usług najważniejszych.

Polityka sprzątania rejestru

Niezmienne tagi powodują, że rejestr rośnie, a sprzątanie musi odróżniać wydania od obrazów z gałęzi roboczych. W GitLabie służy do tego polityka czyszczenia tagów w ustawieniach rejestru kontenerów projektu (Settings › Packages and registries).

Grupa tagówWzorzecZasada
Wydania\d+\.\d+\.\d+(-[0-9a-f]{8})?zachowywane zawsze
Obrazy roboczesha-[0-9a-f]{8}usuwane po 14 dniach, 10 ostatnich zostaje
Pamięć podręczna warstwosobne repozytorium cacheodtwarzalna, czas życia jak w narzędziu budującym

GitLab sam otacza wzorce kotwicami początku i końca, więc w polu nie wpisuje się ^ ani $. Polityka nie usuwa tagów objętych regułą ochrony ani regułą niezmienności. Usunięcie tagów nie zwalnia od razu miejsca na dysku, bo warstwy zwalnia dopiero odśmiecanie rejestru. W instancji utrzymywanej samodzielnie, bez bazy metadanych rejestru, uruchamia się je ręcznie w oknie serwisowym; rejestr z bazą metadanych usuwa warstwy bez tagów automatycznie po 24 godzinach.

GitOps a skrypt wdrożeniowy

Skrypt wdrożeniowy, niezależnie od tego, czy jest to Bash, zadanie w pipeline czy playbook Ansible, wykonuje kroki i kończy pracę, a wie tylko to, co zrobił w chwili uruchomienia. Typowy przykład to zadanie deploy w pipeline z poleceniami kubectl apply -f k8s/ i kubectl rollout status. Ręczna zmiana na klastrze zostaje do następnego pipeline’u, czyli często do następnej zmiany w kodzie. Zasób usunięty z repozytorium zostaje na klastrze, bo kubectl apply domyślnie niczego nie usuwa (usuwanie wymaga --prune). Pipeline potrzebuje kubeconfigu z prawem zapisu do klastra w zmiennych CI, a wycofanie wymaga ponownego uruchomienia starego pipeline’u, co nie zawsze odtwarza poprzedni stan.

W GitOps repozytorium jest jedynym źródłem prawdy o pożądanym stanie, a w klastrze działa kontroler, który w pętli porównuje ten stan z rzeczywistością i usuwa różnice. W Argo CD jednostką jest Application.

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: orders
  namespace: argocd
  finalizers:
    - resources-finalizer.argocd.argoproj.io
spec:
  project: orders
  source:
    repoURL: https://git.example.com/platform/deploy.git
    targetRevision: main
    path: apps/orders/overlays/prod
  destination:
    server: https://kubernetes.default.svc
    namespace: orders
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
      - CreateNamespace=true
      - PruneLast=true
UstawienieCo robiDomyślnie
automatedsynchronizuje po wykryciu zmiany w repozytoriumwyłączone: Argo CD tylko pokazuje OutOfSync
prune: trueusuwa z klastra zasoby usunięte z repozytoriumwyłączone
selfHeal: truecofa ręczne zmiany wprowadzone na klastrzewyłączone
CreateNamespace=truetworzy docelową przestrzeń nazwwyłączone
PruneLast=trueusuwa zbędne zasoby na końcu synchronizacjiwyłączone
finalizer resources-finalizerprzy usunięciu Application usuwa też jej zasobybrak

Bez prune i selfHeal synchronizacja automatyczna dodaje i zmienia zasoby, ale nie usuwa osieroconych i nie cofa ręcznych zmian. Z obiema opcjami klaster stale odpowiada repozytorium.

AspektSkrypt w pipelineGitOps (Argo CD)
Kiedy zmiana trafia na klasterprzy uruchomieniu pipeline’upo zmianie w repozytorium, w ciągu minut
Ręczna zmiana na klastrzezostaje do następnego wdrożeniawidoczna jako OutOfSync, cofana przy selfHeal
Zasób usunięty z repozytoriumzostaje na klastrzeusuwany przy prune
Wycofanieponowne uruchomienie starego pipeline’ugit revert (bez cofnięcia migracji bazy)
Uprawnienia pipeline’uzapis do API klastrazapis do repozytorium manifestów
Odtworzenie klastra od zerauruchomienie wszystkich pipeline’ów po koleipo bootstrapie: wskazanie repozytorium aplikacji nadrzędnej

Bootstrap to instalacja Argo CD i ręczne utworzenie aplikacji nadrzędnej (wzorzec app of apps), która wskazuje na pozostałe. Poza Git zostają sekrety, których nie wolno tam zapisywać.

Kolejność: fale synchronizacji i hooki

Argo CD stosuje zasoby w falach, od najniższego numeru, i przechodzi do następnej dopiero wtedy, gdy poprzednia jest zdrowa. Numer fali to adnotacja argocd.argoproj.io/sync-wave na zasobie, na przykład "-1" dla ConfigMapa, który musi powstać przed Deploymentem. Migracja bazy przed nową wersją to hook PreSync: Job z adnotacjami argocd.argoproj.io/hook: PreSync i argocd.argoproj.io/hook-delete-policy: BeforeHookCreation, uruchamiany przed synchronizacją pozostałych zasobów. Jego niepowodzenie blokuje wdrożenie.

Dryf i poprawki awaryjne

Argo CD domyślnie sprawdza repozytorium co 120 sekund (timeout.reconciliation) plus losowe opóźnienie do 60 sekund (timeout.reconciliation.jitter), czyli do około trzech minut; webhook z serwera Git skraca to do sekund. Każda różnica między repozytorium a klastrem to stan OutOfSync, a przy selfHeal zmiana jest cofana automatycznie. Pola, które z założenia zmienia ktoś inny, na przykład liczbę replik przy HorizontalPodAutoscalerze, wyłącza się z porównania przez ignoreDifferences (wskaźnik /spec/replicas dla Deploymentu) razem z opcją RespectIgnoreDifferences=true.

Ta sama pętla działa przeciwko ręcznej poprawce awaryjnej. Gdy w czasie awarii ktoś ręcznie zwiększy limit pamięci w Deploymencie, przy selfHeal kontroler cofa zmianę niemal od razu (domyślny odstęp ponowienia samonaprawy to 5 sekund, --self-heal-timeout-seconds), zanim ta zdąży pomóc. Bez samonaprawy zmiana żyje do następnego wdrożenia, które po trzech tygodniach przywraca awarię bez oczywistej przyczyny. Procedura incydentu uwzględnia to dwiema ścieżkami: szybki commit do repozytorium wdrożeń, który zostawia ślad, albo świadome wstrzymanie automatycznej synchronizacji aplikacji (pole automated, np. enabled: false) z właścicielem i terminem. Po incydencie zmiana trafia do repozytorium, a synchronizacja wraca.

Wycofanie

Gdy wdrożenie odbywa się przez GitOps, każda zmiana wersji jest commitem w repozytorium manifestów, więc wycofanie to git revert commita, który zmienił wersję, na przykład z 1.4.2-3f9c2a1b na 1.4.3-7d2e91f0, i wypchnięcie go do gałęzi głównej. Kontroler przywraca poprzedni obraz, a ponieważ tag 1.4.2-3f9c2a1b nadal wskazuje ten sam obraz, wracają dokładnie te same bity, które działały wcześniej. Historia w Git jest kompletna, bo nic nie działo się poza Gitem. Wersji nie wycofuje się przez kubectl rollout undo ani kubectl set image: kontroler z samonaprawą przywróci stan z repozytorium, a historia nie zachowa śladu wycofania. argocd app rollback nie działa dla aplikacji z włączoną automatyczną synchronizacją.

Struktura repozytorium i promocja między środowiskami

Repozytorium manifestów ma układ base i overlays: apps/orders/base zawiera manifesty wspólne, a overlays/test i overlays/prod tylko różnice (tag obrazu, liczbę replik, adresy). Każde środowisko ma własną Application wskazującą swój overlay. Promocja z testu na produkcję to commit, który w overlayu produkcyjnym ustawia ten sam tag obrazu co w testowym: obraz nie jest budowany drugi raz, a wydanie ma jeden ślad w Git (kto, kiedy i w którym merge requeście).

Granica roli pipeline’u

GitOps nie eliminuje CI. Pipeline nadal buduje obraz, uruchamia testy i publikuje go z tagiem zawierającym wersję, ale nie dotyka klastra: modyfikuje manifest w repozytorium wdrożeń, na przykład poleceniem kustomize edit set image registry.example.com/shop/orders:1.4.2-3f9c2a1b, wypycha commit i kończy pracę. Wymaga więc tylko prawa zapisu do repozytorium manifestów, a nie kubeconfigu klastra. Kompromitacja pipeline’u nadal jest groźna, bo kto zapisuje do repozytorium manifestów, w praktyce decyduje o tym, co zostanie wdrożone.

Zasięg tego wpływu zawężają dwa mechanizmy. Pierwszy to ochrona gałęzi repozytorium wdrożeń: zmiany produkcji przechodzą przez merge request z przeglądem człowieka. Drugi to dedykowany projekt Argo CD (AppProject). Projekt default dopuszcza dowolne repozytoria, klastry i rodzaje zasobów, także klastrowe, a projekt orders je ogranicza: sourceRepos zawęża źródło do jednego repozytorium wdrożeń, destinations do przestrzeni nazw orders na lokalnym klastrze, a namespaceResourceBlacklist wyklucza ResourceQuota, LimitRange i NetworkPolicy. Aplikacja z takiego projektu wdroży manifesty tylko z jednego repozytorium i tylko do jednej przestrzeni nazw, a limity zasobów i polityki sieciowe pozostają pod kontrolą zespołu platformy. Zasoby klastrowe dopuszcza lista clusterResourceWhitelist, utrzymywana jak najkrócej.

Decyzje i alternatywy

PodejścieKiedy ma sensOgraniczenie
Wspólny szablon przez include z gałęzią-wskaźnikiem wersji głównejwiele projektów o tym samym schemacie dostarczaniazmiana w szablonie dociera do wszystkich projektów; wymaga projektu referencyjnego i kontroli dryfu
include z tagiem lub SHAprojekty wymagające pełnej powtarzalności, diagnozapoprawki nie docierają bez zmiany pliku projektu
Komponenty CI/CD z spec: inputswalidacja typów i dozwolonych wartości parametrówskrócone wersje (@1) tylko dla komponentów z katalogu CI/CD
Kopia pliku CI w każdym projekciepojedynczy projektrozchodzenie się kopii, każda zmiana to osobny merge request
Tag wersja-skrótwłasne obrazy w rejestrze z ochroną tagówbez ochrony tagów nadal możliwe nadpisanie
Przypięcie po digestobrazy bazowe, narzędzia CI, obrazy z publicznych chartów, usługi najważniejszenieczytelne dla ludzi bez tagu obok
Tag latestbrak uzasadnionych zastosowań we wdrożeniachbrak powtarzalności i wycofania, zależność od rejestru przy każdym starcie poda
Skrypt wdrożeniowypojedynczy serwer, kilka wdrożeń rocznie, dostęp tylko dla pipeline’unie wykrywa dryfu i nie usuwa osieroconych zasobów; pipeline z zapisem do API klastra
GitOps (Argo CD)więcej niż jedna osoba zmienia środowisko, częste lub wieloskładnikowe wdrożenia, audyt zmian, odtwarzalnośćutrzymanie kontrolera; sekrety poza Git; samonaprawa cofa ręczne poprawki

GitOps opłaca się, gdy spełniony jest co najmniej jeden z warunków z wiersza tabeli; w pozostałych przypadkach skrypt jest prostszy i wystarczający.

Wdrożenie

  1. Repozytorium szablonów: chroniona gałąź main, chronione tagi wydań, szablon z etapami i punktami rozszerzeń oraz projekt referencyjny uruchamiany zadaniem trigger ze strategy: mirror. Kontrola: błąd wprowadzony celowo do szablonu zatrzymuje jego pipeline przed nadaniem tagu.
  2. Migracja projektów od pilotażowego do najmniej odbiegających od wzorca, po jednym merge requeście na projekt. Kontrola: pipeline zmigrowanego projektu ma te same etapy i ten sam schemat tagu obrazu co przed zmianą. Wyjątki mają właściciela i termin przeglądu.
  3. Schemat tagów w szablonie (build-release, build-branch), reguły ochrony lub niezmienności tagów w rejestrze oraz zadanie odrzucające nadpisanie istniejącego tagu. Kontrola: próba wypchnięcia obrazu pod istniejący tag kończy się odmową.
  4. Inwentaryzacja obrazów bez tagu i z tagiem latest: lista obrazów z kontenerów i initContainers wszystkich podów (kubectl get pods -A z -o jsonpath), przefiltrowana pod kątem braku tagu lub :latest. Oczekiwany wynik jest pusty, a każda linia to przestrzeń nazw i obraz do poprawy.
  5. Polityka sprzątania rejestru z wzorcami wydań i obrazów roboczych, włączana po porównaniu z listą obrazów działających w klastrach.
  6. Wdrażanie przez Argo CD: osobny AppProject i Application dla każdego środowiska (prune, selfHeal), bootstrap aplikacji nadrzędnej, ochrona gałęzi repozytorium manifestów, a w pipeline zamiast kubectl apply zmiana tagu w manifeście. Kontrola: ręczna zmiana na klastrze widoczna jako OutOfSync i cofnięta, a git revert przywraca poprzednią wersję.
  7. Cotygodniowy raport dryfu szablonu z decyzją dla każdej z trzech grup projektów.

Ograniczenia i pułapki

  • Tag o nazwie gałęzi-wskaźnika. Przy dwóch referencjach v2 GitLab pobiera plik z tagu, a z pliku projektu nie widać, którą z nich miał na myśli autor. Nie tworzy się tagu o tej samej nazwie co gałąź-wskaźnik; jednoznaczny zapis to pełna nazwa, refs/heads/v2 albo refs/tags/v2.
  • Revert nie cofa migracji bazy. Cofnięcie manifestu przywraca obraz, ale nie zmiany wykonane przez nową wersję ani hook PreSync, więc poprzednia wersja musi działać na schemacie po migracji. Migracje projektuje się zgodnie wstecz: kolumnę najpierw się dodaje, a usuwa dopiero w kolejnym wydaniu.
  • HPA i replicas w manifeście. Pole replicas w Deploymencie i HPA na tym samym Deploymencie to dwa kontrolery walczące o jedną wartość: HPA skaluje, Argo CD przywraca. Najprościej usunąć replicas z manifestu; ignoreDifferences jest dla przypadków, w których tego zrobić nie można.
  • Sprzątanie usuwa działający obraz. Reguła czyszczenia, która usunie tag obrazu uruchomionego w klastrze, powoduje błąd pobierania przy następnym restarcie poda na innym węźle. Wzorce reguły porównuje się z obrazami działającymi, a wydania pozostają poza zakresem usuwania.

Źródła