Demonstracja pracy z Dockerem

1.1 Postawienie zadania

Stwórzmy małą aplikację wielokontenerową i krok po kroku przeanalizujmy cały proces jej tworzenia: od sformułowania zadania po demonstrację gotowego produktu.

Cel: stworzyć aplikację wielokontenerową do zarządzania zadaniami, która pozwoli użytkownikom tworzyć, edytować, usuwać zadania oraz przypisywać je innym użytkownikom. Aplikacja będzie się składała z trzech głównych komponentów: frontendu na ReactJS, backendu na Pythonie (Flask) oraz bazy danych PostgreSQL.

Główne zadania:

1. Określić wymagania funkcjonalne dla każdego komponentu aplikacji.
2. Wybrać używane technologie i narzędzia.
3. Przygotować środowisko do tworzenia aplikacji.

1.2 Określenie wymagań funkcjonalnych

Wymagania funkcjonalne dla aplikacji zarządzania zadaniami:

1. Rejestracja i autoryzacja użytkowników:
   • Użytkownik może zarejestrować się w systemie.
   • Użytkownik może zalogować się do systemu.
2. Zarządzanie zadaniami:
   • Użytkownik może tworzyć zadania.
   • Użytkownik może edytować zadania.
   • Użytkownik może usuwać zadania.
   • Użytkownik może przeglądać listę zadań.
   • Użytkownik może przypisywać zadania innym użytkownikom.
3. Przeglądanie i filtrowanie zadań:
   • Użytkownik może filtrować zadania według statusu (wykonane/niewykonane).
   • Użytkownik może przeglądać zadania przypisane innym użytkownikom.

1.3 Określenie używanych technologii i narzędzi

Do realizacji tej aplikacji zostaną wykorzystane następujące technologie i narzędzia:

1. Frontend:
   • ReactJS: biblioteka do tworzenia interfejsów użytkownika.
   • Axios: biblioteka do wykonywania zapytań HTTP.
2. Backend:
   • Python: język programowania do tworzenia części serwerowej.
   • Flask: web framework do tworzenia REST API.
   • SQLAlchemy: ORM do pracy z bazą danych.
3. Baza danych:
   • PostgreSQL: relacyjna baza danych do przechowywania informacji o użytkownikach i zadaniach.
4. Konteneryzacja i orkiestracja:
   • Docker: platforma do konteneryzacji aplikacji.
   • Docker Compose: narzędzie do zarządzania aplikacjami wielokontenerowymi.

1.4 Przygotowanie środowiska do programowania

Aby pomyślnie zrealizować projekt, trzeba skonfigurować środowisko programowania i upewnić się, że wszystkie niezbędne narzędzia są zainstalowane.

Kroki przygotowania środowiska:

1. Instalacja Docker’a:
   • Jeśli jeszcze tego nie zrobiłeś(-aś), wróć do wykładu 4 z pierwszego poziomu albo postępuj zgodnie z instrukcjami na oficjalnej stronie Docker’a.
2. Instalacja Docker Compose:
   • Jeśli Docker Compose jeszcze nie jest zainstalowany, odnieś się do wykładu 2 z poziomu 4 albo postępuj zgodnie z instrukcjami na oficjalnej stronie Docker Compose.
3. Tworzenie struktury projektu:
   • Stwórz katalog dla projektu i główne podkatalogi dla każdego serwisu:

mkdir task_management_app
cd task_management_app
mkdir frontend backend database
        

1. Inicjalizacja projektu:
   • Wewnątrz katalogu frontend zainicjalizuj nowy projekt ReactJS:

cd frontend
npx create-react-app .
cd ..
        

• Wewnątrz katalogu backend stwórz strukturę dla aplikacji Python/Flask:

cd backend
mkdir app
touch app/__init__.py
touch app/models.py
touch app/routes.py
touch run.py
touch requirements.txt
cd ..
        

• Wewnątrz katalogu database stwórz Dockerfile dla PostgreSQL (jeśli to konieczne):

cd database
touch Dockerfile
cd ..
        

1.5 Przykład zawartości plików:

Plik backend/app/__init__.py:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://taskuser:taskpassword@database:5432/taskdb'
db = SQLAlchemy(app)

from app import routes
    

Plik backend/app/models.py:

from app import db

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    tasks = db.relationship('Task', backref='owner', lazy=True)

class Task(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(120), nullable=False)
    description = db.Column(db.Text, nullable=True)
    owner_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    

Plik backend/app/routes.py:

from app import app

@app.route('/')
def index():
    return "Cześć, Aplikacja Do Zarządzania Zadaniami!"
    

Plik backend/run.py:

from app import app

if __name__ == '__main__':
    app.run(host='0.0.0.0')
    

Plik backend/requirements.txt:

Flask
Flask-SQLAlchemy
psycopg2-binary