Comment utiliser Docker pour empaqueter des applications CLI – CloudSavvy IT
Agence web » Actualités du digital » Comment utiliser Docker pour empaqueter des applications CLI – CloudSavvy IT

Comment utiliser Docker pour empaqueter des applications CLI – CloudSavvy IT

Docker est une plate-forme populaire pour le conditionnement d’applications sous forme d’artefacts distribuables autonomes. Il crée des images qui incluent tout ce dont vous avez besoin pour exécuter un logiciel particulier, comme son code source, les dépendances de packages tiers et les caractéristiques d’environnement requises.

Comme les images Docker peuvent s’exécuter partout où Docker est installé, elles constituent un format viable pour distribuer vos applications CLI. L’écosystème Docker inclut Docker Hub en tant que registre public disponible par défaut, vous offrant une chaîne d’outils complète pour publier, mettre à jour et documenter vos outils.

Voici comment vous pouvez utiliser Docker pour empaqueter des applications CLI au lieu des gestionnaires de packages de système d’exploitation traditionnels et des téléchargements binaires autonomes.

Pourquoi utiliser Docker pour les applications CLI ?

Docker peut permettre aux utilisateurs d’installer plus rapidement et plus facilement votre nouvel utilitaire. Ils arrivent à docker run your-app au lieu d’avoir à rechercher des instructions d’installation spécifiques à la plate-forme. Il n’y a pas d’extraction manuelle de tar archives, copie dans des dossiers système ou PATH l’édition impliquée.

Le logiciel dockerisé permet également aux utilisateurs de sélectionner facilement différentes versions, d’effectuer des mises à jour et d’initier des restaurations. Chaque version distincte que vous créez doit avoir sa propre balise immuable qui identifie de manière unique son image Docker. Contrairement aux gestionnaires de packages classiques, les utilisateurs peuvent facilement exécuter deux versions de votre logiciel côte à côte en démarrant des conteneurs basés sur différentes balises d’image.

Un autre avantage est la facilité avec laquelle les utilisateurs peuvent essayer votre application en toute sécurité sans s’y engager à long terme. Les gens peuvent hésiter à ajouter de nouveaux packages à leurs machines, de peur que le logiciel ne se nettoie complètement après lui-même lorsqu’il est supprimé. Les conteneurs Docker ont leur propre système de fichiers privé ; la suppression d’un conteneur ne laisse aucune trace de son existence sur l’hôte. Cela pourrait encourager davantage d’utilisateurs à essayer votre application.

Une conséquence naturelle de la distribution Dockerisée est l’exigence que les utilisateurs aient déjà Docker en cours d’exécution sur leur machine. De nos jours, de nombreux développeurs l’exécuteront automatiquement, c’est donc un choix assez sûr à faire. Si vous craignez de bloquer les utilisateurs qui ne souhaitent pas utiliser Docker, vous pouvez toujours proposer des options alternatives via vos canaux de distribution existants.

Création d’une image Docker pour une application CLI

Les images Docker pour les applications CLI sont peu différentes de celles utilisées pour tout autre type de logiciel. L’objectif est de fournir une image aussi légère que possible tout en regroupant tout ce dont votre application a besoin pour fonctionner.

Il est généralement préférable de partir d’une image de base minimale qui exécute un système d’exploitation rationalisé comme Alpine. Ajoutez uniquement les packages requis par votre logiciel, tels que son langage de programmation, sa structure et ses dépendances.

Deux instructions Dockerfile essentielles pour les outils CLI sont ENTRYPOINT et CMD. Ensemble, ils définissent le processus de premier plan qui s’exécutera lorsque les conteneurs seront démarrés à partir de votre image. La plupart des images de base lanceront par défaut un shell au démarrage du conteneur. Vous devez modifier cela pour que votre application s’exécute automatiquement, ce qui évite aux utilisateurs d’avoir à l’exécuter manuellement dans le conteneur.

le ENTRYPOINT L’instruction Dockerfile définit le processus de premier plan du conteneur. Définissez ceci sur l’exécutable de votre application :

ENTRYPOINT ["demo-app"]

le CMD l’instruction fonctionne en tandem avec ENTRYPOINT. Il fournit des arguments par défaut pour la commande définie dans le ENTRYPOINT. Arguments que l’utilisateur fournit au démarrage du conteneur avec docker run remplacera le CMD défini dans le Dockerfile.

Une bonne utilisation pour CMD est lorsque vous souhaitez afficher une aide de base ou des informations sur la version lorsque les utilisateurs omettent une commande spécifique :

ENTRYPOINT ["demo-app"]
CMD ["--version"]

Voici quelques exemples montrant comment ces deux instructions entraînent l’exécution de différentes commandes lors de la création des conteneurs :

# Starting a new container from the "demo-app-image:latest" image

# Runs "demo-app --version"
docker run demo-app-image:latest

# Runs "demo-app demo --foo bar"
docker run demo-app-image:latest demo --foo bar

Aucun des exemples n’exige que l’utilisateur tape le demo-app nom exécutable. Il est automatiquement utilisé comme processus de premier plan car c’est le processus configuré ENTRYPOINT. La commande reçoit les arguments que l’utilisateur a donnés à docker run après le nom de l’image. Lorsqu’aucun argument n’est fourni, la valeur par défaut --version est utilisé.

Ces deux instructions sont les blocs de construction fondamentaux des images Docker hébergeant des outils CLI. Vous voulez que l’exécutable principal de votre application soit le processus de premier plan par défaut afin que les utilisateurs n’aient pas à l’invoquer eux-mêmes.

Mettre ensemble

Voici une image Docker qui exécute une simple application Node.js :

#!/usr/local/bin/node
console.log("Hello World");
FROM node:16-alpine
WORKDIR /hello-world

COPY ./ .

RUN npm install

ENTRYPOINT ["hello-world.js"]

La variante basée sur Alpine de l’image de base Node est utilisée pour réduire la taille globale de votre image. Le code source de l’application est copié dans le système de fichiers de l’image via le COPY instruction. Les dépendances npm du projet sont installées et le hello-world.js script est défini comme point d’entrée de l’image.

Construire l’image en utilisant docker build:

docker build -t demo-app-image:latest

Maintenant, vous pouvez exécuter l’image pour voir Hello World émis vers votre terminal :

docker run demo-app-image:latest

À ce stade, vous êtes prêt à transférer votre image vers Docker Hub ou un autre registre où elle peut être téléchargée par les utilisateurs. Toute personne ayant accès à l’image pourra démarrer votre logiciel en utilisant uniquement la CLI Docker.

Gestion des données persistantes

Dockeriser une application CLI s’accompagne de certains défis. Le plus important d’entre eux est de savoir comment gérer la persistance des données. Les données créées dans un conteneur sont perdues lorsque ce conteneur s’arrête, sauf si elles sont enregistrées sur un volume Docker externe.

Vous devez écrire des données dans des chemins clairement définis sur lesquels les utilisateurs peuvent monter des volumes. Il est recommandé de regrouper toutes vos données persistantes dans un seul répertoire, comme /data. Évitez d’utiliser trop d’emplacements nécessitant le montage de plusieurs volumes. Votre guide de démarrage doit documenter les volumes dont votre application a besoin afin que les utilisateurs puissent configurer la persistance lorsqu’ils créent leur conteneur.

# Run demo-app with a data volume mounted to /data
docker run -v demo-app-data:/data demo-app-image:latest

Autres défis possibles

Le problème de montage réapparaît lorsque votre commande doit interagir avec des fichiers sur le système de fichiers de l’hôte. Voici un exemple simple d’outil de téléchargement de fichiers :

docker run file-uploader cp example.txt demo-server:/example.txt

Cela finit par chercher example.txt dans le conteneur. Dans cette situation, les utilisateurs devront lier mount leur répertoire de travail afin que son contenu soit disponible pour le conteneur :

docker run -v $PWD:/file-uploader file-uploader cp example.txt demo-server:/example.txt

Il est également important de réfléchir à la manière dont les utilisateurs fourniront les valeurs de configuration à votre application. Si vous lisez normalement à partir d’un fichier de configuration, gardez à l’esprit que les utilisateurs devront en monter un dans chaque conteneur qu’ils créent. Offrir des options alternatives telles que des indicateurs de ligne de commande et des variables d’environnement peut rationaliser l’expérience pour des cas d’utilisation simples :

# Setting the LOGGING_DRIVER environment variable in the container
docker run -e LOGGING_DRIVER=json demo-app-image:latest

Un autre défi concerne les applications interactives qui nécessitent une intervention de l’utilisateur. Les utilisateurs doivent passer le -it signaler à docker run pour activer le mode interactif et allouer un pseudo-TTY :

docker run -it demo-app-image:latest

Les utilisateurs doivent se rappeler de définir ces indicateurs si nécessaire, sinon votre programme ne pourra pas collecter d’entrées. Vous devez documenter les commandes qui nécessitent un TTY afin que les utilisateurs ne soient pas surpris par des erreurs inattendues.

Ces points d’achoppement signifient que les applications dockerisées peuvent devenir difficiles à manier si elles ne sont pas spécifiquement conçues avec la conteneurisation à l’esprit. Les utilisateurs obtiennent la meilleure expérience lorsque vos commandes sont pures, ne nécessitant aucune interaction avec le système de fichiers et une configuration minimale. Lorsque cela est possible, un simple docker run image-name répond à l’objectif d’installation et d’utilisation sans frottement. Vous pouvez toujours conteneuriser des logiciels plus complexes, mais vous dépendez de plus en plus des utilisateurs ayant une bonne connaissance pratique de la CLI Docker et de ses concepts.

Sommaire

Docker n’est pas seulement destiné aux déploiements cloud et aux services d’arrière-plan. Il est également de plus en plus populaire en tant que mécanisme de distribution pour les applications de console régulières. Vous pouvez facilement publier, utiliser, exécuter et maintenir des logiciels à l’aide du seul docker CLI que de nombreux praticiens du logiciel utilisent déjà au quotidien.

Offrir une image Docker prête à l’emploi pour votre application donne aux utilisateurs plus de choix. Les nouveaux arrivants peuvent commencer avec une seule commande qui configure un environnement préconfiguré avec toutes les dépendances prises en compte. Il n’y a aucun risque de polluer le système de fichiers ou l’environnement de leur hôte Docker, ce qui évite les conflits avec d’autres packages et garantit la possibilité de revenir à une table rase si vous le souhaitez.

La création d’une image Docker n’implique généralement pas plus que les routines que vous utilisez déjà pour soumettre des versions à différents gestionnaires de packages de système d’exploitation. Les considérations les plus importantes sont de garder votre image aussi petite que possible et de vous assurer que le point d’entrée et la commande sont appropriés pour votre application. Cela offrira aux utilisateurs la meilleure expérience possible lors de l’utilisation de votre logiciel Dockerized.

★★★★★