Exécution d'application personnalisée dans un conteneur Docker avec port personnalisé

Introduction

Docker est une plateforme puissante pour construire, déployer et exécuter des applications dans un environnement conteneurisé. Dans ce tutoriel, vous apprendrez à exécuter une application personnalisée dans un conteneur Docker et à exposer un port personnalisé pour un accès externe. À la fin de ce guide, vous aurez une compréhension solide de la manière d'utiliser Docker pour déployer vos applications avec plus de flexibilité et de contrôle.

Introduction à Docker et aux conteneurs

Docker est une plateforme open-source populaire qui permet le développement, le déploiement et la gestion d'applications à l'aide de conteneurs. Les conteneurs sont des paquets logiciels légers, autonomes et exécutables qui incluent tout ce dont une application a besoin pour fonctionner, y compris le code, l'environnement d'exécution, les outils système et les bibliothèques.

Qu'est-ce que Docker ?

Docker est un outil conçu pour faciliter la création, le déploiement et l'exécution d'applications à l'aide de conteneurs. Les conteneurs permettent à un développeur d'emballer une application avec toutes les parties nécessaires, telles que les bibliothèques et autres dépendances, et de la distribuer comme un seul paquet.

Avantages de l'utilisation de Docker

Cohérence : Les conteneurs garantissent que votre application fonctionnera de la même manière, quel que soit l'environnement dans lequel elle est déployée.
Scalabilité : Les conteneurs peuvent être facilement mis à l'échelle pour répondre aux besoins de votre application.
Portabilité : Les conteneurs peuvent être exécutés sur n'importe quel système disposant de Docker installé, ce qui facilite le déplacement de votre application entre différents environnements.
Efficacité : Les conteneurs sont légers et utilisent moins de ressources que les machines virtuelles, ce qui les rend plus efficaces à exécuter.

Architecture Docker

Docker utilise une architecture client-serveur, où le client Docker communique avec le démon Docker, responsable de la création, de l'exécution et de la distribution des conteneurs Docker.

graph LR
    subgraph Docker Architecture
        client((Client Docker))
        daemon((Démon Docker))
        registry((Registre Docker))
        client --> daemon
        daemon --> registry
    end

Conteneurs Docker

Les conteneurs Docker sont les blocs de construction de base de Docker. Un conteneur est une unité logicielle standard qui regroupe le code et toutes ses dépendances, afin que l'application fonctionne rapidement et de manière fiable d'un environnement informatique à un autre.

graph LR
    subgraph Conteneur Docker
        app((Application))
        runtime((Environnement d'exécution))
        libs((Bibliothèques))
        bin((Fichiers binaires))
    end

Images Docker

Les images Docker sont la base des conteneurs. Une image est un paquet logiciel léger, autonome et exécutable qui inclut tout ce qui est nécessaire pour exécuter une application : le code, un environnement d'exécution, des bibliothèques, des variables d'environnement et des fichiers de configuration.

Exécution d'une application personnalisée dans Docker

Création d'une image Docker personnalisée

Pour exécuter une application personnalisée dans un conteneur Docker, vous devez d'abord créer une image Docker pour votre application. Cela peut être fait à l'aide d'un Dockerfile, qui est un document texte contenant toutes les commandes qu'un utilisateur pourrait appeler en ligne de commande pour assembler une image.

Voici un exemple de Dockerfile pour une application web Flask simple :

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python", "app.py"]

Ce Dockerfile :

Démarre à partir de l'image de base python:3.9-slim
Définit le répertoire de travail à /app
Copie le fichier requirements.txt et installe les packages Python requis
Copie le code de l'application dans le conteneur
Spécifie la commande pour exécuter l'application (python app.py)

Construction et exécution de l'image Docker

Une fois que vous avez le Dockerfile, vous pouvez construire l'image Docker à l'aide de la commande docker build :

docker build -t my-flask-app .

Cela créera une nouvelle image Docker avec l'étiquette my-flask-app.

Pour exécuter l'application dans un conteneur Docker, utilisez la commande docker run :

docker run -p 5000:5000 my-flask-app

Cela démarrera un nouveau conteneur basé sur l'image my-flask-app et mappera le port 5000 de l'hôte au port 5000 dans le conteneur.

Vérification de l'application

Vous pouvez maintenant accéder à l'application en cours d'exécution dans votre navigateur web en visitant http://localhost:5000. Vous devriez voir la sortie de votre application Flask.

Exposition d'un port personnalisé

Par défaut, lorsqu'un conteneur Docker est exécuté, il est isolé du système hôte et de son réseau. Si votre application s'exécute sur un port spécifique à l'intérieur du conteneur, vous devez exposer ce port au système hôte pour pouvoir accéder à l'application depuis l'extérieur du conteneur.

Exposition d'un port

Pour exposer un port depuis un conteneur Docker, vous pouvez utiliser l'option -p ou --publish lors de l'exécution de la commande docker run. La syntaxe est la suivante :

docker run -p <port_hôte>:<port_conteneur> <nom_image>

Par exemple, si votre application s'exécute sur le port 8000 à l'intérieur du conteneur, vous pouvez l'exposer au port 80 du système hôte comme ceci :

docker run -p 80:8000 my-app

Cela mappera le port 80 du système hôte au port 8000 à l'intérieur du conteneur.

Vérification du port exposé

Vous pouvez vérifier que le port a bien été exposé en vérifiant la sortie de la commande docker run, qui devrait afficher les ports mappés :

$ docker run -p 80:8000 my-app
 * Running on http://0.0.0.0:8000/ (Press CTRL+C to quit)

Alternativement, vous pouvez utiliser la commande docker port pour lister les ports mappés pour un conteneur en cours d'exécution :

$ docker port <id_conteneur>
8000/tcp -> 0.0.0.0:80

Cela indique que le port 8000 à l'intérieur du conteneur est mappé au port 80 sur le système hôte.

Vous pouvez maintenant accéder à votre application en visitant http://localhost (ou l'adresse IP du système hôte) dans votre navigateur web.

Résumé

Dans ce tutoriel, vous avez appris à exécuter une application personnalisée dans un conteneur Docker et à exposer un port personnalisé pour un accès externe. En conteneurisant votre application, vous pouvez garantir des déploiements cohérents et fiables, ainsi que la possibilité de mettre à l'échelle et de gérer votre application plus efficacement. La technologie de conteneurisation de Docker fournit une plateforme puissante aux développeurs pour construire, déployer et exécuter leurs applications de manière plus fluide et efficace.

Comment exécuter une application personnalisée dans un conteneur Docker avec un port personnalisé