Cet article est un article sœur du [Flux de développement Python à l'aide de pipenv, Git et Docker] précédemment écrit (https://qiita.com/Aruneko/items/796d7eeb61e1f36ae4a0). Maintenant que le développement de Pipenv n'est pas très actif, je pense qu'il y aura des occasions où Poetry sera utilisé dans des projets qui utilisent Python. Par conséquent, je voudrais réorganiser le flux de développement en utilisant la poésie.
Dans la plupart des cas, vous pouvez l'installer à partir du gestionnaire de packages fourni avec votre système d'exploitation.
$ brew install poetry
Arch Linux
$ sudo pacman -S python-poetry
Ubuntu 18.04 Malheureusement, il n'est pas enregistré dans le référentiel standard, alors installez-le à partir du programme d'installation officiel.
$ sudo apt install python3 python3-pip
$ curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python3
Lorsque l'installation est terminée, mettez votre PATH dans ~ / .poetry / bin. En fonction de votre shell, ajoutez les paramètres suivants à ~ / .zshrc et ~ / .bashrc.
~/.bashrc
export PATH=${HOME}/.poetry/bin:${PATH}
J'utiliserai Git et Docker / Docker Compose à l'avenir, alors soyez prêt.
Il est maintenant temps d'initialiser le projet Python en utilisant la poésie.
Tout d'abord, créez un répertoire approprié et placez-le dedans.
$ mkdir sample-app
$ cd sample-app
Vous pouvez ensuite initialiser le projet en exécutant poetry init. C'est interactif, répondons donc à chacun. On vous demandera si vous souhaitez installer les paquets dépendants en cours de route, mais cette fois je veux les installer individuellement, donc je vais l'ignorer.
$ poetry init
This command will guide you through creating your pyproject.toml config.
Package name [sample_app]:
Version [0.1.0]:
Description []: Sample App
Author [Aruneko <[email protected]>, n to skip]:
License []: MIT
Compatible Python versions [^3.7]:
Would you like to define your main dependencies interactively? (yes/no) [yes] no
Would you like to define your development dependencies interactively? (yes/no) [yes] no
Generated file
[tool.poetry]
name = "sample_app"
version = "0.1.0"
description = "Sample App"
authors = ["Aruneko <[email protected]>"]
license = "MIT"
[tool.poetry.dependencies]
python = "^3.7"
[tool.poetry.dev-dependencies]
[build-system]
requires = ["poetry>=0.12"]
build-backend = "poetry.masonry.api"
Do you confirm generation? (yes/no) [yes]
Lorsque vous quittez l'environnement interactif, vous aurez pyproject.toml. Ceci termine l'initialisation du projet.
$ ls
pyproject.toml
Normalement, l'environnement virtuel Python créé sous ~ / Library / Caches / pypoetry / virtualenvs ou ~ / .config / poetry aura le répertoire .venv directement sous la racine du projet si les paramètres suivants sont ajoutés. Sera créé et y gérera l'environnement Python. Veuillez définir comme vous le souhaitez.
$ poetry config virtualenvs.in-project true --local
Veuillez noter que ce paramètre est répertorié dans poetry.toml au lieu de pyproject.toml.
Dans l'environnement Poetry, utilisez ʻadd` pour ajouter des packages comme avec npm. Développons une application qui utilise FastAPI comme exemple.
$ poetry add fastapi uvicorn
Lorsque vous installez un package avec Poetry, les packages dépendants qui peuvent être résolus à ce moment-là et les informations de version de chaque package sont écrits dans poetry.lock.
Les packages qui ne sont utilisés que pendant le développement sont installés avec l'option -D ainsi que npm. Par exemple, installons le formateur de code black.
$ poetry add -D black
En exécutant les commandes jusqu'à présent, vous pouvez voir que les packages installés jusqu'à présent ont été ajoutés aux sections tool.poetry.dependencies et tool.poetry.dev-dependencies de pyproject.toml. ..
pyproject.toml
[tool.poetry.dependencies]
python = "^3.7"
fastapi = "^0.52.0"
uvicorn = "^0.11.3"
[tool.poetry.dev-dependencies]
black = "^19.10b0"
À partir de maintenant, veuillez installer le package selon vos besoins à chaque fois.
Ensuite, initialisez Git pour gérer ce projet avec Git. Utilisons gitignore.io pour créer d'abord un fichier .gitignore. Cette fois, nous vous demanderons de spécifier Python et virtualenv. Si vous avez besoin de paramètres supplémentaires pour .gitignore, modifiez-le ici.
Une fois que vous avez .gitignore, initialisez votre dépôt Git, ajoutez à peu près tous les fichiers et validez.
$ curl -o .gitignore https://www.gitignore.io/api/python,virtualenv
$ git init
$ git add pyproject.toml poetry.lock poetry.toml .gitignore
$ git commit -m "Initial Commit"
Utilisez la sous-commande shell pour entrer dans l'environnement virtuel Python créé par Poetry. Si vous oubliez d'entrer dans l'environnement virtuel, divers problèmes tels que l'impossibilité de voir le paquet que vous auriez dû installer se produiront, alors assurez-vous de le vérifier attentivement. Pour quitter, utilisez la commande ʻexit`.
$ poetry shell
(.venv)$ exit
Maintenant que nous avons créé le projet Poetry, nous allons enfin travailler sur la conversion Docker.
Les fichiers qui n'ont pas besoin d'être transférés doivent être saisis dans .dockerignore. Assurez-vous de l'inclure, surtout si vous avez défini le fichier .venv pour qu'il soit à la racine du projet. De plus, c'est une bonne idée de ne pas transférer le répertoire __pycache__.
.dockerignore
.venv/
__pycache__/
Enfin, j'écrirai un Dockerfile. Cette fois, je présenterai la méthode utilisant Multi Stage Build. La procédure est divisée en la première moitié pour créer requirements.txt et la seconde moitié pour créer une image Docker avec une application Python.
La raison pour laquelle vous devez le faire en premier lieu est que vous devez installer Poetry pour lire poetry.lock, mais vous n'avez pas besoin de mettre Poetry dans le conteneur où l'application est placée, vous voulez donc les séparer. Parce qu'il y a une intention. La poésie a la capacité de générer requirements.txt, nous en profiterons donc.
Tout d'abord, de l'explication de la première moitié. Pour bien utiliser la stratégie de mise en cache de Docker, j'installe d'abord Poetry. Cela vous évitera d'avoir à installer Poetry sur chaque build. Ensuite, il copie simplement pyproject.toml et poetry.lock pour générer requirements.txt.
Vient ensuite l'explication de la seconde moitié. Copiez le requirements.txt résultant de la première moitié, puis utilisez la commande pip pour installer tous ces packages. Si ces fichiers restent inchangés, le cache sera utilisé et la couche suivante sera construite automatiquement, vous pouvez donc empêcher le comportement de téléchargement de packages dépendants à chaque fois que vous construisez. .. Il s'agit d'une configuration recommandée car elle peut gagner un temps de construction écrasant. Une fois l'installation terminée, transférez divers scripts Python et écrivez les commandes que vous souhaitez exécuter, et vous avez terminé.
FROM python:3.8-slim as builder
WORKDIR /usr/src/app
RUN pip install poetry
COPY pyproject.toml poetry.lock ./
RUN poetry export -f requirements.txt > requirements.txt
FROM python:3.8-slim
ENV PYTHONUNBUFFERED=1
WORKDIR /usr/src/app
COPY --from=builder /usr/src/app/requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 8000
CMD [ "uvicorn", "main:app", "--host", "0.0.0.0" ]
C'est également une bonne idée de configurer Docker Compose. Il peut être judicieux de monter le fichier local pour le développement, puis de définir les paramètres de rechargement automatique.
docker-compose.yml
version: '3'
services:
app:
build: .
volumes:
- ./:/usr/src/app
ports:
- "8000:8000"
command: ["uvicorn", "main:app", "--reload", "--host", "0.0.0.0"]
FAQ
Vous pouvez utiliser «mise à jour de la poésie». Cependant, il ne sera pas mis à jour au-delà de la version décrite dans pyproject.toml, donc soyez prudent lors de la mise à niveau des versions majeures.
Vous pouvez le supprimer avec poetry remove PACKAGE_NAME.
Vous pouvez installer le package de dépendances de développement complet avec poetry install.
Jusqu'à présent, nous avons expliqué le flux de développement d'un projet Python utilisant Poetry. Dans Poetry ainsi que Pipenv, je pense qu'en utilisant poetry.lock, il est possible d'éliminer la différence de version entre les développeurs et de fournir un environnement de développement stable. Il suit également le format convenu par PEP, donc on a l'impression que ce n'est pas mal pour l'avenir.
D'un autre côté, j'ai l'impression qu'il s'agit d'un outil de gestion de projet pour ** développeurs de packages Python ** plutôt que pour des applications Python, comme par exemple l'absence de la fonction script qui exécute le one-liner qui était possible avec Pipenv. Je l'utilise beaucoup pour exécuter Lint et d'autres tests, mais cette fonctionnalité.
Ainsi, Poetry et Pipenv ont tous deux leurs avantages et leurs inconvénients. Je pense qu'il est prudent à ce stade de sélectionner celui qui convient à votre projet. J'espère que vous avez tous une bonne vie Python.
Recommended Posts