Comment créer une application Node.js avec Docker

De Get Docs
Aller à :navigation, rechercher

Introduction

La plate-forme Docker permet aux développeurs de conditionner et d'exécuter des applications en tant que conteneurs. Un conteneur est un processus isolé qui s'exécute sur un système d'exploitation partagé, offrant une alternative plus légère aux machines virtuelles. Bien que les conteneurs ne soient pas nouveaux, ils offrent des avantages, notamment l'isolation des processus et la normalisation de l'environnement, qui gagnent en importance à mesure que de plus en plus de développeurs utilisent des architectures d'applications distribuées.

Lors de la création et de la mise à l'échelle d'une application avec Docker, le point de départ consiste généralement à créer une image pour votre application, que vous pouvez ensuite exécuter dans un conteneur. L'image inclut votre code d'application, vos bibliothèques, vos fichiers de configuration, vos variables d'environnement et votre environnement d'exécution. L'utilisation d'une image garantit que l'environnement de votre conteneur est standardisé et ne contient que ce qui est nécessaire pour créer et exécuter votre application.

Dans ce didacticiel, vous allez créer une image d'application pour un site Web statique qui utilise le framework Express et Bootstrap. Vous allez ensuite créer un conteneur à l'aide de cette image et le pousser vers Docker Hub pour une utilisation future. Enfin, vous allez extraire l'image stockée de votre référentiel Docker Hub et créer un autre conteneur, démontrant comment vous pouvez recréer et mettre à l'échelle votre application.

Conditions préalables

Pour suivre ce tutoriel, vous aurez besoin de :

Étape 1 - Installation de vos dépendances d'application

Pour créer votre image, vous devrez d'abord créer vos fichiers d'application, que vous pourrez ensuite copier dans votre conteneur. Ces fichiers incluront le contenu statique, le code et les dépendances de votre application.

Tout d'abord, créez un répertoire pour votre projet dans le répertoire personnel de votre utilisateur non root. Nous appellerons le nôtre node_project, mais vous devriez vous sentir libre de le remplacer par autre chose :

mkdir node_project

Accédez à ce répertoire :

cd node_project

Ce sera le répertoire racine du projet.

Ensuite, créez un fichier package.json avec les dépendances de votre projet et d'autres informations d'identification. Ouvrez le fichier avec nano ou votre éditeur préféré :

nano package.json

Ajoutez les informations suivantes sur le projet, notamment son nom, son auteur, sa licence, son point d'entrée et ses dépendances. Assurez-vous de remplacer les informations sur l'auteur par votre propre nom et vos coordonnées :

~/node_project/package.json

{
  "name": "nodejs-image-demo",
  "version": "1.0.0",
  "description": "nodejs image demo",
  "author": "Sammy the Shark <[email protected]>",
  "license": "MIT",
  "main": "app.js",
  "keywords": [
    "nodejs",
    "bootstrap",
    "express"
  ],
  "dependencies": {
    "express": "^4.16.4"
  }
}

Ce fichier comprend le nom du projet, l'auteur et la licence sous laquelle il est partagé. Npm recommande de rendre le nom de votre projet court et descriptif, et d'éviter les doublons dans le registre npm. Nous avons répertorié la licence MIT dans le champ de licence, permettant l'utilisation et la distribution gratuites du code d'application.

De plus, le fichier spécifie :

  • "main" : le point d'entrée de l'application, app.js. Vous allez ensuite créer ce fichier.
  • "dependencies" : les dépendances du projet — dans ce cas, Express 4.16.4 ou supérieur.

Bien que ce fichier ne répertorie pas de référentiel, vous pouvez en ajouter un en suivant ces instructions sur ajout d'un référentiel à votre fichier package.json. C'est un bon ajout si vous versionnez votre application.

Enregistrez et fermez le fichier lorsque vous avez terminé d'apporter des modifications.

Pour installer les dépendances de votre projet, exécutez la commande suivante :

npm install

Cela installera les packages que vous avez répertoriés dans votre fichier package.json dans votre répertoire de projet.

Nous pouvons maintenant passer à la construction des fichiers d'application.

Étape 2 - Création des fichiers d'application

Nous allons créer un site Web qui offre aux utilisateurs des informations sur les requins. Notre application aura un point d'entrée principal, app.js, et un répertoire views qui inclura les actifs statiques du projet. La page de destination, index.html, offrira aux utilisateurs des informations préliminaires et un lien vers une page contenant des informations plus détaillées sur les requins, sharks.html. Dans le répertoire views, nous allons créer à la fois la page de destination et sharks.html.

Commencez par ouvrir app.js dans le répertoire principal du projet pour définir les routes du projet :

nano app.js

La première partie du fichier créera les objets Express application et Router, et définira le répertoire de base et le port comme des constantes :

~/node_project/app.js

const express = require('express');
const app = express();
const router = express.Router();

const path = __dirname + '/views/';
const port = 8080;

La fonction require charge le module express, que nous utilisons ensuite pour créer les objets app et router. L'objet router effectuera la fonction de routage de l'application, et lorsque nous définirons les itinéraires de méthode HTTP, nous les ajouterons à cet objet pour définir comment notre application traitera les requêtes.

Cette section du fichier définit également quelques constantes, path et port :

  • path : Définit le répertoire de base, qui sera le sous-répertoire views dans le répertoire du projet en cours.
  • port : indique à l'application d'écouter et de se connecter au port 8080.

Définissez ensuite les routes de l'application à l'aide de l'objet router :

~/node_project/app.js

...

router.use(function (req,res,next) {
  console.log('/' + req.method);
  next();
});

router.get('/', function(req,res){
  res.sendFile(path + 'index.html');
});

router.get('/sharks', function(req,res){
  res.sendFile(path + 'sharks.html');
});

La fonction router.use charge une fonction middleware qui enregistrera les requêtes du routeur et les transmettra aux routes de l'application. Celles-ci sont définies dans les fonctions suivantes, qui spécifient qu'une requête GET à l'URL de base du projet doit renvoyer la page index.html, tandis qu'une requête GET à la route /sharks doit renvoyer [X199X ].

Enfin, montez le middleware router et les actifs statiques de l'application et dites à l'application d'écouter sur le port 8080 :

~/node_project/app.js

...

app.use(express.static(path));
app.use('/', router);

app.listen(port, function () {
  console.log('Example app listening on port 8080!')
})

Le fichier app.js terminé ressemblera à ceci :

~/node_project/app.js

const express = require('express');
const app = express();
const router = express.Router();

const path = __dirname + '/views/';
const port = 8080;

router.use(function (req,res,next) {
  console.log('/' + req.method);
  next();
});

router.get('/', function(req,res){
  res.sendFile(path + 'index.html');
});

router.get('/sharks', function(req,res){
  res.sendFile(path + 'sharks.html');
});

app.use(express.static(path));
app.use('/', router);

app.listen(port, function () {
  console.log('Example app listening on port 8080!')
})

Enregistrez et fermez le fichier lorsque vous avez terminé.

Ensuite, ajoutons du contenu statique à l'application. Commencez par créer le répertoire views :

mkdir views

Ouvrez le fichier de page de destination, index.html :

nano views/index.html

Ajoutez le code suivant au fichier, qui importera Boostrap et créera un composant jumbotron avec un lien vers la page d'informations plus détaillée sharks.html :

~/node_project/views/index.html

<!DOCTYPE html>
<html lang="en">

<head>
    <title>About Sharks</title>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
    <link href="css/styles.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css?family=Merriweather:400,700" rel="stylesheet" type="text/css">
</head>

<body>
    <nav class="navbar navbar-dark bg-dark navbar-static-top navbar-expand-md">
        <div class="container">
            <button type="button" class="navbar-toggler collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false"> <span class="sr-only">Toggle navigation</span>
            </button> <a class="navbar-brand" href="#">Everything Sharks</a>
            <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
                <ul class="nav navbar-nav mr-auto">
                    <li class="active nav-item"><a href="/" class="nav-link">Home</a>
                    </li>
                    <li class="nav-item"><a href="/sharks" class="nav-link">Sharks</a>
                    </li>
                </ul>
            </div>
        </div>
    </nav>
    <div class="jumbotron">
        <div class="container">
            <h1>Want to Learn About Sharks?</h1>
            <p>Are you ready to learn about sharks?</p>
            <br>
            <p><a class="btn btn-primary btn-lg" href="/sharks" role="button">Get Shark Info</a>
            </p>
        </div>
    </div>
    <div class="container">
        <div class="row">
            <div class="col-lg-6">
                <h3>Not all sharks are alike</h3>
                <p>Though some are dangerous, sharks generally do not attack humans. Out of the 500 species known to researchers, only 30 have been known to attack humans.
                </p>
            </div>
            <div class="col-lg-6">
                <h3>Sharks are ancient</h3>
                <p>There is evidence to suggest that sharks lived up to 400 million years ago.
                </p>
            </div>
        </div>
    </div>
</body>

</html>

La navbar de niveau supérieur permet aux utilisateurs de basculer entre les pages Home et Sharks. Dans le sous-composant navbar-nav, nous utilisons la classe active de Bootstrap pour indiquer la page actuelle à l'utilisateur. Nous avons également spécifié les routes vers nos pages statiques, qui correspondent aux routes que nous avons définies dans app.js :

~/node_project/views/index.html

...
<div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
   <ul class="nav navbar-nav mr-auto">
      <li class="active nav-item"><a href="/" class="nav-link">Home</a>
      </li>
      <li class="nav-item"><a href="/sharks" class="nav-link">Sharks</a>
      </li>
   </ul>
</div>
...

De plus, nous avons créé un lien vers notre page d'informations sur les requins dans le bouton de notre jumbotron :

~/node_project/views/index.html

...
<div class="jumbotron">
   <div class="container">
      <h1>Want to Learn About Sharks?</h1>
      <p>Are you ready to learn about sharks?</p>
      <br>
      <p><a class="btn btn-primary btn-lg" href="/sharks" role="button">Get Shark Info</a>
      </p>
   </div>
</div>
...

Il y a aussi un lien vers une feuille de style personnalisée dans l'en-tête :

~/node_project/views/index.html

...
<link href="css/styles.css" rel="stylesheet">
...

Nous créerons cette feuille de style à la fin de cette étape.

Enregistrez et fermez le fichier lorsque vous avez terminé.

Avec la page d'accueil de l'application en place, nous pouvons créer notre page d'informations sur les requins, sharks.html, qui offrira aux utilisateurs intéressés plus d'informations sur les requins.

Ouvrez le fichier :

nano views/sharks.html

Ajoutez le code suivant, qui importe Bootstrap et la feuille de style personnalisée et offre aux utilisateurs des informations détaillées sur certains requins :

~/node_project/views/sharks.html

<!DOCTYPE html>
<html lang="en">

<head>
    <title>About Sharks</title>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
    <link href="css/styles.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css?family=Merriweather:400,700" rel="stylesheet" type="text/css">
</head>
<nav class="navbar navbar-dark bg-dark navbar-static-top navbar-expand-md">
    <div class="container">
        <button type="button" class="navbar-toggler collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false"> <span class="sr-only">Toggle navigation</span>
        </button> <a class="navbar-brand" href="/">Everything Sharks</a>
        <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
            <ul class="nav navbar-nav mr-auto">
                <li class="nav-item"><a href="/" class="nav-link">Home</a>
                </li>
                <li class="active nav-item"><a href="/sharks" class="nav-link">Sharks</a>
                </li>
            </ul>
        </div>
    </div>
</nav>
<div class="jumbotron text-center">
    <h1>Shark Info</h1>
</div>
<div class="container">
    <div class="row">
        <div class="col-lg-6">
            <p>
                <div class="caption">Some sharks are known to be dangerous to humans, though many more are not. The sawshark, for example, is not considered a threat to humans.
                </div>
                <img src="https://assets.digitalocean.com/articles/docker_node_image/sawshark.jpg" alt="Sawshark">
            </p>
        </div>
        <div class="col-lg-6">
            <p>
                <div class="caption">Other sharks are known to be friendly and welcoming!</div>
                <img src="https://assets.digitalocean.com/articles/docker_node_image/sammy.png" alt="Sammy the Shark">
            </p>
        </div>
    </div>
</div>

</html>

Notez que dans ce fichier, nous utilisons à nouveau la classe active pour indiquer la page courante.

Enregistrez et fermez le fichier lorsque vous avez terminé.

Enfin, créez la feuille de style CSS personnalisée à laquelle vous avez lié dans index.html et sharks.html en créant d'abord un dossier css dans le répertoire views :

mkdir views/css

Ouvrez la feuille de style :

nano views/css/styles.css

Ajoutez le code suivant, qui définira la couleur et la police souhaitées pour nos pages :

~/node_project/views/css/styles.css

.navbar {
    margin-bottom: 0;
}

body {
    background: #020A1B;
    color: #ffffff;
    font-family: 'Merriweather', sans-serif;
}

h1,
h2 {
    font-weight: bold;
}

p {
    font-size: 16px;
    color: #ffffff;
}

.jumbotron {
    background: #0048CD;
    color: white;
    text-align: center;
}

.jumbotron p {
    color: white;
    font-size: 26px;
}

.btn-primary {
    color: #fff;
    text-color: #000000;
    border-color: white;
    margin-bottom: 5px;
}

img,
video,
audio {
    margin-top: 20px;
    max-width: 80%;
}

div.caption: {
    float: left;
    clear: both;
}

En plus de définir la police et la couleur, ce fichier limite également la taille des images en spécifiant un max-width de 80 %. Cela leur évitera de prendre plus de place que nous ne le souhaiterions sur la page.

Enregistrez et fermez le fichier lorsque vous avez terminé.

Une fois les fichiers d'application en place et les dépendances du projet installées, vous êtes prêt à démarrer l'application.

Si vous avez suivi le didacticiel de configuration initiale du serveur dans les prérequis, vous disposerez d'un pare-feu actif autorisant uniquement le trafic SSH. Pour autoriser le trafic vers le port 8080, exécutez :

sudo ufw allow 8080

Pour démarrer l'application, assurez-vous d'être dans le répertoire racine de votre projet :

cd ~/node_project

Démarrez l'application avec node app.js :

node app.js

Naviguez dans votre navigateur jusqu'à http://your_server_ip:8080. Vous verrez la page de destination suivante :

Cliquez sur le bouton Obtenir des informations sur les requins. Vous verrez la page d'informations suivante :

Vous avez maintenant une application en cours d'exécution. Lorsque vous êtes prêt, quittez le serveur en tapant CTRL+C. Nous pouvons maintenant passer à la création du Dockerfile qui nous permettra de recréer et de mettre à l'échelle cette application comme vous le souhaitez.

Étape 3 - Écrire le Dockerfile

Votre Dockerfile spécifie ce qui sera inclus dans votre conteneur d'application lors de son exécution. L'utilisation d'un Dockerfile vous permet de définir votre environnement de conteneur et d'éviter les divergences avec les dépendances ou les versions d'exécution.

En suivant ces directives sur la création de conteneurs optimisés, nous rendrons notre image aussi efficace que possible en minimisant le nombre de calques d'image et en limitant la fonction de l'image à un seul objectif : recréer nos fichiers d'application et notre contenu statique.

Dans le répertoire racine de votre projet, créez le Dockerfile :

nano Dockerfile

Les images Docker sont créées à l'aide d'une succession d'images en couches qui s'appuient les unes sur les autres. Notre première étape consistera à ajouter l'image de base pour notre application qui constituera le point de départ de la construction de l'application.

Utilisons l'image node:10-alpine, car au moment de la rédaction, il s'agit de la version LTS recommandée par de Node.js. L'image alpine est dérivée du projet Alpine Linux et nous aidera à réduire la taille de notre image. Pour plus d'informations sur la question de savoir si l'image alpine est le bon choix pour votre projet, veuillez consulter la discussion complète dans la section Variantes d'image de la page d'image Docker Hub Node[ X210X].

Ajoutez l'instruction FROM suivante pour définir l'image de base de l'application :

~/node_project/Dockerfile

FROM node:10-alpine

Cette image inclut Node.js et npm. Chaque Dockerfile doit commencer par une instruction FROM.

Par défaut, l'image Docker Node inclut un utilisateur node non root que vous pouvez utiliser pour éviter d'exécuter votre conteneur d'application en tant que root. C'est une pratique de sécurité recommandée d'éviter d'exécuter des conteneurs en tant que racine et de restreindre les capacités au sein du conteneur uniquement à celles requises pour exécuter ses processus. Nous allons donc utiliser le répertoire personnel de l'utilisateur node comme répertoire de travail pour notre application et le définir comme notre utilisateur à l'intérieur du conteneur. Pour plus d'informations sur les meilleures pratiques lors de l'utilisation de l'image Docker Node, consultez ce guide des meilleures pratiques.

Pour affiner les autorisations sur notre code d'application dans le conteneur, créons le sous-répertoire node_modules dans /home/node avec le répertoire app. La création de ces répertoires garantira qu'ils disposent des autorisations souhaitées, ce qui sera important lorsque nous créerons des modules de nœuds locaux dans le conteneur avec npm install. En plus de créer ces répertoires, nous en définirons la propriété sur notre utilisateur node :

~/node_project/Dockerfile

...
RUN mkdir -p /home/node/app/node_modules && chown -R node:node /home/node/app

Pour plus d'informations sur l'utilité de la consolidation des instructions RUN, consultez cette discussion sur la gestion des couches de conteneur.

Ensuite, définissez le répertoire de travail de l'application sur /home/node/app :

~/node_project/Dockerfile

...
WORKDIR /home/node/app

Si un WORKDIR n'est pas défini, Docker en créera un par défaut, c'est donc une bonne idée de le définir explicitement.

Ensuite, copiez les fichiers package.json et package-lock.json (pour npm 5+) :

~/node_project/Dockerfile

...
COPY package*.json ./

L'ajout de cette instruction COPY avant d'exécuter npm install ou de copier le code de l'application nous permet de tirer parti du mécanisme de mise en cache de Docker. À chaque étape de la construction, Docker vérifiera s'il a une couche en cache pour cette instruction particulière. Si nous modifions package.json, cette couche sera reconstruite, mais si nous ne le faisons pas, cette instruction permettra à Docker d'utiliser la couche d'image existante et d'ignorer la réinstallation de nos modules de nœud.

Pour vous assurer que tous les fichiers d'application appartiennent à l'utilisateur node non root, y compris le contenu du répertoire node_modules, basculez l'utilisateur vers node avant d'exécuter npm install :

~/node_project/Dockerfile

...
USER node

Après avoir copié les dépendances du projet et changé d'utilisateur, nous pouvons exécuter npm install :

~/node_project/Dockerfile

...
RUN npm install

Ensuite, copiez votre code d'application avec les autorisations appropriées dans le répertoire de l'application sur le conteneur :

~/node_project/Dockerfile

...
COPY --chown=node:node . .

Cela garantira que les fichiers d'application appartiennent à l'utilisateur non root node.

Enfin, exposez le port 8080 sur le conteneur et démarrez l'application :

~/node_project/Dockerfile

...
EXPOSE 8080

CMD [ "node", "app.js" ]

EXPOSE ne publie pas le port, mais fonctionne plutôt comme un moyen de documenter les ports du conteneur qui seront publiés au moment de l'exécution. CMD exécute la commande pour démarrer l'application — dans ce cas, node app.js. Notez qu'il ne devrait y avoir qu'une seule instruction CMD dans chaque Dockerfile. Si vous en incluez plusieurs, seul le dernier prendra effet.

Il y a beaucoup de choses que vous pouvez faire avec le Dockerfile. Pour une liste complète des instructions, veuillez vous référer à la documentation de référence Dockerfile de Docker.

Le Dockerfile complet ressemble à ceci :

~/node_project/Dockerfile

FROM node:10-alpine

RUN mkdir -p /home/node/app/node_modules && chown -R node:node /home/node/app

WORKDIR /home/node/app

COPY package*.json ./

USER node

RUN npm install

COPY --chown=node:node . .

EXPOSE 8080

CMD [ "node", "app.js" ]

Enregistrez et fermez le fichier lorsque vous avez terminé l'édition.

Avant de construire l'image de l'application, ajoutons un fichier .dockerignore. Fonctionnant de la même manière qu'un fichier .gitignore , .dockerignore spécifie quels fichiers et répertoires de votre répertoire de projet ne doivent pas être copiés dans votre conteneur.

Ouvrez le fichier .dockerignore :

nano .dockerignore

Dans le fichier, ajoutez vos modules de nœud locaux, les journaux npm, Dockerfile et le fichier .dockerignore :

~/node_project/.dockerignore

node_modules
npm-debug.log
Dockerfile
.dockerignore

Si vous travaillez avec Git, vous voudrez également ajouter votre répertoire .git et votre fichier .gitignore.

Enregistrez et fermez le fichier lorsque vous avez terminé.

Vous êtes maintenant prêt à créer l'image de l'application à l'aide de la commande docker build. L'utilisation du drapeau -t avec docker build vous permettra de taguer l'image avec un nom mémorable. Comme nous allons pousser l'image vers Docker Hub, incluons notre nom d'utilisateur Docker Hub dans la balise. Nous étiqueterons l'image comme nodejs-image-demo, mais n'hésitez pas à la remplacer par un nom de votre choix. N'oubliez pas de remplacer également your_dockerhub_username par votre propre nom d'utilisateur Docker Hub :

docker build -t your_dockerhub_username/nodejs-image-demo .

Le . spécifie que le contexte de construction est le répertoire courant.

Il faudra une minute ou deux pour construire l'image. Une fois terminé, vérifiez vos images :

docker images

Vous verrez la sortie suivante :

OutputREPOSITORY                                         TAG                 IMAGE ID            CREATED             SIZE
your_dockerhub_username/nodejs-image-demo          latest              1c723fb2ef12        8 seconds ago       73MB
node                                               10-alpine           f09e7c96b6de        3 weeks ago        70.7MB

Il est maintenant possible de créer un conteneur avec cette image en utilisant docker run. Nous allons inclure trois drapeaux avec cette commande :

  • -p : Cela publie le port sur le conteneur et le mappe à un port sur notre hôte. Nous utiliserons le port 80 sur l'hôte, mais vous devriez vous sentir libre de le modifier si nécessaire si vous avez un autre processus en cours d'exécution sur ce port. Pour plus d'informations sur la façon dont cela fonctionne, consultez cette discussion dans la documentation Docker sur liaison de port.
  • -d : cela exécute le conteneur en arrière-plan.
  • --name : Cela nous permet de donner au conteneur un nom mémorable.

Exécutez la commande suivante pour créer le conteneur :

docker run --name nodejs-image-demo -p 80:8080 -d your_dockerhub_username/nodejs-image-demo 

Une fois que votre conteneur est opérationnel, vous pouvez inspecter une liste de vos conteneurs en cours d'exécution avec docker ps :

docker ps

Vous verrez la sortie suivante :

OutputCONTAINER ID        IMAGE                                                   COMMAND             CREATED             STATUS              PORTS                  NAMES
e50ad27074a7        your_dockerhub_username/nodejs-image-demo               "node app.js"       8 seconds ago       Up 7 seconds        0.0.0.0:80->8080/tcp   nodejs-image-demo

Avec votre conteneur en cours d'exécution, vous pouvez maintenant visiter votre application en naviguant dans votre navigateur vers http://your_server_ip. Vous verrez à nouveau la page de destination de votre application :

Maintenant que vous avez créé une image pour votre application, vous pouvez la pousser vers Docker Hub pour une utilisation future.

Étape 4 - Utilisation d'un référentiel pour travailler avec des images

En transférant l'image de votre application vers un registre tel que Docker Hub, vous la rendez disponible pour une utilisation ultérieure lors de la création et de la mise à l'échelle de vos conteneurs. Nous allons démontrer comment cela fonctionne en poussant l'image de l'application vers un référentiel, puis en utilisant l'image pour recréer notre conteneur.

La première étape pour envoyer l'image consiste à vous connecter au compte Docker Hub que vous avez créé dans les prérequis :

docker login -u your_dockerhub_username 

Lorsque vous y êtes invité, saisissez le mot de passe de votre compte Docker Hub. La connexion de cette manière créera un fichier ~/.docker/config.json dans le répertoire personnel de votre utilisateur avec vos informations d'identification Docker Hub.

Vous pouvez maintenant transférer l'image de l'application vers Docker Hub à l'aide de la balise que vous avez créée précédemment, your_dockerhub_username/nodejs-image-demo :

docker push your_dockerhub_username/nodejs-image-demo

Testons l'utilité du registre d'images en détruisant notre conteneur d'application et notre image actuels et en les reconstruisant avec l'image dans notre référentiel.

Tout d'abord, répertoriez vos conteneurs en cours d'exécution :

docker ps

Vous verrez la sortie suivante :

OutputCONTAINER ID        IMAGE                                       COMMAND             CREATED             STATUS              PORTS                  NAMES
e50ad27074a7        your_dockerhub_username/nodejs-image-demo   "node app.js"       3 minutes ago       Up 3 minutes        0.0.0.0:80->8080/tcp   nodejs-image-demo

À l'aide du CONTAINER ID répertorié dans votre sortie, arrêtez le conteneur d'application en cours d'exécution. Assurez-vous de remplacer l'ID en surbrillance ci-dessous par votre propre CONTAINER ID :

docker stop e50ad27074a7

Listez toutes vos images avec le drapeau -a :

docker images -a

Vous verrez la sortie suivante avec le nom de votre image, your_dockerhub_username/nodejs-image-demo, ainsi que l'image node et les autres images de votre build :

OutputREPOSITORY                                           TAG                 IMAGE ID            CREATED             SIZE
your_dockerhub_username/nodejs-image-demo            latest              1c723fb2ef12        7 minutes ago       73MB
<none>                                               <none>              2e3267d9ac02        4 minutes ago       72.9MB
<none>                                               <none>              8352b41730b9        4 minutes ago       73MB
<none>                                               <none>              5d58b92823cb        4 minutes ago       73MB
<none>                                               <none>              3f1e35d7062a        4 minutes ago       73MB
<none>                                               <none>              02176311e4d0        4 minutes ago       73MB
<none>                                               <none>              8e84b33edcda        4 minutes ago       70.7MB
<none>                                               <none>              6a5ed70f86f2        4 minutes ago       70.7MB
<none>                                               <none>              776b2637d3c1        4 minutes ago       70.7MB
node                                                 10-alpine           f09e7c96b6de        3 weeks ago         70.7MB

Supprimez le conteneur arrêté et toutes les images, y compris les images inutilisées ou pendantes, avec la commande suivante :

docker system prune -a

Tapez y lorsque vous y êtes invité dans la sortie pour confirmer que vous souhaitez supprimer le conteneur et les images arrêtés. Sachez que cela supprimera également votre cache de construction.

Vous avez maintenant supprimé à la fois le conteneur exécutant votre image d'application et l'image elle-même. Pour plus d'informations sur la suppression des conteneurs, des images et des volumes Docker, veuillez consulter Comment supprimer des images, des conteneurs et des volumes Docker.

Une fois toutes vos images et tous vos conteneurs supprimés, vous pouvez désormais extraire l'image de l'application depuis Docker Hub :

docker pull your_dockerhub_username/nodejs-image-demo

Listez à nouveau vos images :

docker images

Vous verrez l'image de votre application :

OutputREPOSITORY                                     TAG                 IMAGE ID            CREATED             SIZE
your_dockerhub_username/nodejs-image-demo      latest              1c723fb2ef12        11 minutes ago      73MB

Vous pouvez maintenant reconstruire votre conteneur à l'aide de la commande de l'étape 3 :

docker run --name nodejs-image-demo -p 80:8080 -d your_dockerhub_username/nodejs-image-demo

Répertoriez vos conteneurs en cours d'exécution :

docker ps
OutputCONTAINER ID        IMAGE                                                   COMMAND             CREATED             STATUS              PORTS                  NAMES
f6bc2f50dff6        your_dockerhub_username/nodejs-image-demo               "node app.js"       4 seconds ago       Up 3 seconds        0.0.0.0:80->8080/tcp   nodejs-image-demo

Visitez à nouveau http://your_server_ip pour voir votre application en cours d'exécution.

Conclusion

Dans ce didacticiel, vous avez créé une application Web statique avec Express et Bootstrap, ainsi qu'une image Docker pour cette application. Vous avez utilisé cette image pour créer un conteneur et avez poussé l'image vers Docker Hub. À partir de là, vous avez pu détruire votre image et votre conteneur et les recréer à l'aide de votre référentiel Docker Hub.

Si vous souhaitez en savoir plus sur l'utilisation d'outils tels que Docker Compose et Docker Machine pour créer des configurations multi-conteneurs, vous pouvez consulter les guides suivants :

Pour obtenir des conseils généraux sur l'utilisation des données de conteneur, consultez :

Si vous êtes intéressé par d'autres sujets liés à Docker, veuillez consulter notre bibliothèque complète de tutoriels Docker.