Introduction à la génération et au push d’images Docker

  Administration système Linux, Virtualisation et informatique en nuage
construction image docker build docker push docker

Les images Docker sont les blocs de base des conteneurs Docker. Une image contient tout ce qui est nécessaire pour exécuter une application ou un service à l’intérieur d’un conteneur – le code ou les binaires, les runtimes, les dépendances et les configurations.

Les images sont immuables, ce qui signifie qu’elles ne peuvent pas être modifiées une fois générées. Pour apporter des modifications, vous devez générer une nouvelle image. Les images sont également empilées, ce qui signifie que chaque image s’appuie sur une image de base, en ajoutant uniquement les changements nécessaires pour cette image spécifique. Cela rend les images légères, réutilisables et rapides à générer.

Il y a deux étapes principales pour travailler avec les images Docker :

  1. Génération – Crée une image Docker à partir d’un Dockerfile
  2. Push – Télécharge une image vers un registre comme Docker Hub

Ce guide couvrira ces étapes en détail, y compris :

  • Les bases du Dockerfile
  • Générer des images localement
  • Étiqueter les images
  • Pousser les images vers les registres
  • Gérer les images

Les bases du Dockerfile

Les images Docker sont générées à partir d’un Dockerfile – un fichier texte qui contient les instructions pour générer l’image. Un Dockerfile définit tout ce qui compose l’image – le système d’exploitation, les configurations, les fichiers et dossiers à copier, les ports réseau à exposer, les volumes Docker à créer, etc.

Quelques instructions Dockerfile courantes incluent :

  • FROM – Définit l’image de base sur laquelle s’appuyer
  • COPY – Copie des fichiers depuis l’hôte vers l’image
  • RUN – Exécute des commandes et des scripts shell pendant la génération
  • EXPOSE – Expose les ports réseau auxquels le conteneur écoutera
  • ENV – Définit des variables d’environnement
  • ENTRYPOINT – Définit l’exécutable à exécuter lors du démarrage du conteneur
  • CMD – Paramètres par défaut qui sont passés à l’ENTRYPOINT

Voici un exemple simple de Dockerfile qui génère une application Node.js :

# Utilise l'image de base Node.js 11 la plus récente
FROM node:11
# Définit le répertoire de travail dans le conteneur
WORKDIR /app
# Copie les fichiers package et installe les dépendances
COPY package*.json ./
RUN npm install
# Copie le code source de l'application
COPY . .
# Expose le port et démarre l'application
EXPOSE 8080
CMD ["node", "app.js"]

Cela utilise l’image node:11 comme point de départ, copie le code source de l’application dans l’image, installe les dépendances, et définit l’application pour démarrer au lancement du conteneur.

Générer des images localement

Avec un Dockerfile prêt, vous pouvez générer une image en utilisant la commande docker build. Cela générera l’image étape par étape selon les instructions du Dockerfile.

Le format de base est :

$ docker build [options] PATH

Où PATH est l’emplacement du Dockerfile.

Par exemple :

$ docker build -t my-app .

Cela cherchera un Dockerfile dans le répertoire courant et générera une image appelée my-app à partir de celui-ci.

Quelques options clés :

  • -t – Étiquette l’image avec un nom de dépôt et un tag
  • --no-cache – Regénère l’image depuis zéro au lieu d’utiliser le cache
  • -f – Chemin vers le Dockerfile s’il n’est pas dans le répertoire courant

Vous pouvez générer des images pour différents environnements ou paramètres en ayant simplement plusieurs Dockerfiles, par exemple Dockerfile.dev, Dockerfile.prod.

Pendant le développement, vous voudrez itérer rapidement en regénérant fréquemment les images au fur et à mesure des modifications apportées à l’application. L’utilisation du cache accélère considérablement les temps de regénération.

Étiqueter les images

Les tags d’image identifient une image comme appartenant à un dépôt et fournissent un nom de version ou de variante.

Les tags sont composés du nom du dépôt et du nom du tag séparés par un deux-points, comme my-app:latest.

Lors de la génération d’une image, le flag -t permet de l’étiqueter :

$ docker build -t my-app:latest .

Cela nomme l’image my-app et lui applique le tag latest.

Si aucun tag n’est fourni, latest est supposé.

Quelques stratégies d’étiquetage courantes :

  • latest – La version stable la plus récente
  • SHA de commit Git – Étiquette la génération avec le SHA du commit pour la traçabilité
  • Versions sémantiques – Tags comme v1.0.2 pour les versions de publication
  • Tags de variantes – Comme prod, test, dev pour indiquer à quoi sert l’image

Remarque : L’étiquetage donne du sens et du contexte à une image. Les images sans tag sont difficiles à gérer.

Vous pouvez ré-étiqueter une image existante pour ajouter ou modifier des tags :

$ docker tag my-app:latest my-app:v1.0

Pousser les images vers les registres Docker

Pour partager des images Docker avec d’autres, vous devez les pousser vers un registre. Un registre stocke les images Docker qui peuvent ensuite être récupérées et utilisées par n’importe quel hôte Docker.

Le registre par défaut est Docker Hub, qui a des dépôts publics et privés.

Pour pousser une image :

  1. Étiquetez l’image avec le nom du registre :
$ docker tag my-app:latest mydockerid/my-app:latest
  1. Poussez l’image étiquetée :
$ docker push mydockerid/my-app:latest

Cela téléchargera l’image my-app:latest dans l’espace de noms mydockerid sur Docker Hub.

Pour pousser vers un autre registre :

$ docker push registry.example.com/my-app:latest

Certaines entreprises hébergent des registres privés internes pour stocker des images exclusives. Cela nécessite une authentification et SSL pour la sécurité.

Dans une chaîne CI/CD, vous pouvez automatiser la génération et le push d’images vers les registres à chaque modification du code. Cela permet de déployer en continu des applications en utilisant les dernières images.

Gérer les images locales

Lorsque vous générez des images, l’hôte Docker les stocke localement dans le moteur Docker. Pour libérer de l’espace disque, vous devrez occasionnellement nettoyer les anciennes images inutilisées.

Quelques commandes utiles pour gérer les images :

  • docker images – Liste toutes les images sur l’hôte
  • docker image rm – Supprime une ou plusieurs images
  • docker image prune – Supprime les images inutilisées et dangling
  • docker rmi – Supprime l’image par ID ou nom

Exemple de suppression d’images :

# Supprime une image spécifique
$ docker image rm my-app:latest
# Supprime toutes les images correspondant au nom
$ docker image rm my-app
# Supprime les images dangling
$ docker image prune
# Supprime toutes les images
$ docker rmi $(docker images -q)

Utilisez ces commandes avec précaution pour éviter de supprimer accidentellement des images encore en cours d’utilisation ou nécessaires.

Vous pouvez également configurer des politiques automatisées pour supprimer les anciennes images. Par exemple, conserver uniquement les 10 tags d’image les plus récents pour chaque dépôt.

Conclusion

Voilà pour les bases de la génération, de l’étiquetage, du push et de la gestion des images Docker !

Les points clés à retenir incluent :

  • Les Dockerfiles définissent la façon dont les images sont générées
  • docker build transforme un Dockerfile en une image exécutable
  • Les images doivent être étiquetées avec un nom de dépôt et de version
  • docker push télécharge les images vers des registres comme Docker Hub
  • Les commandes docker image gèrent les images sur un hôte Docker

Avec ces bases, vous pouvez utiliser efficacement les images Docker pour packager et déployer des applications de manière cohérente et fiable. L’automatisation de la génération d’images et des déploiements vous permettra d’adopter des pratiques DevOps matures.

Laisser un commentaire