Il s'agit simplement d'une simple démonstration pour avoir une compréhension de base du fonctionnement de Docker tout en travaillant étape par étape. J'ai appris Docker comme celui-ci et créé ce dépôt pour résoudre certains problèmes que j'ai rencontrés au cours de mon expérience d'apprentissage afin qu'il puisse aider d'autres débutants. J'espère que vous apprécierez apprendre. Si vous l'aimez, donnez-lui un sur GitHub et soutenez mon travail.
Important : - En voyant la taille du fichier Lisez-moi, vous pourriez avoir des doutes, mais, pour être honnête, si vous travaillez dès le début, vous ne rencontrerez aucun problème et vous apprendrez en cours de route.
Wikipédia définit Docker comme
est un ensemble de produits de plateforme en tant que service (PaaS) qui utilisent la virtualisation au niveau du système d'exploitation pour fournir des logiciels dans des packages appelés conteneurs. Les conteneurs sont isolés les uns des autres et regroupent leurs logiciels, bibliothèques et fichiers de configuration ; ils peuvent communiquer entre eux via des canaux bien définis. Tous les conteneurs sont gérés par un seul noyau de système d'exploitation et utilisent donc moins de ressources que les machines virtuelles.
Docker vous aide à déployer plus efficacement vos applications dans un bac à sable (appelé conteneurs) pour s'exécuter sur le système d'exploitation hôte, c'est-à-dire Mac. Le principal avantage de Docker est qu’il vous permet de regrouper un logiciel avec toutes ses dépendances dans une seule unité standardisée.
Le conteneur est une solution permettant de faire fonctionner le logiciel sans aucun problème lorsqu'il est déplacé d'un environnement informatique à un autre. Cela peut provenir d'un environnement de test vers la production ou peut-être d'un ordinateur portable vers un autre ordinateur portable avec un autre système d'exploitation.
Les conteneurs fournissent un mécanisme de packaging logique dans lequel vos applications peuvent être extraites de l'environnement dans lequel elles s'exécutent. La principale différence est que chaque conteneur ne nécessite pas son système d’exploitation à part entière. Tous les conteneurs sur un seul hôte partageant un seul système d'exploitation. Cela permet de libérer d’énormes quantités de ressources système telles que le processeur et la RAM.
Une fois que vous avez terminé d'installer Docker, testez votre installation Docker en exécutant ce qui suit :
docker run hello-world
Hello from Docker.
This message shows that your installation appears to be working correctly.
...Dockerfile est un document texte qui contient toutes les commandes que vous pouvez appeler sur la ligne de commande pour créer une image. Créez un fichier hello.js et copiez-y ce code. Ici, nous avons écrit un simple code JS pour afficher Hello World sur localhost:8888 . var http = require( " http " ) ;
http.createServer(function (request, response) {
response.writeHead(200, { ' Content-Type ' : ' text/plain ' }) ;
response.end( ' Hello Worldn ' ) ;
}).listen(8888) ;
// Console will print the message
console.log( ' Server running at http://127.0.0.1:8888/ ' ) ;Dockerfile et copiez-y ce code. FROM node:8
LABEL maintainer= " [email protected] "
RUN npm install
ADD hello.js /hello.js
EXPOSE 8888
ENTRYPOINT [ " node " , " hello.js " ]Même s'il s'agit du premier Dockerfile que vous voyez, je dirais que vous pouvez avoir une bonne idée de ce qui se passe ici. Les instructions Dockerfile sont FROM, ENV, LABEL, RUN , ADD , EXPOSE et ENTRYPOINT ; ils sont en majuscules mais c'est une convention, pas une exigence.
À un niveau élevé, ce Dockerfile donne des instructions telles que Démarrer avec l'image du nœud, ajouter “[email protected]” en tant que responsable, exécuter npm install pour installer les dépendances, copier le fichier dans le code de l'application, documenter le port réseau de l'application, et définissez hello.js comme application par défaut à exécuter.
Nous allons maintenant créer une image Docker sur notre machine locale. Ouvrez votre terminal dans le dossier du projet en cours et exécutez
docker build -t helloworld . Ici, vous demandez à Docker de créer une image appelée helloworld basée sur le contenu du répertoire actuel (notez le point (.) à la fin de la commande build). Docker recherchera le Dockerfile dans le répertoire et construira l'image en fonction des instructions du fichier.
Après avoir créé l'image Docker, l'étape suivante consisterait à exécuter l'image et à voir si elle fonctionne :
docker run -p 8888:8888 helloworldLa commande que nous venons d'exécuter utilisait le port 8888 pour le serveur à l'intérieur du conteneur et l'exposait en externe sur le port 8888. Rendez-vous sur l'URL avec le port 8888 :
Bravo! Vous avez créé avec succès votre première image Docker.
Les images Docker sont comme des modèles de machines virtuelles et sont utilisées pour démarrer des conteneurs. Sous le capot, ils sont constitués d’un ou plusieurs calques en lecture seule qui, une fois empilés, constituent l’image globale. Docker se charge d'empiler ces couches et de les représenter comme un seul objet unifié. Remarque : les images Docker sont immuables, ce qui signifie que les images Docker ne peuvent jamais changer. Une fois que vous en avez créé un, vous pouvez le supprimer, mais vous ne pouvez pas le modifier.
L'image Docker contient tous les fichiers que vous avez empaquetés, qui deviennent le système de fichiers du conteneur - et elle contient également de nombreuses métadonnées sur l'image elle-même. Cela comprend un bref historique de la façon dont l’image a été construite. Vous pouvez l'utiliser pour voir chaque calque de l'image et la commande qui a créé le calque. Vous pouvez vérifier l’historique de l’image helloworld en utilisant :
docker image history helloworld
IMAGE CREATED CREATED BY COMMENT
cb84eb33ca20 58 seconds ago /bin/sh -c # (nop) ENTRYPOINT ["node" "hello…
7d652a817a9f 58 seconds ago /bin/sh -c # (nop) EXPOSE 8888
334575e947c9 59 seconds ago /bin/sh -c # (nop) ADD file:b9606ef53b832e66e… Les commandes CREATED BY sont les instructions Dockerfile – il existe une relation un-à-un, donc chaque ligne du Dockerfile crée une couche d'image.
Tout d'abord, vous devez vous connecter avec votre compte dockerhub en
docker login --username $dockerIdMaintenant que vous êtes connecté, vous pouvez transférer des images vers votre compte ou vers toute organisation à laquelle vous avez accès. Si vous n'êtes membre d'aucune organisation, vous pouvez uniquement transférer des images vers les référentiels de votre compte.
Nous avons construit une image Docker appelée helloworld . Cette référence d'image n'a pas de nom de compte, nous ne pouvons donc la transmettre à aucun registre. Nous n'avons cependant pas besoin de reconstruire l'image pour lui donner une nouvelle référence, les images peuvent avoir plusieurs références. Marquez votre image comme ceci :
docker image tag helloworld $dockerId /helloworld:v1Nous avons maintenant une référence d'image avec notre identifiant Docker dans le nom du compte, et nous nous sommes connectés à Docker Hub, nous sommes donc prêts à partager notre image ! La commande docker image push est le pendant de la commande pull, elle télécharge nos couches d'images locales dans le registre :
docker image push championshuttler/helloworld:v1
The push refers to a repository [docker.io/championshuttler/helloworld]
9519a21ac374: PushedNous pouvons mettre n'importe quelle chaîne dans une balise d'image Docker et, comme nous l'avons déjà vu, vous pouvez avoir plusieurs balises pour la même image. Nous l'utiliserons pour versionner le logiciel dans nos images et permettre aux utilisateurs de faire des choix éclairés sur ce qu'ils n'utiliseront pas - et pour faire nos propres choix éclairés lorsque nous utilisons les images d'autres personnes.
De nombreux projets logiciels utilisent un schéma de version numérique avec des points décimaux pour indiquer l'ampleur du changement entre les versions, et vous pouvez le suivre avec vos balises d'image. L'idée de base est quelque chose comme [major].[minor].[patch], qui a des garanties implicites. Une version qui incrémente uniquement le numéro de correctif peut contenir des corrections de bugs mais doit avoir les mêmes fonctionnalités que la dernière version ; une version qui incrémente la version mineure peut ajouter des fonctionnalités mais ne devrait en supprimer aucune ; une version majeure pourrait avoir des fonctionnalités complètement différentes.
La plupart des applications ne s'exécutent pas dans un seul composant. Même les anciennes applications volumineuses sont généralement conçues sous forme de composants front-end et back-end, qui sont des couches logiques distinctes exécutées dans des composants physiquement distribués. Docker est parfaitement adapté à l'exécution d'applications distribuées, des monolithes à n niveaux aux microservices modernes. Chaque composant s'exécute dans son conteneur léger et Docker les connecte à l'aide de protocoles réseau standard. Vous définissez et gérez des applications multi-conteneurs comme celle-ci à l'aide de Docker Compose. Docker Compose est un outil permettant de définir et d'exécuter des applications Docker multi-conteneurs. Avec Compose, vous utilisez un fichier YAML pour configurer les services de votre application. Ensuite, avec une seule commande, nous créons et démarrons tous les services à partir de votre configuration.
Le fichier Docker Compose décrit l'état souhaité de votre application - à quoi elle devrait ressembler lorsque tout est en cours d'exécution. Il s'agit d'un format de fichier simple dans lequel vous capturez toutes les options que vous mettriez dans les commandes d'exécution de votre conteneur Docker dans le fichier Compose. Ensuite, vous utilisez l'outil Docker Compose pour exécuter l'application. Il détermine les ressources Docker dont il a besoin (qui peuvent être des conteneurs, des réseaux ou des volumes) et envoie des requêtes à l'API Docker pour les créer. Le nom par défaut du fichier Compose YAML est docker-compose.yml . Cependant, nous pouvons utiliser l'indicateur -f pour spécifier des noms de fichiers personnalisés.
Commençons.
Ci-dessous, le code montre un fichier Docker Compose très simple qui définit une petite application Flask avec deux services (interface Web et Redis). L'application est un simple serveur Web qui compte le nombre de visites et stocke la valeur dans Redis.
version: " 3.5 "
services:
web-frontend:
build: .
command: python app.py
ports:
- target: 8888
published: 8888
networks:
- counter-net
volumes:
- type: volume
source: counter-vol
target: /code
redis:
image: " redis:alpine "
networks:
counter-net:
networks:
counter-net:
volumes:
counter-vol: La clé version est nécessaire et doit toujours figurer sur la première ligne du fichier. Ceci explique la version du format Compose file (essentiellement l'API).
La clé services de niveau supérieur est l'endroit où nous définissons les différents services d'application. L'exemple que nous utilisons définit deux services ; une interface Web appelée web-frontend et une base de données en mémoire appelée Redis. Compose déploiera chacun de ces services en tant que conteneur.
La clé networks de niveau supérieur indique à Docker de créer de nouveaux réseaux. Par défaut, Compose créera des réseaux de ponts. Il s'agit de réseaux à hôte unique qui ne peuvent connecter que des conteneurs sur le même hôte.
Dans la définition du service web-frontend, nous donnons à Docker les instructions suivantes :
Nous allons déployer l'application définie dans le fichier Compose de la section précédente. Pour ce faire, vous aurez besoin des 4 fichiers suivants provenant de https://github.com/championshuttler/counter-app :
Clonez le dépôt Git localement.
git clone https://github.com/championshuttler/counter-app.gitDécrivons rapidement chaque fichier :
app.py est le code de l'application (une application Python Flask).docker-compose.yml est le fichier Docker Compose qui décrit comment Docker doit déployer l'application.Dockerfile décrit comment créer l'image pour le service d'interface Web.requirements.txt répertorie les packages Python requis pour l'application. Utilisons Compose pour afficher l'application. Vous devez exécuter toutes ces commandes suivantes à partir du répertoire counter-app :
docker-compose up &L'application prendra quelques secondes pour apparaître et le résultat peut être assez détaillé.
Une fois l'application déployée avec succès, vous pouvez pointer un navigateur Web vers votre hôte Docker sur port 5000 et voir l'application dans toute sa splendeur.
Avez-vous trouvé le tutoriel complètement en désordre ou vous êtes-vous amusé et avez-vous appris quelque chose ? Envoyez-moi directement vos réflexions ou créez simplement un problème. Retrouvez-moi également sur Twitter, n'hésitez pas à me demander si vous avez des doutes.
J'aimerais connaître votre expérience avec ce tutoriel. J'espère que vous avez apprécié apprendre. Si vous l'aimez, donnez-lui un message sur GitHub et soutenez mon travail.
