Il est vraiment facile de créer une image Docker personnalisée à partir d'images Docker existantes en utilisant Dockerfile. Habituellement, les gens utilisent une image de base minimale telle que alpin ou Ubuntu / Debian Dans ce but. Disons que vous souhaitez créer une image Docker personnalisée de votre application Web préférée écrite dans Nodejs. L'application s'exécutera sur le port 8080. Par défaut, vous ne pourrez pas accéder à l'application Web sur le port 8080 de votre machine hôte. Vous devrez dire à Docker que vous souhaitez exposer ou ouvrir le port 8080 Pour pouvoir y accéder depuis votre machine hôte.

Dans cet article, je vais vous montrer comment exposer les ports en utilisant Dockerfile avec un exemple du monde réel. Commençons.

Création d'un répertoire de projet:

Tout d'abord, nous devons créer un répertoire de projet. Dans ce répertoire, vous devez conserver tous les fichiers du projet et un Dockerfile.

Exécutez la commande suivante pour créer un répertoire de projet myApp / Dans le répertoire personnel de vos utilisateurs et y accéder:

$ mkdir ~ / myapp && cd ~ / myApp

Préparer l'application Web:

Créez maintenant un répertoire src / à l'intérieur de ~ / myApp / Répertoire avec la commande suivante:

$ mkdir src

Dans le src / répertoire, tout le code source de mon application NodeJS sera conservé.

Je vais juste créer un simple appliquer.js fichier dans le src / répertoire et exécuter un serveur Web simple sur le port 8080 Juste pour la démonstration.

Le src / application.js Le fichier contient les lignes de codes suivantes:

Écrire Dockerfile et exposer les ports:

Créez maintenant un Dockerfile dans le ~ / MyApp Répertoire avec la commande suivante:

$ touch dockerfile

Tapez maintenant les lignes suivantes vers le Dockerfile Et sauvegard. Je vais discuter de ce que ces lignes signifient plus tard.

Ici, De Alpine: 3.8 signifie, utilisez le Alpine: 3.8 Image Docker comme base de la nouvelle image que nous construions à partir de ce Dockerfile.

Exécuter la mise à jour APK signifie, exécuter le mise à jour APK commande dans l'image docker de base Alpine: 3.8.

Exécutez APK ADD -NO-CACH NODEJS signifie, exécuter le apk ajouter commande pour installer le langage de programmation NodeJS dans le Alpine: 3.8 Image de base docker.

COPIE ./ src / application signifie, copiez tous les fichiers de la ~ / myapp / src répertoire au / application Répertoire de la nouvelle image Docker que nous allons construire en utilisant le Dockerfile.

Cmd [«/ usr / bin / nœud», «/ app / app.js ”] signifie, exécuter le / App / App.js fichier du nouveau conteneur à l'aide nœud binaire situé dans / usr / bin / nœud.

Enfin, pour Exposer 8080 / TCP signifie, exposer ou ouvrir le port TCP 8080 à l'ordinateur hôte.

Création d'images Docker personnalisées à l'aide de Dockerfile:

Maintenant, faisons une image Docker personnalisée nœud alpin: v1 en utilisant le Dockerfile que nous venons de créer.

Assurez-vous d'abord que vous êtes dans le ~ / myApp / Répertoire puis exécutez la commande suivante pour créer votre image Docker personnalisée nœud alpin: v1:

$ docker build -t-nœud alpin: v1 .

Comme vous pouvez le voir, l'image Docker personnalisée nœud alpin: v1 est créé. L'image et les packages de base requis sont tirés d'Internet.

Comme vous pouvez le voir, l'image Docker personnalisée nœud alpin: v1 est créé avec succès.

Test de l'image Docker personnalisée:

Maintenant, nous pouvons tester l'image Docker personnalisée nœud alpin: v1 très facilement. Tout ce que nous avons à faire est de créer un conteneur à partir de nœud alpin: v1 image.

Exécutez la commande suivante pour créer un conteneur Docker www du nœud alpin: v1 Image Docker:

$ docker run -d -it --name www alpine-node: v1

Le récipient www est créé.

Découvrons maintenant l'adresse IP du www Conteneur Docker avec la commande suivante:

$ docker inspecter www | adresse grep

Comme vous pouvez le voir, dans mon cas, l'adresse IP est 172.17.0.3. Ainsi, l'application NodeJS que j'ai écrite devrait être accessible à partir du navigateur Web du port 8080 de cette adresse IP.

Tour! Je peux accéder au port 8080 de mon www Récipient Docker.

C'est essentiellement la façon dont vous exposez certains ports dans vos images Docker personnalisées que vous construirez en utilisant Dockerfile.

Exposer les ports TCP et UDP à l'aide de Dockerfile:

Dans la section précédente de cet article, je vous ai montré comment exposer un port TCP à l'aide d'un Dockerfile.

Vous pouvez facilement exposer un port TCP (disons le port TCP 53) dans ton Dockerfile avec la ligne suivante:

Exposer 53 / TCP

Vous pouvez également exposer un port UDP (disons le port UDP 53) avec la ligne suivante dans votre Dockerfile:

Exposer 53 / UDP

Vous pouvez exposer le port TCP et UDP en même temps avec les lignes suivantes dans votre Dockerfile:

Exposer 53 / TCP
Exposer 53 / UDP

Si vous ne spécifiez pas quel protocole (TCP ou UDP) à utiliser, TCP est utilisé par défaut. Par exemple, si vous écrivez la ligne suivante dans votre Dockerfile:

Exposer 53

Alors docker supposera que vous souhaitez utiliser le port TCP 53.

Exposer plusieurs ports à l'aide de dockerfile:

Disons que vous souhaitez créer une image Docker de pile moyenne personnalisée. Dans ce cas, vous exécuterez un serveur HTTP sur un port (disons TCP Port 80 ou 8080), un serveur FTP qui s'exécute sur le port TCP 21, un serveur de base de données SQL (disons MySQL) qui s'exécute sur TCP Port 3306, ou serveur de base de données NoSQL (disons MongoDB) qui s'exécute sur le port TCP 27017 ou 27018, un serveur SSH qui s'exécute sur le port TCP 22. C'est beaucoup de ports!

La bonne nouvelle est; Vous pouvez exposer autant de ports que besoin de votre image Docker personnalisée créée en utilisant Dockerfile.

Les ports de l'exemple ci-dessus peuvent être exposés avec les lignes suivantes dans votre Dockerfile:

Exposer 80 / TCP
Exposer 8080 / TCP
Exposer 21 / TCP
Exposer 22 / TCP
Exposer 3306 / TCP
Exposer 27017 / TCP
Exposer 27018 / TCP

Si vous le souhaitez, vous pouvez laisser la spécification du protocole comme Docker utilise TCP par défaut et faire la même chose avec les lignes suivantes dans votre Dockerfile:

Exposer 80
Exposer 8080
Exposer 21
Exposer 22
Exposer 3306
Exposer 27017
Exposer 27018

Si vous en avez besoin, vous pouvez mélanger les ports TCP et UDP dans votre Dockerfile. Par exemple, si vous exécutez DNS Server (qui s'exécute sur le port UDP 53), ainsi que l'exemple ci-dessus, vous ajouteriez les lignes suivantes à votre Dockerfile.

Exposer 80
Exposer 8080
Exposer 21
Exposer 22
Exposer 53 / UDP
Exposer 3306
Exposer 27017
Exposer 27018

C'est ainsi que vous exposez les ports en utilisant Dockerfile. En apprendre davantage sur Dockerfile et exposer des ports en utilisant Dockerfile, lis le Dockerfile Guide de référence sur https: // docs.docker.com / moteur / référence / constructeur / # Expose

Merci d'avoir lu cet article.