Technical Tutorials

L'un des défis les plus persistants en ingénierie logicielle moderne est le syndrome « ça marche sur ma machine ». À mesure que les projets Python deviennent complexes, la gestion des dépendances entre les environnements de développement local et les pipelines d'intégration continue/déploiement continu (CI/CD) devient de plus en plus critique. Des environnements incohérents entraînent des tests instables, des échecs de déploiement et une perte d'heures de travail pour les ingénieurs.

Dans cet article, nous explorerons comment combiner Python Poetry pour la gestion des dépendances avec Docker pour l'isolation des environnements. En tirant parti de ces outils ensemble, nous pouvons créer un flux de travail robuste qui garantit que votre environnement de développement local reflète précisément les étapes de production et de CI/CD.

Les problèmes avec la gestion standard des dépendances

Traditionnellement, les développeurs utilisent requirements.txt ou pip pour gérer les packages. Bien que simple, cette approche ignore souvent les dépendances au niveau du système (comme les compilateurs C ou des bibliothèques spécifiques) et les comportements spécifiques à l'OS. Poetry résout le problème de résolution des dépendances en utilisant un fichier pyproject.toml et un fichier de verrouillage (poetry.lock), mais il s'exécute toujours sur l'OS hôte. Si votre exécuteur CI/CD utilise Ubuntu 22.04 mais que vous développez sur macOS, des différences subtiles dans les dépendances binaires ou les versions de bibliothèques peuvent provoquer des problèmes.

Pour vraiment isoler les environnements, nous avons besoin de la conteneurisation. Docker fournit une couche d'abstraction qui encapsule le système d'exploitation, les bibliothèques et le code de l'application, garantissant la cohérence quelle que soit la machine hôte sous-jacente.

Structure du projet et configuration

Commençons par mettre en place une structure de projet Python standard en utilisant Poetry. Tout d'abord, initialisez votre projet :

poetry new my-reproducible-app
cd my-reproducible-app

Ajoutez les dépendances de votre projet. Pour cet exemple, supposons que nous ayons besoin de requests et pytest :

poetry add requests
poetry add --group dev pytest

Crucialement, Poetry génère un fichier poetry.lock. Ce fichier épingle chaque version spécifique de chaque dépendance, garantissant que quiconque clone le dépôt obtient exactement les mêmes versions de packages.

Construction de l'environnement Docker

Maintenant, créons un Dockerfile qui utilise le fichier de verrouillage généré par Poetry. L'astuce ici est d'éviter d'installer les dépendances à chaque construction. Nous utilisons des constructions multi-étapes ou une mise en cache soigneuse des couches pour maintenir des constructions rapides.

Voici un Dockerfile optimisé pour le développement :

FROM python:3.11-slim AS base

WORKDIR /app

# Installer Poetry à l'intérieur du conteneur
RUN pip install --no-cache-dir poetry

# Copier uniquement le fichier de verrouillage en premier pour tirer parti de la mise en cache des couches Docker
COPY pyproject.toml poetry.lock ./

# Installer les dépendances dans un environnement virtuel
RUN poetry config virtualenvs.in-project true \
    && poetry install --no-interaction --no-ansi

# Copier le reste du code de l'application
COPY . .

# Commande pour exécuter l'application ou les tests
CMD ["poetry", "run", "python", "-m", "my_app"]

Remarquez l'utilisation de poetry install sans le drapeau --no-dev. Pour le développement local, nous voulons que toutes les dépendances de développement (comme les linters et les lanceurs de tests) soient disponibles. Cependant, pour CI/CD, nous modifierons cela légèrement.

Isoler les dépendances CI/CD

Les pipelines CI/CD ont des exigences différentes du développement local. Vous ne voulez généralement pas d'invites interactives, et vous n'avez peut-être pas besoin de plugins IDE ou d'outils de linter local dans le conteneur final. Nous pouvons gérer cela en passant des arguments de construction ou en utilisant des services Docker Compose séparés.

Pour une étape semblable à la production dans votre pipeline CI/CD (par exemple, GitHub Actions ou GitLab CI), vous pouvez utiliser une construction multi-étapes pour éliminer les dépendances de développement inutiles :

FROM python:3.11-slim AS builder
WORKDIR /app
COPY pyproject.toml poetry.lock ./
RUN pip install --no-cache-dir poetry \
    && poetry config virtualenvs.in-project true \
    && poetry install --no-dev --no-interaction --no-ansi

FROM python:3.11-slim
WORKDIR /app
COPY --from=builder /app/.venv .venv
COPY --from=builder /app /app
ENV PATH="/app/.venv/bin:$PATH"

CMD ["python", "-m", "my_app"]

Cette approche garantit que l'image finale s'exécutant en production ou dans les tests d'intégration est légère et ne contient que les dépendances d'exécution, réduisant ainsi la surface d'attaque et la taille de l'image.

Flux de travail pratique pour les développeurs

Pour rendre ce flux de travail transparent, configurez votre terminal local pour utiliser l'environnement virtuel de Poetry automatiquement. Lorsque vous exécutez poetry shell, il active l'environnement au sein du projet. Combiné avec Docker, vous pouvez exécuter vos tests locaux à l'intérieur du conteneur pour garantir la parité :

docker-compose run --rm app poetry run pytest

Cette commande démarre le conteneur défini dans votre configuration Docker Compose, exécute les tests, puis supprime le conteneur. Elle garantit que vos résultats de test ne sont pas influencés par les packages installés globalement sur votre machine.

Conclusion

En intégrant Poetry pour une résolution précise des dépendances avec Docker pour l'isolation de l'environnement, les développeurs peuvent éliminer les frictions entre les environnements locaux et CI/CD. Cette configuration améliore non seulement la fiabilité de vos pipelines CI/CD, mais simplifie également l'intégration des nouveaux membres de l'équipe. Plus de débogage de bugs spécifiques à l'environnement — juste une exécution de code propre et reproductible.

Adopter ce modèle est une étape significative vers des pratiques DevOps matures. Commencez par conteneuriser votre environnement de développement dès aujourd'hui, et voyez votre confiance dans les déploiements s'envoler.