8

Rozdział 8 z 11

Workflow Deploy, sekrety i zmienne środowiskowe

Opublikowany

Tworzymy deploy.yml (SSH → git pull → build → migracje → cache), dodajemy 3 sekrety, omawiamy .env.local + --env-file oraz budowanie frontu (Vite).

Czego się nauczysz

  • Workflow Deploy przez SSH
  • GitHub Secrets (który klucz)
  • Zmienne środowiskowe i --env-file
  • Build frontu w produkcji

Rozdział 8: Workflow Deploy, sekrety i zmienne środowiskowe

Mamy infrastrukturę. Teraz napiszemy drugi automat — Deploy — który po git push na main loguje się na serwer i wdraża aplikację. Po drodze ustawimy sekrety (jak GitHub loguje się na serwer), zmienne środowiskowe produkcji oraz build frontu. Czynności 🔁 jednorazowe, 🐙 w repo i w ustawieniach GitHuba.

Po tym rozdziale wszystko jest gotowe do pierwszego wdrożenia (Rozdział 9).


Plik deploy.yml — w całości

Utwórz .github/workflows/deploy.yml:

name: Deploy to Production

on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Deploy via SSH
        uses: appleboy/ssh-action@v1.0.3
        with:
          host: ${{ secrets.VPS_HOST }}
          username: ${{ secrets.VPS_USER }}
          key: ${{ secrets.VPS_SSH_KEY }}
          script: |
            set -e
            cd /var/www/factorycode

            echo "Pulling latest code..."
            git pull origin main

            echo "Building images (with latest base images for security patches)..."
            docker compose --env-file .env.local -f compose.yaml -f compose.prod.yaml build --pull

            echo "Starting containers..."
            docker compose --env-file .env.local -f compose.yaml -f compose.prod.yaml up -d --remove-orphans

            echo "Syncing built frontend assets to host public (served by nginx)..."
            rm -rf public/build
            docker compose --env-file .env.local -f compose.yaml -f compose.prod.yaml cp app:/var/www/html/public/build ./public/build

            echo "Running migrations..."
            docker compose --env-file .env.local -f compose.yaml -f compose.prod.yaml exec -T app php bin/console doctrine:migrations:migrate --no-interaction --allow-no-migration

            echo "Clearing cache..."
            docker compose --env-file .env.local -f compose.yaml -f compose.prod.yaml exec -T app php bin/console cache:clear --env=prod

            echo "Removing old images..."
            docker image prune -f

            echo "Deploy complete!"

Co robi ten workflow (krok po kroku)

Krok Co robi
on: push: branches: [main] uruchamia się po każdym push na main
appleboy/ssh-action gotowy „klocek": loguje się przez SSH na serwer
host/username/key dane logowania z sekretów (nie w kodzie!)
git pull origin main serwer pobiera nowy kod (przez Deploy Key z Rozdz. 7)
docker compose build --pull buduje obrazy aplikacji, najpierw pobierając aktualny obraz bazowy
docker compose up -d --remove-orphans startuje kontenery z nowych obrazów i usuwa osierocone
sync public/build kopiuje zbudowany front z kontenera na hosta (dla Nginx) — patrz niżej
migrations:migrate aktualizuje schemat bazy
cache:clear --env=prod odświeża cache produkcyjny
docker image prune -f kasuje stare, nieużywane obrazy (zwalnia miejsce)

Dlaczego build i start to dwa osobne kroki

  • --pull przy każdym deployu pobiera najnowszą wersję obrazu bazowego (u nas php:8.4-fpm-alpine dla app i worker). Dzięki temu poprawki bezpieczeństwa PHP, Alpine czy OpenSSL trafiają na produkcję same, bez Twojej pracy.
  • Build przed startem: jeśli budowanie się nie uda, set -e przerywa skrypt, zanim cokolwiek zostanie zatrzymane. Stare kontenery działają dalej, a strona nie znika.

⚠️ Gotowe obrazy, których nie budujemy (nginx:alpine, postgres:16-alpine), nie odświeżają się przez build --pull. Bazę danych świadomie aktualizujemy ręcznie, po świeżym backupie (Rozdział 10).

🎯 Ścieżka cd /var/www/factorycode i nazwa kontenera app są specyficzne dla FactoryCode. 🧩 Mechanizm (SSH + sekrety + git pull + restart) jest uniwersalny.


Sekrety: jak GitHub loguje się na serwer 🐙🔁

Co to sekret: poufna wartość przechowywana w GitHubie poza kodem. W workflow odwołujesz się do niej przez ${{ secrets.NAZWA }}. Nikt (nawet Ty) nie odczyta jej później w panelu — można ją tylko nadpisać.

Potrzebujemy trzech sekretów:

Sekret Wartość Co to
VPS_HOST <VPS_IP> adres serwera
VPS_USER root użytkownik SSH
VPS_SSH_KEY prywatny <KLUCZ_LOKALNY> klucz, którym automat loguje się na serwer

⚠️ Który klucz do VPS_SSH_KEY? To prywatny klucz z Rozdziału 2 (~/.ssh/factorycode_deploy), bo to jego publiczną część autoryzowaliśmy dla roota na serwerze (Rozdział 4). To NIE jest github_deploy z serwera (tamten służy do: serwer → GitHub).

Jak dodać sekrety

  1. Skopiuj prywatny klucz do schowka:
    # 💻 lokalnie
    pbcopy < ~/.ssh/<KLUCZ_LOKALNY>      # macOS (Linux: xclip -sel clip < ...)
    
  2. Wejdź: https://github.com/<REPO>/settings/secrets/actions
  3. Kliknij „New repository secret" i dodaj po kolei trzy sekrety z tabeli powyżej.
    • przy VPS_SSH_KEY wklej cały klucz (z liniami -----BEGIN...----- i -----END...-----).

Oczekiwany rezultat: na liście „Actions secrets" widnieją VPS_HOST, VPS_USER, VPS_SSH_KEY (wartości ukryte).

🎯 Dla FactoryCode: VPS_HOST=203.0.113.10, VPS_USER=root, VPS_SSH_KEY = treść ~/.ssh/factorycode_deploy.


⚠️ Zmienne środowiskowe i sekrety produkcyjne

Zmienna środowiskowa to ustawienie przekazywane aplikacji z zewnątrz (np. adres bazy, tryb prod, hasło do bazy). W produkcji nie trzymamy ich w kodzie — żyją w pliku .env.local na serwerze (wygenerowanym przez setup-vps.sh, poza repo).

Kluczowy, nieoczywisty szczegół:

Docker Compose domyślnie czyta zmienne tylko z pliku .env, a nasze sekrety są w .env.local. Dlatego każda komenda compose w deployu (i w backupie) używa --env-file .env.local. Bez tego POSTGRES_PASSWORD i APP_SECRET byłyby puste → baza wstaje z pustym hasłem i kontener pada.

Co zawiera .env.local na serwerze (szablon to .env.prod.example w repo):

APP_ENV=prod
APP_SECRET=<losowy_32_znaki>        # generuje setup-vps.sh
POSTGRES_PASSWORD=<losowe_haslo>    # generuje setup-vps.sh
MAILER_DSN=null://null              # poczta: na razie wyłączona

🎯 Poczta @<DOMENA> nie jest jeszcze skonfigurowana — MAILER_DSN=null://null oznacza „nie wysyłaj maili". Prawdziwy MAILER_DSN (+ rekordy SPF/DKIM w DNS) dodasz, gdy założysz skrzynkę. To nie blokuje wdrożenia.

🧩 Uniwersalnie: sekrety produkcyjne trzymaj w pliku poza repo i przekazuj je Compose przez --env-file. Nigdy nie commituj prawdziwych haseł.


⚠️ Build frontu w produkcji (jeśli projekt ma assety)

To częsta pułapka: po wdrożeniu strona działa, ale nie ma stylów (goły HTML). Powód: nikt nie zbudował CSS/JS (Vite), więc aplikacja nie ma z czego wygenerować linków do stylów.

Rozwiązanie w FactoryCode — dwa elementy:

  1. Obraz produkcyjny buduje front. W Dockerfile (etap prod), po skopiowaniu kodu:

    RUN npm install -g puppeteer@latest --unsafe-perm \
        && npm install \
        && npm run build \
        && composer dump-autoload --optimize \
        && composer run-script post-install-cmd --no-interaction \
        && php bin/console cache:warmup
    

    npm run build tworzy katalog public/build/ (zbudowane assety + manifest) w obrazie — dzięki temu app (PHP) wie, jakie pliki podlinkować.

  2. Deploy kopiuje public/build z kontenera na hosta (ten krok widziałeś w deploy.yml):

    rm -rf public/build
    docker compose ... cp app:/var/www/html/public/build ./public/build
    

    Dzięki temu host-owy katalog public/ (serwowany przez Nginx) ma aktualne pliki statyczne.

🧩➡️🎯 Dla nowego projektu: jeśli używa frontu budowanego (Vite/Webpack Encore), upewnij się, że obraz produkcyjny go buduje, a zbudowane assety trafiają tam, skąd serwuje je serwer WWW. Jeśli projekt nie ma frontu do budowania — pomiń ten krok.


Commit workflow i sekrety — podsumowanie czynności

# 💻 lokalnie
git add .github/workflows/deploy.yml
git commit -m "ci: add deploy workflow"
git push origin main

Ten push uruchomi deploy — ale jeśli nie dodałeś jeszcze trzech sekretów, zakończy się błędem (to normalne). Po dodaniu sekretów wykonamy pierwszy prawdziwy deploy w Rozdziale 9.


Weryfikacja rozdziału

  • Plik .github/workflows/deploy.yml jest w repo.
  • W https://github.com/<REPO>/settings/secrets/actions są trzy sekrety.
  • Rozumiesz, że VPS_SSH_KEY to prywatny <KLUCZ_LOKALNY> (nie github_deploy).
  • Rozumiesz rolę --env-file .env.local i (jeśli dotyczy) budowania frontu.

Częste problemy

Objaw Przyczyna Rozwiązanie
deploy: ssh: handshake failed / permission denied zły VPS_SSH_KEY (nie ten klucz albo niepełny) wklej cały prywatny <KLUCZ_LOKALNY> z liniami BEGIN/END
baza pada: „password authentication failed" / pusta brak --env-file .env.local dodaj --env-file .env.local do komend compose
strona bez stylów (goły HTML) front nie zbudowany / nie skopiowany npm run build w obrazie + cp public/build na hosta
deploy nie startuje po push zły branches: albo plik w złym katalogu plik musi być w .github/workflows/, trigger na main

Podsumowanie

  • ✅ Masz workflow deploy.yml (SSH → git pull → build → migracje → cache).
  • ✅ Dodałeś trzy sekrety; wiesz, który klucz to VPS_SSH_KEY.
  • ✅ Rozumiesz --env-file .env.local (sekrety produkcji) i build frontu.
  • ✅ Wiesz, co 🧩 uniwersalne (SSH+sekrety), a co 🎯 specyficzne (ścieżki, migracje, Vite).

Wszystko gotowe. Czas na pierwsze prawdziwe wdrożenie i jego weryfikację.

Dalej: Rozdział 9: Pierwszy deploy i weryfikacja.

Narzędzia / paczki

GitHub Actions appleboy/ssh-action Docker Compose Vite

Spis treści