Kurs Python · Moduł 12: Projekt końcowy
Deployment do Produkcji
W tej lekcji4
"U mnie działa" to najczęstsze zdanie w historii programowania. Na Twoim laptopie jest właściwa wersja Pythona, zainstalowane pakiety i ustawione zmienne środowiskowe. Serwer w chmurze nie ma nic z tych rzeczy. Deployment to moment, gdy kod staje się produktem, a naszym zadaniem jest spakować obóz tak, by rozłożył się identycznie w każdym miejscu sawanny.
Docker - konteneryzacja
Docker pakuje aplikację razem z systemem, Pythonem i zależnościami w obraz. Kontener to uruchomiony obraz. Użyjemy multi-stage build: pierwszy etap buduje paczki, drugi zabiera tylko wynik, dzięki czemu finalny obraz jest mniejszy. Etap pierwszy:
# Dockerfile
FROM python:3.12-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip wheel --no-cache-dir --no-deps --wheel-dir /wheels -r requirements.txtpip wheel zamienia każdą zależność w gotowy plik .whl. Flaga --no-deps oznacza, że pip nie dociąga zależności pośrednich, więc requirements.txt musi zawierać pełną, przypiętą listę (na przykład z pip freeze). Etap drugi:
FROM python:3.12-slim
WORKDIR /app
# Dependencies
COPY /wheels /wheels
RUN pip install --no-cache-dir /wheels/*
# Security
RUN useradd -m -u 1000 appuser
USER appuser
# Application
COPY . .
EXPOSE 8000
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]Kolejność ma znaczenie. Pakiety instalujemy jeszcze jako root, a dopiero potem przełączamy się na zwykłego użytkownika appuser, bo aplikacja nie powinna działać z uprawnieniami roota. Gdybyśmy zmienili użytkownika przed pip install, pip zainstalowałby pakiety do katalogu domowego i polecenie uvicorn nie byłoby na ścieżce. Obraz budujesz poleceniem docker build -t app:latest . (kropka to katalog z Dockerfile), a lokalnie uruchamiasz przez docker run -p 8000:8000 app:latest. Typowa kolejność pracy: Dockerfile, build, test lokalny, push do registry, wdrożenie na serwer.
Docker Compose zarządza kilkoma kontenerami jako jedną usługą. Nasza aplikacja potrzebuje Qdranta i Redisa, a wszystko opisujemy w jednym pliku. Najpierw serwis aplikacji:
# docker-compose.yml
services:
app:
build: .
ports:
- "8000:8000"
environment:
- OPENAI_API_KEY=${OPENAI_API_KEY}
- QDRANT_URL=http://qdrant:6333
- REDIS_URL=redis://redis:6379
depends_on:
- qdrant
- redis
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')"]
interval: 30s
timeout: 10s
retries: 3depends_on ustala kolejność startu, a healthcheck co 30 sekund pyta endpoint /health. Używamy do tego Pythona z biblioteki standardowej, bo obraz python:3.12-slim nie zawiera curl. Pole version na początku pliku jest przestarzałe, obecny Docker Compose je ignoruje, więc go nie piszemy. Dalej bazy danych i wolumeny:
qdrant:
image: qdrant/qdrant:latest
volumes:
- qdrant_data:/qdrant/storage
ports:
- "6333:6333"
redis:
image: redis:alpine
volumes:
- redis_data:/data
volumes:
qdrant_data:
redis_data:Wolumeny sprawiają, że dane przetrwają restart kontenera. Tag latest jest wygodny na start, ale w produkcji przypnij konkretną wersję obrazu, żeby aktualizacja nie przyszła niespodziewanie.
GitHub Actions - CI/CD
CI/CD to Continuous Integration i Continuous Deployment: każdy push automatycznie przechodzi przez testy, budowanie i wdrożenie. Pipeline ma kolejne etapy: test, build, push do registry, deploy. Pierwszy etap uruchamia testy:
# .github/workflows/deploy.yml
name: Deploy
on:
push:
branches: [main]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: "3.12"
- run: pip install -r requirements.txt
- run: pytest tests/ -v
Jeśli testy nie przejdą, dalsze etapy się nie wykonają. Drugi etap buduje obraz i wysyła go do Docker Huba (needs: test oznacza "tylko po udanych testach"):
build:
needs: test
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Build Docker image
run: docker build -t app:latest .
- name: Push to Registry
run: |
echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
docker tag app:latest ${{ secrets.DOCKER_USERNAME }}/ai-assistant:latest
docker push ${{ secrets.DOCKER_USERNAME }}/ai-assistant:latest
Hasło trafia do docker login przez --password-stdin, więc nie widać go w logach. Ostatni etap łączy się z serwerem przez SSH i podmienia kontenery:
deploy:
needs: build
runs-on: ubuntu-latest
steps:
- name: Deploy to server
uses: appleboy/ssh-action@v1
with:
host: ${{ secrets.SERVER_HOST }}
username: ${{ secrets.SERVER_USER }}
key: ${{ secrets.SSH_KEY }}
script: |
cd /app
docker compose pull
docker compose up -dAkcję przypinamy do wersji (@v1), a nie do gałęzi master, bo gałąź może się zmienić bez ostrzeżenia. To ważne szczególnie wtedy, gdy akcja dostaje klucz SSH do Twojego serwera.
Cloud Deployment Options
Gdzie postawić kontener? Oto cztery główne drogi z ich wadami i zaletami:
"""
Opcje deploymentu:
1. VPS (DigitalOcean, Hetzner)
- Pełna kontrola
- Niski koszt (zależny od dostawcy i rozmiaru maszyny)
- Wymaga zarządzania
2. Platform as a Service
- Railway, Render, Fly.io
- Łatwy deployment
- Auto-scaling
3. Kubernetes
- Dla dużych systemów
- Wysoka dostępność
- Złożona konfiguracja
4. Serverless
- AWS Lambda, Google Cloud Run
- Pay-per-use
- Cold starts
"""Ceny zmieniają się często, więc porównuj je w aktualnych cennikach dostawców. Moja rada na pierwszy projekt portfolio: platforma PaaS, bo wdrożysz kontener w kilka minut i nie musisz administrować serwerem.
Monitoring
Po wdrożeniu musisz wiedzieć, czy aplikacja żyje i jak szybko odpowiada. Biblioteka prometheus_client udostępnia liczniki (Counter) i histogramy czasu (Histogram), które Prometheus odczytuje z endpointu /metrics. app to aplikacja FastAPI z poprzedniej lekcji:
# Prometheus metrics
from prometheus_client import CONTENT_TYPE_LATEST, Counter, Histogram, generate_latest
from fastapi import Response
REQUEST_COUNT = Counter('requests_total', 'Total requests', ['method', 'endpoint'])
REQUEST_LATENCY = Histogram('request_latency_seconds', 'Request latency')
@app.middleware("http")
async def metrics_middleware(request, call_next):
REQUEST_COUNT.labels(request.method, request.url.path).inc()
with REQUEST_LATENCY.time():
response = await call_next(request)
return response
@app.get("/metrics")
async def metrics():
return Response(generate_latest(), media_type=CONTENT_TYPE_LATEST)Middleware liczy każde żądanie i mierzy jego czas. CONTENT_TYPE_LATEST to właściwy typ treści formatu Prometheusa, bezpieczniejszy niż ręcznie wpisane text/plain. Uważaj na etykietę ze ścieżką: przy adresach z identyfikatorami liczba serii może rosnąć bez końca.
Twój projekt jest gotowy do produkcji! W następnej lekcji zbudujemy portfolio, które pokaże go światu.
Pamiętaj: dobrze spakowany obóz rozkłada się identycznie w każdym miejscu sawanny, i to właśnie daje Ci kontener.
Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Po co używamy multi-stage build w Dockerfile?
2. Do czego służy Docker Compose?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Klikanie w kolejności
Kliknij w kolejności:
- Układanie w pionie
Uporządkuj kroki:
- Edytor kodu
Stwórz produkcyjny Dockerfile
- Układanie w poziomie
Ułóż elementy:
- Klikanie w kolejności
Kliknij w kolejności:
- Edytor kodu
Stwórz docker-compose z serwisami: app (FastAPI) i db (MongoDB).
- Układanie w pionie
Ułóż etapy CI/CD pipeline: