Conteneuriser une application Python avec Docker

Docker est une solution gratuite et open source permettant de développer, déployer et gérer des applications dans une virtualisation légère au niveau du système d’exploitation. Dans ce guide, nous allons montrer comment créer une application Python dans un conteneur Docker.

Prérequis

Pour suivre les étapes présentées dans ce guide, vous aurez besoin des éléments suivants :

• Un système Linux. Consultez la configuration de votre propre VPS Ubuntu sur CloudSigma.

• La dernière version de Docker installée et configurée. En savoir plus sur l’installation de Docker sur Ubuntu.

Conteneurs Docker

Lorsque plusieurs programmes s’exécutent dans le même environnement, les choses peuvent casser, et finiront souvent par le faire. Plus vous ajoutez de programmes, plus l’environnement devient instable. Cela peut ne pas être très grave pour un usage courant. Toutefois, lorsqu’il s’agit d’applications critiques, les conséquences peuvent être importantes.

Plus le nombre d’applications introduites dans le système est élevé, plus la surface d’attaque augmente. Une seule application compromise peut facilement entraîner la compromission de l’ensemble du système.

Pour résoudre ces problèmes, nous pouvons utiliser des conteneurs Docker afin de créer un isolement logiciel :

• Les applications à l’intérieur du conteneur auront un accès limité aux fichiers.

• Les applications conteneurisées ne peuvent pas voir les autres processus exécutés sur le système.

• Une quantité spécifique de ressources matérielles peut être allouée au conteneur.

• Les ports réseau d’un conteneur ne sont pas exposés à l’extérieur.

• Le packaging reste cohérent pour presque tout, entre les environnements locaux et de production.

Pour la démonstration, nous allons créer un simple serveur Python dans un conteneur Docker, transformer ce conteneur en image, puis déployer l’image dans un environnement de production factice.

Étape 1 – Configuration du système de fichiers

Pour héberger le projet, nous allons d’abord créer un répertoire dédié :

mkdir -pv python-server-container/

cd !$

Dans ce répertoire, créez un sous-répertoire src afin de stocker notre code :

mkdir -pv src/

Étape 2 – Création du serveur Python

Dans cette étape, nous allons créer un simple serveur HTTP en Python. Créez le fichier server.py :

touch server.py

Ouvrez-le dans un éditeur de texte :

nano server.py

Saisissez le code Python suivant :

from http.server import HTTPServer, SimpleHTTPRequestHandler

def run(server_class=HTTPServer, handler_class=SimpleHTTPRequestHandler):
    """server entrypoint"""
    server_address = ("0.0.0.0", 8080)
    httpd = server_class(server_address, handler_class)
    print("starting server...")
    httpd.serve_forever()

if __name__ == "__main__":
    run()

Ici :

• Nous utilisons la classe HTTPServer et demandons un gestionnaire depuis la bibliothèque standard Python, ce qui permet de garder le programme simple.

• La fonction run initialise une instance de HTTPserver.

• Comme le suggèrent les arguments de server_address, le serveur écoutera toute connexion entrante sur le port 8080.

Nous allons maintenant vérifier que le serveur fonctionne comme prévu. Lancez le serveur :

python3 server.py

Depuis un nouveau terminal, nous pouvons utiliser curl pour envoyer une requête au serveur :

curl -iv localhost:8080

Vous pouvez également accéder au lien dans un navigateur web :

http://localhost:8080

Étape 3 – Création d’un Dockerfile

Un Dockerfile contient les instructions nécessaires pour générer une image Docker. Les instructions du fichier sont exécutées séquentiellement. En savoir plus sur Dockerfile.

Créez un nouveau Dockerfile pour notre projet :

touch Dockerfile

Nous allons maintenant y ajouter le code nécessaire. Ouvrez-le dans un éditeur de texte :

nano Dockerfile

Saisissez le code suivant :

FROM python:latest

ENV SRC_DIR /usr/bin/src/test_server/src
COPY src/* ${SRC_DIR}/
WORKDIR ${SRC_DIR}

ENV PYTHONUNBUFFERED=1

CMD ["python", "server.py"]

Ici :

• Tout Dockerfile doit commencer par la directive FROM. Dans notre cas, nous déclarons Python comme base de l’image Docker.

• La directive ENV SRC_DIR indique l’emplacement du répertoire du conteneur.

• La directive COPY copie les fichiers depuis le répertoire src, qui héberge actuellement le serveur Python.

• La variable PYTHONBUFFERED=1 indique que Python imprimera et journalisera la sortie directement vers STDOUT. Sinon, les journaux ne seraient envoyés à aucun tampon.

• La directive CMD spécifie une commande par défaut à exécuter au lancement du conteneur. Dans ce cas, nous l’utilisons pour démarrer notre serveur Python.

Étape 4 – Génération de l’image Docker

Une fois le Dockerfile prêt, nous pouvons créer une image. Exécutez la commande Docker suivante pour démarrer le processus :

docker build . -t python_server

Ici :

• L’option -t est utilisée pour étiqueter notre image Docker sous le nom python_server.

• Docker téléchargera tous les composants nécessaires et les combinera en une image.

Étape 5 – Exécution de l’image

L’image est prête pour le déploiement. Nous pouvons l’exécuter avec la commande suivante :

docker run -p 8080:8080 python_server

Ici, nous transférons le port 8080 de la machine locale vers l’image Docker à l’aide de l’option -p.

Nous pouvons facilement vérifier que le serveur est opérationnel avec curl :

curl -iv localhost:8080

Étape 6 – Arrêt du serveur

Depuis le terminal, appuyez sur “Ctrl + C” pour arrêter le processus Docker :

Étape 7 – Exportation et importation de l’image Docker

Nous disposons maintenant d’une image Docker fonctionnelle hébergeant notre serveur Python. Grâce aux fonctions d’exportation et d’importation de Docker, nous pouvons la migrer vers n’importe quel autre système.

Commencez par vérifier la liste des images Docker sur le système actuel :

docker images

Notre cible est l’image Docker python_server que nous venons de créer. La commande suivante l’exportera sous forme d’archive TAR :

docker save python_server:latest > python_server.tar

Après avoir transféré le fichier python_server.tar vers la machine cible, utilisez la commande suivante pour importer l’image Docker :

docker load < python_server.tar

Conclusion

Dans ce guide, nous avons montré comment créer une image Docker à partir d’une application Python. Nous avons créé un serveur web Python simple, puis construit une image Docker à partir de celui-ci. L’image Docker peut désormais être déployée dans n’importe quel environnement tout en offrant un comportement cohérent.

Vous souhaitez en savoir plus sur Docker ? Consultez les guides suivants :

• Créer et déployer une application Flask avec Docker sur Ubuntu 20.04

• Comment sécuriser et faire évoluer une application Django avec Docker, Nginx et Let’s Encrypt

• Comment déployer WordPress avec des conteneurs Docker sur Ubuntu 20.04

• Partager des données entre conteneurs Docker

Bon computing !