Kurs Python · Moduł 5: Flask i aplikacje webowe

Deployment - publikacja w internecie

7 min czytania ·
W tej lekcji15

Gratulacje! Darwin tutaj z ostatnią lekcją Module 5 - deployment aplikacji Flask!

Zbudowałeś/aś funkcjonującą aplikację Safari Database z formularzami, autentykacją i templates. Teraz czas opublikować ją w internecie, żeby świat mógł z niej korzystać!

Analogia Safari: Deployment to jak otwarcie parku dla publiczności - dotychczas park działał tylko wewnętrznie (localhost), teraz otwierasz bramy dla turystów z całego świata (internet)!

Development vs Production

Development (localhost)

app.run(debug=True) - serwer deweloperski Auto-reload po zmianie kodu Szczegółowe błędy w przeglądarce Localhost tylko - nie dostępny z internetu Wolny - nie zoptymalizowany

Production (internet)

WSGI server (Gunicorn, uWSGI) Bez debug=True - bezpieczeństwo! Zmienne środowiskowe - SECRET_KEY, DATABASE_URL Dostępny publicznie - każdy może wejść Szybki - zoptymalizowany

NIGDY nie używaj app.run(debug=True) w produkcji!

WSGI Server - Gunicorn

Gunicorn (Green Unicorn) to popularny WSGI server dla aplikacji Flask/Django.

WSGI = Web Server Gateway Interface - standard komunikacji między serwerem a aplikacją Python.

Instalacja

pip install gunicorn

Uruchomienie

# Basic
gunicorn app:app

# Z określeniem portu i workerów
gunicorn app:app --bind 0.0.0.0:8000 --workers 4

# Z reload (dev tylko)
gunicorn app:app --reload

Format: gunicorn <module>:<app_variable>

  • app - nazwa pliku (app.py)
  • app - nazwa zmiennej Flask (app = Flask(name))

Przygotowanie do deployment

1. Plik requirements.txt

Zapisz wszystkie zależności:

pip freeze > requirements.txt

requirements.txt:

Flask==3.0.0
Flask-WTF==1.2.1
Flask-Login==0.6.3
Werkzeug==3.0.1
gunicorn==21.2.0

2. Zmienne środowiskowe

NIGDY nie commituj SECRET_KEY i wrażliwych danych do git!

Użyj zmiennych środowiskowych:

# app.py
import os

app = Flask(__name__)

# Pobierz z environment variables
app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY') or 'dev-fallback-key'
app.config['DATABASE_URL'] = os.environ.get('DATABASE_URL') or 'sqlite:///dev.db'

# Debug tylko w dev
app.config['DEBUG'] = os.environ.get('FLASK_ENV') == 'development'

3. .gitignore

# .gitignore
venv/
__pycache__/
*.pyc
*.pyo
.env
instance/
.DS_Store

4. Procfile (dla platform jak Render/Heroku)

web: gunicorn app:app

Procfile mówi platformie, jak uruchomić Twoją aplikację.

5. runtime.txt (opcjonalnie)

python-3.11.0

Określa wersję Pythona.

Deployment na Render (FREE!)

Render to nowoczesna platforma hostingowa z darmowym planem. Świetna alternatywa dla Heroku!

Krok 1: Przygotuj aplikację

Struktura projektu:

safari_web/
├── app.py
├── models.py
├── forms.py
├── requirements.txt
├── Procfile
├── .gitignore
├── templates/
│   └── ...
└── static/
    └── ...

app.py - ostatnie linie:

if __name__ == '__main__':
    # Tylko dla local development
    app.run(debug=True)

Render uruchomi przez Procfile, więc if __name__ nie wykona się!

Krok 2: Push do GitHub

git init
git add .
git commit -m "Initial commit - Safari Database"
git branch -M main
git remote add origin https://github.com/twoj-username/safari-web.git
git push -u origin main

Krok 3: Utwórz Web Service na Render

  1. Wejdź na https://render.com i zarejestruj się (FREE)

  2. Kliknij "New +" → "Web Service"

  3. Połącz GitHub repository

  4. Wybierz repozytorium safari-web

  5. Konfiguracja:

    • Name: safari-database
    • Environment: Python 3
    • Build Command: pip install -r requirements.txt
    • Start Command: gunicorn app:app
    • Plan: Free
  6. Environment Variables - dodaj:

    • SECRET_KEY = your-random-secret-key-here
    • FLASK_ENV = production
  7. Kliknij "Create Web Service"

Krok 4: Deploy!

Render automatycznie:

  • Instaluje zależności (pip install -r requirements.txt)
  • Uruchamia Gunicorn (gunicorn app:app)
  • Przydziela domenę (https://safari-database.onrender.com)

Gratulacje! Twoja aplikacja jest LIVE!

Deployment na Railway (również FREE!)

Railway to kolejna świetna platforma z prostym setupem.

Kroki:

  1. https://railway.app - zarejestruj się
  2. "New Project" → "Deploy from GitHub repo"
  3. Wybierz repozytorium
  4. Railway automatycznie wykryje Flask!
  5. Dodaj Environment Variables:
    • SECRET_KEY
    • FLASK_ENV=production
  6. Railway automatycznie deploy!

Domain: https://safari-database.up.railway.app

Deployment checklist

Przed deployment upewnij się:

Bezpieczeństwo

  • DEBUG = False w produkcji
  • SECRET_KEY jako zmienna środowiskowa
  • Hasła hashowane (werkzeug.security)
  • CSRF protection włączone (Flask-WTF)
  • .gitignore zawiera venv/, .env

Pliki

  • requirements.txt aktualny
  • Procfile utworzony
  • .gitignore utworzony
  • Static files poprawnie skonfigurowane

Baza danych

  • W dev: SQLite
  • W prod: PostgreSQL (Render/Railway FREE tier!)
  • DATABASE_URL jako zmienna środowiskowa

Testy

  • Aplikacja działa lokalnie
  • Wszystkie routes działają
  • Formularze działają
  • Logowanie/rejestracja działa

Baza danych w produkcji

SQLite (Development)

app.config['DATABASE_URL'] = 'sqlite:///safari.db'

Problemy: SQLite nie jest rekomendowane dla produkcji (problemy z współbieżnością).

PostgreSQL (Production)

Render/Railway oferują FREE PostgreSQL!

Render: Add PostgreSQL Database → skopiuj DATABASE_URL

import os

database_url = os.environ.get('DATABASE_URL')

if database_url and database_url.startswith('postgres://'):
    # Render używa postgres://, ale SQLAlchemy potrzebuje postgresql://
    database_url = database_url.replace('postgres://', 'postgresql://', 1)

app.config['SQLALCHEMY_DATABASE_URI'] = database_url or 'sqlite:///dev.db'

Static files w produkcji

Flask automatycznie serwuje pliki z static/, ale w produkcji lepiej użyć CDN lub Nginx.

Podstawowa konfiguracja Flask:

# app.py
app = Flask(__name__)

# Flask automatycznie serwuje static files z /static/
# http://yourapp.com/static/css/style.css

W templates:

<link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
<script src="{{ url_for('static', filename='js/script.js') }}"></script>

Monitorowanie i logi

Render Logs

Dashboard → Twój Web Service → Logs

Railway Logs

Project → Twój Service → Logs

Przykładowe logi:

[2024-01-15 10:23:45] INFO: Starting gunicorn 21.2.0
[2024-01-15 10:23:45] INFO: Listening at: http://0.0.0.0:10000
[2024-01-15 10:23:45] INFO: Using worker: sync
[2024-01-15 10:23:45] INFO: Booting worker with pid: 42

Aktualizacja aplikacji

Render/Railway

  1. Zmiany w kodzie lokalnie
  2. Commit do git:
    git add .
    git commit -m "Update: Add new feature"
    git push origin main
  3. Render/Railway automatycznie deploy nową wersję!

Auto-deploy = push to GitHub → automatyczny deploy!

Własna domena (opcjonalnie)

Zamiast safari-database.onrender.com możesz użyć własnej domeny:

  1. Kup domenę (np. safaridatabase.com)
  2. Render/Railway → Settings → Custom Domain
  3. Dodaj CNAME record u rejestratora domeny
  4. Gotowe! https://safaridatabase.com → Twoja aplikacja

Alternatywne platformy

1. Fly.io

  • FREE tier
  • Globalny deployment
  • Świetna dokumentacja

2. PythonAnywhere

  • FREE tier dla Flask
  • Prosty setup
  • Dobre dla początkujących

3. DigitalOcean App Platform

  • $5/miesiąc
  • Więcej kontroli
  • Skalowalne

4. AWS/Google Cloud/Azure

  • Zaawansowane
  • Droższe
  • Pełna kontrola

Przykład production-ready app.py

# app.py
import os
from flask import Flask, render_template, redirect, url_for, flash
from flask_login import LoginManager, login_user, logout_user, login_required, current_user
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)

# Configuration from environment variables
app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY') or 'dev-key-change-in-production'
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL') or 'sqlite:///dev.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

# Fix for Render PostgreSQL URL
if app.config['SQLALCHEMY_DATABASE_URI'].startswith('postgres://'):
    app.config['SQLALCHEMY_DATABASE_URI'] = app.config['SQLALCHEMY_DATABASE_URI'].replace('postgres://', 'postgresql://', 1)

db = SQLAlchemy(app)
login_manager = LoginManager(app)
login_manager.login_view = 'login'

# Models, routes, etc...

if __name__ == '__main__':
    # Only for local development
    port = int(os.environ.get('PORT', 5000))
    app.run(host='0.0.0.0', port=port, debug=os.environ.get('FLASK_ENV') == 'development')

Podsumowanie

W tej lekcji nauczyłeś/aś się:

  • Różnica między development a production
  • WSGI servers (Gunicorn)
  • Przygotowanie aplikacji do deployment
  • Zmienne środowiskowe (SECRET_KEY, DATABASE_URL)
  • Deployment na Render (FREE!)
  • Deployment na Railway (FREE!)
  • Deployment checklist
  • Bazy danych w produkcji (PostgreSQL)
  • Static files w produkcji
  • Monitorowanie i logi
  • Aktualizacja aplikacji (auto-deploy)

Analogia Safari finalna: Deployment to jak grand opening parku safari - przygotowałeś infrastrukturę (kod), zatrudniłeś pracowników (WSGI server), zabezpieczyłeś park (SECRET_KEY, HTTPS), i otworzyłeś bramy dla turystów z całego świata (internet)! Twoja aplikacja Flask żyje i działa 24/7 w chmurze!

Gratulacje Module 5!

Zbudowałeś/aś kompletną aplikację webową z:

  • Frontend (HTML, CSS, JavaScript)
  • Backend (Flask)
  • Routing i view functions
  • Jinja2 templates
  • Formularze z walidacją (Flask-WTF)
  • Autentykacja (Flask-Login)
  • Deployment w internecie (Render/Railway)

Safari Database jest teraz LIVE i dostępna dla każdego w internecie!

Darwin jest z Ciebie dumny! Przygotuj się na kolejne moduły, gdzie poznasz zaawansowane techniki Python i AI!

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. 1. Czym jest deployment aplikacji webowej?

  2. 2. Czym jest Gunicorn?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż typowe kroki deploymentu aplikacji Flask:

  • Klikanie w kolejności

    Ułóż komendę generującą requirements.txt:

  • Edytor kodu

    Napisz klasę Config z SECRET_KEY pobieranym ze zmiennej środowiskowej.

  • Układanie w poziomie

    Ułóż elementy dekoratora route:

  • Układanie w pionie

    Uporządkuj kroki tworzenia aplikacji Flask:

  • Edytor kodu

    Napisz route '/api/species' zwracający listę gatunków jako JSON.

  • Edytor kodu

    Utwórz route '/' w Flask zwracający 'Witaj na Safari!'.

  • Edytor kodu

    Wyrenderuj szablon 'index.html' przekazując zmienną title.

  • Układanie w pionie

    Uporządkuj etapy obsługi żądania HTTP:

  • Edytor kodu

    Zdefiniuj klasę LoginForm z polami username i password.

  • Edytor kodu

    Zbuduj aplikację Safari Species Portal z: listą gatunków, dodawaniem nowych, logowaniem użytkowników i podstawowym stylem CSS.

  1. PytanieCo to deployment?
  2. PytanieGunicorn
  3. Pytanierequirements.txt
  4. Ułóż w kolejnościKroki deploymentu
  5. Kliknij w kolejnościGenerowanie requirements
  6. Zadanie z kodemKonfiguracja produkcyjna
  7. Ułóż w kolejnościDekorator route w Flask
  8. Ułóż w kolejnościTworzenie aplikacji Flask
  9. Zadanie z kodemEndpoint JSON w Flask
  10. Zadanie z kodemPodstawowa trasa Flask
  11. Zadanie z kodemSzablon Jinja2 z danymi
  12. Ułóż w kolejnościObsługa żądania HTTP w Flask
  13. Zadanie z kodemFormularz logowania
  14. Zadanie z kodemProjekt: Safari Species Portal
  15. Projekt do wysłaniaWyślij projekt do mentora
  16. WideoPodsumowanie modułu

Przydatne artykuły