Flask-Projekte mit Poetry unter Ubuntu 24.04 verwalten

Poetry ist ein kostenloses Open-Source-Werkzeug, das die Verwaltung von Abhängigkeiten und das Packaging von Python-Projekten vereinfacht. Es liefert einen klaren Überblick über die Projektabhängigkeiten, erleichtert die Installation und sorgt für eine unkomplizierte Veröffentlichung auf PyPI.

In dieser Anleitung erfährst du, wie du Poetry mit Pipx installierst, es für ein Flask-Projekt auf Ubuntu 24.04 einrichtest, eine virtuelle Umgebung erstellst und deine Flask-Anwendung mit Poetry und Gunicorn betreibst.

Voraussetzungen

• Du arbeitest auf einem Ubuntu-24.04-System.

Poetry mit Pipx unter Ubuntu 24.04 installieren

Es wird empfohlen, Poetry in einer isolierten Umgebung zu installieren, um Konflikte mit globalen Python-Abhängigkeiten zu vermeiden. Befolge diese Schritte zur Einrichtung von Pipx und zur Installation von Poetry:

1. APT-Paketindex aktualisieren

$ sudo apt update

2. Pipx installieren

$ sudo apt install pipx -y

3. Pipx zum Systempfad hinzufügen

$ pipx ensurepath

4. Autovervollständigung für Pipx aktivieren

$ echo 'eval "$(register-python-argcomplete pipx)"' >> ~/.bashrc

5. Bash-Konfiguration neu laden

$ source ~/.bashrc

6. Poetry mit Pipx installieren

$ pipx install poetry

Nach der Installation erscheint folgende Meldung im Terminal:

installed package poetry 2.0.0, installed using Python 3.12.3 These apps are now globally available - poetry done!

7. Installierte Poetry-Version prüfen

$ poetry --version

Die Ausgabe sollte wie folgt aussehen:

Poetry (version 2.0.0)

Ein neues Poetry-Projekt für Flask anlegen

Du kannst Poetry in ein bestehendes Python-Projekt integrieren oder ein komplett neues Projekt erzeugen. Wenn du ein neues Projekt anlegst, erstellt Poetry automatisch die gesamte Struktur und Konfigurationsdateien. So startest du ein neues Flask-Projekt mit Poetry:

1. Neues Projekt mit Poetry erzeugen

$ poetry new flask-app

Der Befehl erstellt ein Verzeichnis flask-app mit folgendem Inhalt:

• flask_app: Beinhaltet eine __init__.py-Datei mit dem Flask-Code, Modulen und Funktionen.
• pyproject.toml: Enthält Metadaten zum Projekt, die Poetry-Konfiguration und die Abhängigkeiten.
• README.md: Einfache Projektdokumentation.
• tests: Strukturiert die Testfälle des Projekts.

Created package flask_app in flask-app

2. In das Projektverzeichnis wechseln

$ cd flask-app

Virtuelle Umgebung einrichten und Flask installieren

1. Python-Interpreter auswählen

$ poetry env use python3

Mit diesem Befehl weist du Poetry an, den standardmäßigen Python-3-Interpreter des Systems zu verwenden. Wenn du eine bestimmte Version nutzen möchtest, kannst du z. B. poetry env use python3.11 ausführen, sofern diese Version installiert ist.

Creating virtualenv flask-app-vnQ3DaWl-py3.12 in /home/linuxuser/.cache/pypoetry/virtualenvs

Using virtualenv: /home/linuxuser/.cache/pypoetry/virtualenvs/flask-app-vnQ3DaWl-py3.12

2. Aktivierungsbefehl abrufen

$ poetry env activate

source /home/linuxuser/.cache/pypoetry/virtualenvs/flask-app-vnQ3DaWl-py3.12/bin/activate

3. Virtuelle Umgebung aktivieren

$ source /home/linuxuser/.cache/pypoetry/virtualenvs/flask-app-vnQ3DaWl-py3.12/bin/activate

(flask-app-py3.12) linuxuser@:~/flask-app$

4. Flask im Projekt installieren

$ poetry add flask

Dieser Befehl führt mehrere Dinge aus:

• Installiert Flask und alle erforderlichen Pakete in der virtuellen Umgebung.
• Trägt die installierte Flask-Version in der Datei pyproject.toml ein.
• Erstellt eine poetry.lock-Datei zur Absicherung identischer Builds.

Using version ^3.1.0 for flask

Updating dependencies

Resolving dependencies... (0.2s)

Writing lock file

5. Virtuelle Umgebung verlassen

$ deactivate

Firewall für Flask unter Ubuntu 24.04 konfigurieren

Standardmäßig ist auf den meisten Ubuntu-24.04-Systemen die UFW-Firewall aktiv. Um den Zugriff auf deine Flask-Anwendung zu ermöglichen, solltest du den verwendeten Port – in der Regel Port 5000 – freigeben. Hier sind die nötigen Schritte:

1. Port 5000 freigeben

$ sudo ufw allow 5000/tcp

2. Firewall-Konfiguration neu laden

$ sudo ufw reload

3. UFW-Status überprüfen

$ sudo ufw status

Status: active

5000/tcp (v6) ALLOW Anywhere (v6)

Flask-Anwendung mit Poetry ausführen

Poetry verwaltet nicht nur Abhängigkeiten, sondern kann auch Projekte direkt ausführen. Hier erfährst du, wie du deine Flask-App über die Poetry-Umgebung startest:

1. Befehl zur Aktivierung der Umgebung abrufen

$ poetry env activate

source /home/linuxuser/.cache/pypoetry/virtualenvs/flask-app-vnQ3DaWl-py3.12/bin/activate

2. Umgebung aktivieren

$ source /home/linuxuser/.cache/pypoetry/virtualenvs/flask-app-vnQ3DaWl-py3.12/bin/activate

3. Zum Projektverzeichnis wechseln

$ cd flask_app

4. Datei app.py erstellen

$ nano app.py

5. Folgenden Code einfügen

from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "<h1>Greetings</h1>"

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

Drücke Strg+X, anschließend Y und dann Enter, um die Datei zu speichern.

Dieser Code zeigt beim Aufruf der Startseite eine einfache HTML-Ausgabe „Greetings“ an.

6. Flask-Anwendung mit Poetry starten

$ poetry run python app.py

Rufe die Anwendung im Browser unter folgender Adresse auf:

http://<SERVER-IP>:5000

Zum Beenden der Anwendung drücke Strg+C im Terminal.

Entwicklungs- und Produktionsabhängigkeiten mit Poetry verwalten

Poetry erlaubt es, Abhängigkeiten in Gruppen zu organisieren. Dadurch lassen sich Entwicklungswerkzeuge von produktiven Bibliotheken trennen. Hier siehst du, wie du eine Gruppe für die Entwicklung anlegst und pytest für Tests hinzufügst.

1. Pytest in der Dev-Gruppe installieren

$ poetry add pytest --group dev

Dieser Befehl fügt im pyproject.toml eine neue Sektion [tool.poetry.group.dev.dependencies] hinzu. Darin wird pytest = "^8.3.4" unter der Gruppe dev gespeichert.

Produktionsabhängigkeiten sollten keiner Gruppe zugeordnet werden. Stattdessen gehören sie direkt unter [tool.poetry.dependencies], um sicherzustellen, dass sie beim Build und Deployment nicht ausgeschlossen werden.

2. Unit-Test für die Flask-App erstellen

Wechsle zunächst in das Testverzeichnis deiner Flask-Anwendung:

$ cd ~/flask-app/tests

Erstelle einen neuen Ordner unit:

$ mkdir unit

Wechsle in das neue Verzeichnis:

$ cd unit

Lege die Datei __init__.py an, um das Verzeichnis als Python-Paket zu kennzeichnen:

$ touch __init__.py

Mit dieser Datei erkennt Python das Verzeichnis als Paket und erlaubt Modulimporte. Weitere Informationen findest du in der offiziellen Python-Dokumentation.

Erstelle die Datei test_app.py:

$ nano test_app.py

Füge folgenden Testcode ein:

import pytest
from flask_app.app import app

@pytest.fixture
def client():
    with app.test_client() as client:
        yield client

def test_the_home_route(client):
    response = client.get('/')
    assert response.status_code == 200
    assert b"<h1>Greetings</h1>" in response.data

Speichere und schließe die Datei mit Strg+X, dann Y, und bestätige mit Enter.

Dieser Unit-Test prüft, ob die Startseite der Flask-App den erwarteten HTML-Inhalt zurückgibt.

3. Test ausführen

$ pytest

Die Ausgabe sollte in etwa so aussehen:

Gunicorn für Flask in der Produktion konfigurieren

Gunicorn ist ein produktionsreifer WSGI-Server für Python-Webanwendungen. Er verarbeitet Anfragen effizient und ist daher ideal für Flask in Live-Umgebungen. Die folgenden Schritte zeigen, wie du Gunicorn mit deiner Flask-App verwendest.

1. In das Flask-App-Verzeichnis wechseln

$ cd ~/flask-app/flask_app

2. Gunicorn als Produktionsabhängigkeit hinzufügen

$ poetry add gunicorn

3. Datei wsgi.py erstellen

$ nano wsgi.py

Füge diesen Python-Code ein:

from app import app

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

Speichern mit Strg+X, Y und Enter.

4. Flask-App mit Gunicorn starten

$ gunicorn --bind 0.0.0.0:5000 wsgi:app

Rufe deine Flask-Anwendung im Browser unter folgender Adresse auf:

http://<SERVER-IP>:5000

Zum Beenden des Servers verwende Strg+C im Terminal.

Poetry-Umgebungen verwalten und neu erstellen

Poetry legt virtuelle Umgebungen an, die Speicherplatz belegen, sich jedoch bei Bedarf löschen und wiederherstellen lassen. Die folgenden Schritte zeigen, wie du deine aktuelle Umgebung entfernst und neu erzeugst.

1. Virtuelle Umgebung verlassen

$ deactivate

2. Alle Umgebungen für das Projekt auflisten

$ poetry env list

Die aktuell verwendete Umgebung wird mit (Activated) markiert.

flask-app-vnQ3DaWl-py3.12 (Activated)

3. Umgebung löschen

$ poetry env remove flask-app-vnQ3DaWl-py3.12

Deleted virtualenv: /home/linuxuser/.cache/pypoetry/virtualenvs/flask-app-vnQ3DaWl-py3.12

4. Neue virtuelle Umgebung erzeugen

$ poetry env use python3

5. Aktivierungsbefehl abrufen

$ poetry env activate

source /home/linuxuser/.cache/pypoetry/virtualenvs/flask-app-vnQ3DaWl-py3.12/bin/activate

6. Umgebung aktivieren

$ source /home/linuxuser/.cache/pypoetry/virtualenvs/flask-app-vnQ3DaWl-py3.12/bin/activate

7. Abhängigkeiten aus pyproject.toml installieren

$ poetry install

Solange die pyproject.toml-Datei vorhanden ist, lassen sich Umgebung und Abhängigkeiten jederzeit wiederherstellen.

Speicherort der virtuellen Umgebung ändern

Standardmäßig speichert Poetry virtuelle Umgebungen unter ~/.cache/pypoetry/virtualenvs. Du kannst den Speicherort aber auch direkt ins Projektverzeichnis verlegen, um deine Dateien besser zu organisieren.

1. Aktuelle Umgebung verlassen

$ deactivate

2. Vorhandene Umgebungen auflisten

$ poetry env list

flask-app-vnQ3DaWl-py3.12 (Activated)

3. Umgebung löschen

$ poetry env remove flask-app-vnQ3DaWl-py3.12

4. Speicherort auf Projektverzeichnis umstellen

$ poetry config virtualenvs.in-project true

Mit diesem Befehl überschreibst du die Standardkonfiguration, sodass die virtuelle Umgebung im Hauptverzeichnis des Projekts erzeugt wird.

5. Konfiguration überprüfen

$ poetry config virtualenvs.in-project

true

6. Neue Umgebung erzeugen

$ poetry env use python3

Creating virtualenv flask-app in /home/linuxuser/flask-app/.venv

Using virtualenv: /home/linuxuser/flask-app/.venv

7. Aktivierungsbefehl abrufen

$ poetry env activate

source /home/linuxuser/flask-app/.venv/bin/activate

8. Umgebung aktivieren

$ source /home/linuxuser/flask-app/.venv/bin/activate

9. Umgebungsinformationen anzeigen

$ poetry env info

10. Abhängigkeiten erneut installieren

$ poetry install

11. Flask-Anwendung mit Gunicorn starten

$ gunicorn --bind 0.0.0.0:5000 wsgi:app

Rufe die Anwendung im Browser unter folgender Adresse auf:

http://<SERVER-IP>:5000

Fazit

In dieser Anleitung hast du gelernt, wie man Poetry auf Ubuntu 24.04 installiert und nutzt, um Abhängigkeiten in einem Flask-Projekt zu verwalten. Du hast ein Projekt mit Poetry erstellt, virtuelle Umgebungen konfiguriert, Tests ausgeführt und einen produktionsfähigen Server mit Gunicorn eingerichtet. Außerdem hast du erfahren, wie du den Speicherort deiner Umgebung kontrollieren und dein Setup effizient organisieren kannst.

Weitere Informationen findest du in der offiziellen Poetry-Dokumentation.