Przejdź do treści głównej

Opublikowano

CI/CD w małej firmie: co to jest i jak zacząć

CI/CD to automat, który po zmianie w kodzie uruchamia testy, buduje aplikację i wdraża ją na serwer według kroków zapisanych w repozytorium. Przy 1–5 osobach zwykle opłaca się już wtedy, gdy aplikacja ma użytkowników, a wdrożenie jest ręczne i powtarzalne. Poniżej opisuję, kiedy warto to zrobić, i pokazuję minimalny pipeline w GitHub Actions i Dockerze razem z powrotem do poprzedniej wersji.

  • CI/CD
  • GitHub Actions
  • Docker
  • Docker Compose
  • deployment
  • rollback

Co to jest CI/CD

Skrót łączy dwie praktyki. CI, czyli continuous integration, pilnuje, żeby każda zmiana trafiająca do wspólnego kodu przeszła automatyczne sprawdzenia. CD oznacza continuous delivery albo continuous deployment, a różnica między nimi sprowadza się do tego, czy wdrożenie na produkcję wymaga czyjejś decyzji.

Zestaw tych kroków nazywa się pipeline’em. Dla małej firmy najważniejsze jest to, że pipeline jest plikiem w repozytorium, więc każdy widzi, co się wykona, a log pokazuje, na którym kroku wdrożenie się zatrzymało.

  • Continuous integration: testy uruchamiają się przy każdej zmianie, a nie wtedy, gdy ktoś o nich pamięta.
  • Continuous delivery: każda zmiana po testach jest gotowa do wydania, ale wdrożenie uruchamia człowiek.
  • Continuous deployment: zmiana po testach sama trafia na produkcję. Tak działa przykład poniżej, a jeśli wolisz decydować ręcznie, zamień w nim wyzwalacz push na workflow_dispatch.

Kiedy CI/CD opłaca się przy 1–5 osobach

Mały zespół rzadko ma problem ze skalą. Ma za to jedną osobę, która wie, jak wdrożyć aplikację, i tej osoby czasem nie ma. Sam zaczynałem w zespole trzech programistów, gdzie wdrożenie oznaczało git pull na serwerze produkcyjnym, a konflikty merge zdarzało się rozwiązywać właśnie tam. Opisałem to w notatce o nudnym deploymencie.

Brak testów nie jest powodem do czekania. Pierwszy pipeline może tylko budować obraz i go wdrażać, a testy dojdą później. Już to zapisuje kroki wdrożenia i daje wersje, do których można wrócić.

Koszt to głównie jednorazowa konfiguracja. Według cennika GitHub Actions plan Free dla prywatnych repozytoriów zawiera 12 USD zużycia miesięcznie, a standardowe runnery w repozytoriach publicznych są bezpłatne. Dokumentacja GitHuba podaje też, że przechowywanie obrazów w GitHub Container Registry jest obecnie bezpłatne. To stan z listopada 2026, więc przed decyzją sprawdź aktualne warunki.

  • Warto, gdy aplikacja ma użytkowników, a wdrażasz ją przynajmniej kilka razy w miesiącu.
  • Warto, gdy wdrożyć potrafi tylko jedna osoba albo kolejność komend siedzi w czyjejś głowie.
  • Warto, gdy ktoś poprawia kod bezpośrednio na serwerze lub robi tam git pull.
  • Warto, gdy po wdrożeniach wracają te same błędy z pominiętego kroku, np. migracji albo czyszczenia cache.
  • Można poczekać, gdy to prototyp bez użytkowników albo strona zmieniana dwa razy w roku.

Minimalny zestaw

Przy jednej aplikacji na jednym serwerze wystarczy repozytorium na GitHubie, Dockerfile, rejestr obrazów i serwer Linux z Docker Compose. Kubernetes nie jest tu potrzebny. Przebieg jest prosty: push do main, testy, build obrazu oznaczonego SHA commita, wypchnięcie do rejestru i wdrożenie przez SSH.

Tag z SHA zamiast latest sprawia, że każde wydanie ma własną, niezmienną nazwę i wiadomo, z którego commita pochodzi. Na tym opiera się powrót do poprzedniej wersji.

  • Dockerfile ma dwa etapy: test, który uruchamia testy w instrukcji RUN, i production, który zawiera tylko to, co ma działać na serwerze.
  • Nieudany RUN przerywa docker build, więc pipeline zatrzymuje się przed wypchnięciem obrazu.
  • Pliki compose.yaml, app.env i deploy.sh leżą na serwerze w /opt/app. Do działania aplikacji serwer nie potrzebuje kopii repozytorium.

Pipeline w GitHub Actions

Zapisz ten plik jako .github/workflows/deploy.yml i zamień ghcr.io/firma/aplikacja na nazwę swojego obrazu. W GitHub Container Registry nazwa musi być zapisana małymi literami.

name: deploy

on:
  push:
    branches: [main]

# Dwa wdrożenia naraz nadpisałyby sobie stan na serwerze.
concurrency:
  group: production

env:
  IMAGE: ghcr.io/firma/aplikacja

jobs:
  build:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write
    steps:
      - uses: actions/checkout@v7
      - name: Testy
        run: docker build --target test .
      - name: Build obrazu
        run: docker build --target production -t "$IMAGE:$GITHUB_SHA" .
      - name: Push do rejestru
        env:
          TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          echo "$TOKEN" | docker login ghcr.io -u "$GITHUB_ACTOR" --password-stdin
          docker push "$IMAGE:$GITHUB_SHA"

  deploy:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Wdrożenie przez SSH
        env:
          SSH_KEY: ${{ secrets.DEPLOY_SSH_KEY }}
          KNOWN_HOSTS: ${{ secrets.DEPLOY_KNOWN_HOSTS }}
          TARGET: ${{ secrets.DEPLOY_TARGET }}
        run: |
          mkdir -p ~/.ssh
          printf '%s\n' "$SSH_KEY" > ~/.ssh/id_ed25519
          chmod 600 ~/.ssh/id_ed25519
          printf '%s\n' "$KNOWN_HOSTS" > ~/.ssh/known_hosts
          ssh "$TARGET" /opt/app/deploy.sh "$GITHUB_SHA"
  • DEPLOY_SSH_KEY to osobny klucz prywatny tylko do wdrożeń, bez hasła, którego publiczna część jest na serwerze.
  • DEPLOY_KNOWN_HOSTS to wynik ssh-keyscan dla serwera. Sprawdź odcisk klucza, zanim go zapiszesz, bo ten sekret chroni przed połączeniem z cudzym hostem.
  • DEPLOY_TARGET to adres w postaci deploy@adres-serwera.
  • GITHUB_TOKEN tworzy się sam przy każdym uruchomieniu i nie trzeba go nigdzie wpisywać.

Serwer: compose.yaml

Tag obrazu jest tu zmienną. Compose czyta ją z pliku .env, który zapisuje skrypt wdrożenia, więc restart serwera podnosi ostatnie udane wydanie.

services:
  app:
    image: ghcr.io/firma/aplikacja:${APP_TAG:?}
    restart: unless-stopped
    env_file: app.env
    ports:
      - '127.0.0.1:8080:8080'
    healthcheck:
      test: ['CMD', 'wget', '-q', '--spider', 'http://localhost:8080/health']
      interval: 5s
      timeout: 3s
      retries: 12
  • Port jest przypięty do 127.0.0.1, a ruch z internetu odbiera reverse proxy z TLS. Bez tego port opublikowany przez Dockera ominie UFW.
  • Sekrety aplikacji leżą w app.env na serwerze, poza obrazem i poza repozytorium.
  • Healthcheck wymaga wget w obrazie i adresu /health w aplikacji. W obrazach bez wget użyj curl albo komendy samej aplikacji.
  • Przy prywatnym obrazie zaloguj serwer do ghcr.io tokenem z uprawnieniem read:packages.
  • Użytkownik deploy z grupy docker ma na hoście w praktyce uprawnienia roota, więc jego klucz traktuj jak klucz administratora.

Serwer: deploy.sh

Ten sam skrypt obsługuje wdrożenie i powrót do poprzedniej wersji. Zapisz go jako /opt/app/deploy.sh i nadaj mu prawo wykonywania przez chmod +x.

#!/usr/bin/env bash
set -euo pipefail

tag="${1:?Podaj pełny SHA commita}"
[[ "$tag" =~ ^[0-9a-f]{40}$ ]] || { echo "Niepoprawny tag: $tag" >&2; exit 1; }

cd /opt/app
export APP_TAG="$tag"

docker compose pull app
docker compose up -d --wait app

# Zapisz tag dopiero po udanym starcie, żeby .env wskazywał działające wydanie.
echo "APP_TAG=$tag" > .env
echo "$(date -Is) $tag" >> deploys.log
  • --wait czeka na healthcheck i kończy się błędem, gdy kontener jest niezdrowy, więc pipeline robi się czerwony.
  • Sprawdzenie formatu odrzuca wszystko poza pełnym SHA, także latest.
  • up -d zastępuje kontener nowym, więc aplikacja ma krótką przerwę. Przy wdrożeniach poza godzinami szczytu zwykle to wystarcza.
  • Migracje uruchom między pull a up, w Laravelu np. docker compose run --rm app php artisan migrate --force. Stara wersja działa wtedy jeszcze przez chwilę na nowym schemacie, więc migracja musi być z nią zgodna.

Jak wrócić do poprzedniej wersji

Każde wydanie to osobny obraz w rejestrze, więc powrót oznacza wdrożenie poprzedniego tagu. Nie trzeba niczego budować ani odtwarzać stanu serwera. Listę ostatnich wydań masz w deploys.log, a pierwsza kolumna mówi, kiedy dane wydanie weszło.

ssh deploy@adres-serwera tail -n 5 /opt/app/deploys.log
ssh deploy@adres-serwera /opt/app/deploy.sh <pełny SHA poprzedniego wydania>
  • Wydanie, które nie przeszło healthchecku, zostaje uruchomione do czasu tej komendy. Skrypt celowo nie cofa się sam, żeby pozostał krótki, więc czerwony pipeline wymaga reakcji człowieka.
  • Po powrocie zrób git revert błędnego commita. Inaczej następny push do main zbuduje nową wersję razem z tym samym błędem.
  • Powrót obrazu nie cofa bazy danych. Dlatego migracje najlepiej robić dodające, a usunięcie kolumny zostawić na osobne, późniejsze wydanie. Przy większej zmianie danych miej też kopię zapasową z przećwiczonym odtworzeniem.
  • Rollback działa tylko wtedy, gdy stary obraz nadal jest w rejestrze, więc reguły czyszczenia rejestru muszą zostawiać kilka ostatnich wydań.
  • Nie uruchamiaj rollbacku w trakcie działającego pipeline’u, bo ręczna komenda omija blokadę concurrency.

Co sprawdziłem, a czego nie

Skrypt deploy.sh i compose.yaml sprawdziłem lokalnie na Dockerze 29.6 i Compose 5.3, z lokalnym rejestrem zamiast ghcr.io i z trzema wydaniami testowymi. Dwa wdrożenia przeszły, tag latest został odrzucony, a wydanie z zepsutym healthcheckiem zakończyło skrypt błędem i nie zmieniło .env. Potem powrót do obu wcześniejszych tagów zadziałał, a po zatrzymaniu i ponownym starcie Compose podniósł ostatnie udane wydanie. Nieudany etap test przerywa też docker build.

Plik workflow przeszedł actionlint, ale nie uruchamiałem go w prawdziwym repozytorium ani nie sprawdzałem połączenia SSH i logowania do ghcr.io. Przy pierwszym uruchomieniu patrz więc na log kroku wdrożenia i od razu przećwicz powrót do poprzedniej wersji, zanim będzie potrzebny.

Co dodać później

Ten zestaw celowo nie ma kilku rzeczy, które często pojawiają się w większych konfiguracjach. Dodawaj je wtedy, gdy pojawi się konkretny problem.

  • Cache warstw Dockera, gdy build zaczyna trwać zbyt długo, bo runner za każdym razem startuje od zera.
  • Środowisko testowe, gdy zmiany trzeba komuś pokazać przed wydaniem.
  • Wdrożenia bez przerwy, gdy nawet krótka niedostępność jest problemem.
  • Automatyczny powrót po nieudanym healthchecku, gdy nikt nie może szybko zareagować na czerwony pipeline.

Zobacz też: CI/CD i wdrożenia na Dockerze, Deployment powinien być nudny, Opublikowane porty Dockera omijają UFW.

Jeśli chcesz porozmawiać o podobnej konfiguracji albo problemie, napisz przez stronę kontaktową.