Poetry installieren und Flask-Abhängigkeiten 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.tomlein. - Erstellt eine
poetry.lock-Datei zur Absicherung identischer Builds.
Using version ^3.1.0 for flask
Updating dependencies
Resolving dependencies… (0.2s)
Package operations: 7 installs, 0 updates, 0 removals
- Installing markupsafe (3.0.2)
- Installing blinker (1.9.0)
- Installing click (8.1.8)
- Installing itsdangerous (2.2.0)
- Installing jinja2 (3.1.5)
- Installing werkzeug (3.1.3)
- Installing flask (3.1.0)
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
To Action From
— —— —-
22/tcp ALLOW Anywhere
5000/tcp ALLOW Anywhere
22/tcp (v6) ALLOW Anywhere (v6)
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
* Serving Flask app ‘app’
* Debug mode: off
WARNING: This is a development server. Do not use it in a production deployment.
Use a production WSGI server instead.
* Running on all addresses (0.0.0.0)
* Running on http://127.0.0.1:5000
* Running on http://<SERVER-IP>:5000
Press CTRL+C to quit
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:
platform linux — Python 3.12.3, pytest-8.3.4, pluggy-1.5.0
rootdir: /home/linuxuser/flask-app
configfile: pyproject.toml
collected 1 item
test_app.py . [100%]
============================= 1 passed in 0.11s ==============================
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
Virtualenv
Python: 3.12.3
Implementation: CPython
Path: /home/linuxuser/flask-app/.venv
Executable: /home/linuxuser/flask-app/.venv/bin/python
Valid: True
Base Platform: linux
OS: posix
Python: 3.12.3
Path: /usr
Executable: /usr/bin/python3.12
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.
