Conteneuriser une application Python

Table des matières

Prérequis

Vous avez installé la dernière version de Docker Desktop.
Vous disposez d'un client git. Les exemples de cette section utilisent un client git en ligne de commande, mais vous pouvez utiliser n'importe quel client.

Aperçu

Cette section vous guide à travers la conteneurisation et l'exécution d'une application Python.

Obtenir l'application exemple

L'application exemple utilise le framework populaire FastAPI.

Clonez l'application exemple pour l'utiliser avec ce guide. Ouvrez un terminal, placez-vous dans le répertoire de votre choix et exécutez la commande suivante pour cloner le dépôt :

$ git clone https://github.com/estebanx64/python-docker-example && cd python-docker-example

Initialiser les ressources Docker

Maintenant que vous avez une application, vous pouvez créer les ressources Docker nécessaires pour la conteneuriser. Vous pouvez utiliser la fonctionnalité intégrée Docker Init de Docker Desktop pour vous aider à rationaliser le processus, ou vous pouvez créer manuellement les ressources.

À l'intérieur du répertoire python-docker-example, exécutez la commande docker init. docker init fournit une configuration par défaut, mais vous devrez répondre à quelques questions sur votre application. Par exemple, cette application utilise FastAPI pour s'exécuter. Référez-vous à l'exemple suivant pour répondre aux invites de docker init et utilisez les mêmes réponses pour vos invites.

$ docker init
Bienvenue dans le CLI Docker Init !

Cet utilitaire vous guidera dans la création des fichiers suivants avec des valeurs par défaut pertinentes pour votre projet :
  - .dockerignore
  - Dockerfile
  - compose.yaml
  - README.Docker.md

Commençons !

? Quelle plateforme d'application votre projet utilise-t-il ? Python
? Quelle version de Python voulez-vous utiliser ? 3.11.4
? Sur quel port voulez-vous que votre application écoute ? 8000
? Quelle est la commande pour exécuter votre application ? python3 -m uvicorn app:app --host=0.0.0.0 --port=8000

Créez un fichier nommé .gitignore avec le contenu suivant.

.gitignore

# Fichiers compilés en byte-code / optimisés / DLL
__pycache__/
*.py[cod]
*$py.class

# Extensions C
*.so

# Distribution / empaquetage
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST

# Rapports de test unitaire / couverture
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
*.py,cover
.hypothesis/
.pytest_cache/
cover/

# PEP 582 ; utilisé par ex. github.com/David-OConnor/pyflow et github.com/pdm-project/pdm
__pypackages__/

# Environnements
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/

Si vous n'avez pas Docker Desktop installé ou si vous préférez créer les ressources manuellement, vous pouvez créer les fichiers suivants dans le répertoire de votre projet.

Créez un fichier nommé Dockerfile avec le contenu suivant.

Dockerfile

# syntax=docker/dockerfile:1

# Des commentaires sont fournis tout au long de ce fichier pour vous aider à démarrer.
# Si vous avez besoin de plus d'aide, consultez le guide de référence Dockerfile à l'adresse
# https://docs.docker.com/go/dockerfile-reference/

# Vous voulez nous aider à améliorer ce modèle ? Partagez vos commentaires ici : https://forms.gle/ybq9Krt8jtBL3iCk7

ARG PYTHON_VERSION=3.11.4
FROM python:${PYTHON_VERSION}-slim AS base

# Empêche Python d'écrire des fichiers pyc.
ENV PYTHONDONTWRITEBYTECODE=1

# Empêche Python de mettre en mémoire tampon stdout et stderr pour éviter les situations où
# l'application plante sans émettre de journaux en raison de la mise en mémoire tampon.
ENV PYTHONUNBUFFERED=1

WORKDIR /app

# Crée un utilisateur non privilégié sous lequel l'application s'exécutera.
# Voir https://docs.docker.com/go/dockerfile-user-best-practices/
ARG UID=10001
RUN adduser \
    --disabled-password \
    --gecos "" \
    --home "/nonexistent" \
    --shell "/sbin/nologin" \
    --no-create-home \
    --uid "${UID}" \
    appuser

# Télécharge les dépendances dans une étape séparée pour profiter de la mise en cache de Docker.
# Utilise un montage de cache sur /root/.cache/pip pour accélérer les constructions ultérieures.
# Utilise un montage bind sur requirements.txt pour éviter d'avoir à les copier dans
# cette couche.
RUN --mount=type=cache,target=/root/.cache/pip \
    --mount=type=bind,source=requirements.txt,target=requirements.txt \
    python -m pip install -r requirements.txt

# Passe à l'utilisateur non privilégié pour exécuter l'application.
USER appuser

# Copie le code source dans le conteneur.
COPY . .

# Expose le port sur lequel l'application écoute.
EXPOSE 8000

# Exécute l'application.
CMD python3 -m uvicorn app:app --host=0.0.0.0 --port=8000

Créez un fichier nommé compose.yaml avec le contenu suivant.

compose.yaml

# Des commentaires sont fournis tout au long de ce fichier pour vous aider à démarrer.
# Si vous avez besoin de plus d'aide, consultez le guide de référence de Docker Compose à l'adresse
# https://docs.docker.com/go/compose-spec-reference/

# Ici, les instructions définissent votre application comme un service appelé "server".
# Ce service est construit à partir du Dockerfile dans le répertoire courant.
# Vous pouvez ajouter d'autres services dont votre application peut dépendre ici, comme une
# base de données ou un cache. Pour des exemples, consultez le dépôt Awesome Compose :
# https://github.com/docker/awesome-compose
services:
  server:
    build:
      context: .
    ports:
      - 8000:8000

Créez un fichier nommé .dockerignore avec le contenu suivant.

.dockerignore

# Incluez ici tous les fichiers ou répertoires que vous ne voulez pas copier dans votre
# conteneur (par exemple, les artefacts de construction locaux, les fichiers temporaires, etc.).
#
# Pour plus d'aide, consultez le guide de référence du fichier .dockerignore à l'adresse
# https://docs.docker.com/go/build-context-dockerignore/

**/.DS_Store
**/__pycache__
**/.venv
**/.classpath
**/.dockerignore
**/.env
**/.git
**/.gitignore
**/.project
**/.settings
**/.toolstarget
**/.vs
**/.vscode
**/*.*proj.user
**/*.dbmdl
**/*.jfm
**/bin
**/charts
**/docker-compose*
**/compose.y*ml
**/Dockerfile*
**/node_modules
**/npm-debug.log
**/obj
**/secrets.dev.yaml
**/values.dev.yaml
LICENSE
README.md

Créez un fichier nommé .gitignore avec le contenu suivant.

.gitignore

# Fichiers compilés en byte-code / optimisés / DLL
__pycache__/
*.py[cod]
*$py.class

# Extensions C
*.so

# Distribution / empaquetage
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST

# Rapports de test unitaire / couverture
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
*.py,cover
.hypothesis/
.pytest_cache/
cover/

# PEP 582 ; utilisé par ex. github.com/David-OConnor/pyflow et github.com/pdm-project/pdm
__pypackages__/

# Environnements
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/

You should now have the following contents in your python-docker-example directory.

├── python-docker-example/
│ ├── app.py
│ ├── requirements.txt
│ ├── .dockerignore
│ ├── .gitignore
│ ├── compose.yaml
│ ├── Dockerfile
│ └── README.md

To learn more about the files, see the following:

Run the application

Inside the python-docker-example directory, run the following command in a terminal.

$ docker compose up --build

Open a browser and view the application at http://localhost:8000. You should see a simple FastAPI application.

In the terminal, press ctrl+c to stop the application.

Run the application in the background

You can run the application detached from the terminal by adding the -d option. Inside the python-docker-example directory, run the following command in a terminal.

$ docker compose up --build -d

Open a browser and view the application at http://localhost:8000.

To see the OpenAPI docs you can go to http://localhost:8000/docs.

You should see a simple FastAPI application.

In the terminal, run the following command to stop the application.

$ docker compose down

For more information about Compose commands, see the Compose CLI reference.

Summary

In this section, you learned how you can containerize and run your Python application using Docker.

Related information:

Docker Compose overview

Next steps

In the next section, you'll take a look at how to set up a CI pipeline using GitHub Actions.