Demonstration der Arbeit mit Docker

1.1 Aufgabenstellung

Lass uns eine kleine Multi-Container-Anwendung erstellen und Schritt für Schritt den gesamten Entwicklungsprozess durchgehen: von der Aufgabenstellung bis zur Präsentation des fertigen Produkts.

Ziel: eine Multi-Container-Anwendung für das Aufgabenmanagement erstellen, die es den Nutzern ermöglicht, Aufgaben zu erstellen, zu bearbeiten, zu löschen und sie anderen Nutzern zuzuweisen. Die Anwendung wird aus drei Hauptkomponenten bestehen: einem Frontend in ReactJS, einem Backend in Python (Flask) und einer PostgreSQL-Datenbank.

Hauptaufgaben:

1. Funktionale Anforderungen für jede Komponente der Anwendung definieren.
2. Die zu verwendenden Technologien und Tools auswählen.
3. Die Entwicklungsumgebung vorbereiten.

1.2 Definition der funktionalen Anforderungen

Funktionale Anforderungen für eine Aufgabenverwaltungsanwendung:

1. Registrierung und Authentifizierung der Benutzer:
   • Der Benutzer kann sich im System registrieren.
   • Der Benutzer kann sich im System authentifizieren.
2. Verwaltung von Aufgaben:
   • Der Benutzer kann Aufgaben erstellen.
   • Der Benutzer kann Aufgaben bearbeiten.
   • Der Benutzer kann Aufgaben löschen.
   • Der Benutzer kann die Liste der Aufgaben anzeigen.
   • Der Benutzer kann Aufgaben anderen Benutzern zuweisen.
3. Anzeigen und Filtern von Aufgaben:
   • Der Benutzer kann Aufgaben nach Status filtern (erledigt/nichterledigt).
   • Der Benutzer kann Aufgaben anzeigen, die anderen Benutzern zugewiesen wurden.

1.3 Definition der verwendeten Technologien und Tools

Für die Umsetzung dieser Anwendung werden die folgenden Technologien und Tools verwendet:

1. Frontend:
   • ReactJS: Bibliothek zur Erstellung von Benutzeroberflächen.
   • Axios: Bibliothek für die Ausführung von HTTP-Anfragen.
2. Backend:
   • Python: Programmiersprache zur Erstellung des Server-Backends.
   • Flask: Web-Framework zur Erstellung von REST-APIs.
   • SQLAlchemy: ORM für die Interaktion mit der Datenbank.
3. Database:
   • PostgreSQL: Relationale Datenbank zum Speichern von Informationen über Benutzer und Aufgaben.
4. Containerisierung und Orchestrierung:
   • Docker: Plattform für die Containerisierung von Anwendungen.
   • Docker Compose: Tool zur Verwaltung von Multi-Container-Anwendungen.

1.4 Vorbereitung der Entwicklungsumgebung

Um das Projekt erfolgreich auszuführen, musst du die Entwicklungsumgebung einrichten und sicherstellen, dass alle notwendigen Tools installiert sind.

Schritte zur Vorbereitung der Umgebung:

1. Docker installieren:
   • Falls du es noch nicht getan hast, geh zurück zur Vorlesung 4 des ersten Levels oder folge den Anleitungen auf der offiziellen Docker-Website.
2. Docker Compose installieren:
   • Falls Docker Compose noch nicht installiert ist, schau dir die Vorlesung 2 des vierten Levels an oder folge den Anleitungen auf der offiziellen Docker Compose-Website.
3. Projektstruktur erstellen:
   • Erstelle ein Verzeichnis für das Projekt und die Hauptunterverzeichnisse für jeden Service:

mkdir task_management_app
cd task_management_app
mkdir frontend backend database
        

1. Projekt initialisieren:
   • Initialisiere innerhalb des Verzeichnisses frontend ein neues ReactJS-Projekt:

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

• Erstelle innerhalb des Verzeichnisses backend die Struktur für eine Python/Flask-App:

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

• Erstelle innerhalb des Verzeichnisses database eine Dockerfile für PostgreSQL (falls nötig):

cd database
touch Dockerfile
cd ..
        

1.5 Beispiel von Dateiinhalt:

Datei 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
    

Datei 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)
    

Datei backend/app/routes.py:

from app import app

@app.route('/')
def index():
    return "Hallo, Task Management App!"
    

Datei backend/run.py:

from app import app

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

Datei backend/requirements.txt:

Flask
Flask-SQLAlchemy
psycopg2-binary