En gros, Docker ressemble de plus en plus à un gestionnaire de paquets universel qui fonctionne sur toutes les plates-formes Linux possibles. Il prend des conteneurs et les utilise pour résoudre un problème complètement différent auquel les développeurs sont confrontés. Le problème est que les développeurs utilisent leur système d'exploitation de bureau (comme Windows, macOS ou Linux avec une tonne de packages liés au bureau) pour écrire des applications. L'application qu'ils écrivent s'exécute souvent sur un système d'exploitation complètement différent sur un serveur quelque part avec une distribution Linux complètement différente de celle de l'ordinateur portable du développeur.
Avec Docker, l'idée est que votre application est livrée sous forme d'image Docker. C'est le travail de Docker de prendre cette image et de l'exécuter en tant qu'application conteneurisée pour vous. Être conteneurisé signifie que l'application et ses dépendances s'exécuteront dans un environnement isolé qui peut différer complètement de l'ordinateur portable du développeur et même du serveur de production. Tant qu'ils prennent tous les deux en charge Docker, ils peuvent tous les deux exécuter la même application exactement de la même manière.
Anatomie d'une image Docker
Comme mentionné précédemment, une application Docker s'exécutera sur un environnement convenu. Maintenant, la question est de savoir comment créer cet environnement ? La plupart des images d'application importeraient une image de base Docker et créeraient leur application par-dessus.
Les applications sont constituées de couches de logiciels. Une image de conteneur wordpress est construite à l'aide d'une image de conteneur httpd qui, à son tour, est construite au-dessus d'une image Ubuntu. L'image sur laquelle une image plus récente est construite est connue sous le nom d'IMAGE PARENT dans la terminologie Docker. Dans Dockerfile (nous verrons ce que signifie un Dockerfile, un peu plus tard), cette image parent est mentionnée en haut du fichier comme indiqué ci-dessous :
D'Ubuntu : 18.04
## Reste du Dockerfile
Ce Dockerfile, lorsqu'il est exécuté, convertit votre application en une image Docker (une sorte de binaire) que vous pouvez ensuite pousser vers un registre d'où elle peut être extraite pour créer de nouveaux conteneurs ailleurs. Cependant, ils auront tous Ubuntu:18.04 comme image de base et fonctionneront comme s'il s'agissait d'un système Ubuntu dans lequel ils s'exécutaient.
Vous l'avez peut-être remarqué en essayant d'extraire une nouvelle image Docker.
Cela montre combien de couches sont extraites avant que l'application réelle (qui peut ne faire que quelques mégaoctets) soit importée.
Pour cette raison, nous aimerions créer ce qu'on appelle une image de base. Qui n'est construit sur rien d'autre. Le mot-clé scratch est utilisé pour indiquer que cette couche n'est construite sur rien d'autre. Ainsi:
De zéro## Reste du fichier Dcoker
Nous allons d'abord créer une application hello-world simple, puis déterminer ce que sera le reste du Dockerfile. Le système hôte est Ubuntu:18.04 LTS et nous utilisons Docker version 17.12.1-ce pour l'expérience.
Créer un binaire statique
Les conteneurs Docker sont un ensemble de processus exécutés isolés du reste du système d'exploitation. La seule chose avec laquelle ce processus est en contact est le noyau. Le noyau est responsable de la planification de ces processus sur le processeur, de la gestion de la mémoire et de quelques autres tâches de base de gestion des réservations.
Mais la plupart des applications de haut niveau dépendent de nombreuses bibliothèques système (comme glibc, musl, klibc, etc. ) et de nombreuses dépendances d'exécution comme Python ou Node.js ou Java Runtime. Le binaire de l'application ne contient pas toutes les bibliothèques disponibles, mais lorsqu'il démarre l'exécution, il appelle ces bibliothèques à partir du système d'exploitation hôte.
Parce que nous essayons de créer une image à partir de zéro, nous n'obtiendrions pas ces subtilités. Notre application doit donc être un fichier statique ou un exécutable autonome.
Commençons par créer un dossier appelé MyDockerImage et créer un fichier hello.cc à l'intérieur.
$mkdirMonImageDocker$CDMonImageDocker
$toucherbonjour.cc
Ouvrez hello.cc à l'aide de votre éditeur de texte préféré et ajoutez-y les lignes suivantes.
#comprendreen utilisant l'espace de noms std;
entierprincipale(){
cout<< 'Bonjour! Ce message provient d'un conteneur ';
revenir 0;
}
Il s'agit d'un simple programme C++ qui affiche Hello! Ce message …
Pour les raisons évoquées précédemment, nous allons le compiler en utilisant le drapeau statique. Le compilateur utilisé est g++ (Ubuntu 7.3.0-16ubuntu3) 7.3.0.
Pour compiler le programme, dans le même répertoire exécutez la commande suivante :
g $++ -bonjour-statiqueBonjour.CCCela crée un fichier exécutable binaire hello dans le même répertoire. C'est notre fichier statique. Testez s'il fonctionne comme prévu en mentionnant le nom du fichier dans le terminal.
$./Bonjour 
Nous sommes maintenant prêts à conteneuriser ce programme simple.
Dockerfile
Le Dockerfile se compose d'un ensemble de règles qui prend vos fichiers d'application (comme les binaires, les fichiers source, etc.) ainsi que divers paramètres de configuration comme la disposition du système de fichiers, les ports exposés, etc. et les transforme en un fichier image Docker. Vous pouvez ensuite partager le fichier image avec toute personne souhaitant exécuter cette application.
Nous n'allons pas creuser dans toutes les options disponibles pour Dockerfile, nous allons plutôt écrire un Dockerfile très minimaliste. Dans le même répertoire, où réside votre exécutable hello, créez un fichier vide nommé Dockerfile.
$toucherDockerfileOuvrez-le avec votre éditeur de texte préféré et écrivez-y les lignes suivantes :
De zéroAJOUTER bonjour/
CMD['/Bonjour']
rayure n'est pas une image mère. Cela indique plutôt à Docker que l'image n'est construite sur aucune autre image. Il est construit à partir de zéro. La commande ADD prendrait le binaire statique nommé |_+_|du répertoire actuel et l'ajouterait au répertoire racine du fichier image. Lorsque nous exécuterons enfin un conteneur basé sur cette image, l'exécutable hello sera vu dans le répertoire racine lui-même à |_+_|
Enfin, la ligne CMD a une chaîne /Bonjour cette chaîne sera exécutée en tant que commande shell chaque fois qu'un conteneur sera créé à partir de cette image, donc le fichier binaire que nous avons ajouté à notre conteneur et imprimera le message que nous avons écrit dans notre application.
Construisons l'image en invoquant le construction de docker commande qui parcourrait le contenu du Dockerfile et générerait l'image. Exécutez la commande suivante dans le même répertoire que le Dockerfile et le binaire exécutable.
$construction de docker--étiqueterBonjour .Les -tag bonjour flag définit le nom de l'image sur Bonjour et le point ( . ) à la fin raconte construction de docker pour rechercher dans le répertoire actuel Dockerfile et le contenu associé.
Exécuter le conteneur Docker
Pour vérifier si l'image que nous venons de créer apparaît dans la liste des images, exécutez :
$images docker 
Remarquez à quel point l'image de bonjour est petite par rapport aux autres images. Dans tous les cas, il est prêt à être exécuté en tant que conteneur,
$bonjour 
C'est ça! Vous avez créé votre premier conteneur minimaliste à partir de zéro.
Autres options
Bien que la création d'images à partir de zéro soit toujours une option, les gens ont souvent tendance à créer des images à partir d'autres distributions Linux légères. Par exemple, des images comme alpine et busybox sont des environnements vraiment légers avec des bibliothèques plus petites comme musl au lieu de glibc.
Les utiliser comme image parent en utilisant DE alpin:dernier entraînerait également des images plus petites. Étant donné que les images de base ne font que 2 à 5 Mo. Faites-nous savoir s'il y a un sujet lié à Docker que vous souhaiteriez que nous abordions ensuite. Vous pouvez nous joindre sur Twitter , Facebook ou abonnez-vous par e-mail.