L'écosystème Docker : un aperçu de la conteneurisation

Introduction

Il existe souvent de nombreux obstacles qui empêchent de déplacer facilement votre application tout au long du cycle de développement et éventuellement en production. Outre le travail réel de développement de votre application pour répondre de manière appropriée dans chaque environnement, vous pouvez également rencontrer des problèmes de recherche de dépendances, de mise à l'échelle de votre application et de mise à jour de composants individuels sans affecter l'ensemble de l'application.

La conteneurisation Docker et la conception orientée services tentent de résoudre bon nombre de ces problèmes. Les applications peuvent être divisées en composants gérables et fonctionnels, emballés individuellement avec toutes leurs dépendances et déployés facilement sur une architecture irrégulière. La mise à l'échelle et la mise à jour des composants sont également simplifiées.

Dans ce guide, nous discuterons des avantages de la conteneurisation et de la manière dont Docker aide à résoudre bon nombre des problèmes que nous avons mentionnés ci-dessus. Docker est le composant central des déploiements de conteneurs distribués qui offrent une évolutivité et une gestion faciles.

Une brève histoire de la conteneurisation Linux

La conteneurisation et l'isolement ne sont pas des concepts nouveaux dans le monde informatique. Certains systèmes d'exploitation de type Unix exploitent des technologies de conteneurisation matures depuis plus d'une décennie.

Sous Linux, LXC, le bloc de construction qui a constitué la base des technologies de conteneurisation ultérieures, a été ajouté au noyau en 2008. LXC a combiné l'utilisation de groupes de contrôle du noyau (permet d'isoler et de suivre l'utilisation des ressources) et d'espaces de noms (permet de séparer les groupes afin qu'ils ne puissent pas se "voir" les uns les autres) pour implémenter une isolation légère des processus.

Plus tard, Docker a été présenté comme un moyen de simplifier les outils nécessaires pour créer et gérer des conteneurs. Il utilisait initialement LXC comme pilote d'exécution par défaut (il a depuis développé une bibliothèque appelée libcontainer à cet effet). Docker, tout en n'introduisant pas beaucoup de nouvelles idées, les a rendues accessibles au développeur moyen et à l'administrateur système en simplifiant le processus et en standardisant sur une interface. Cela a stimulé un regain d'intérêt pour la conteneurisation dans le monde Linux parmi les développeurs.

Bien que certains des sujets que nous aborderons dans cet article soient plus généraux, nous nous concentrerons principalement sur la conteneurisation Docker en raison de sa popularité écrasante et de son adoption standard.

Ce que la conteneurisation apporte à l'image

Les conteneurs présentent de nombreux avantages très intéressants pour les développeurs et les administrateurs système/équipes d'exploitation.

Certains des avantages les plus importants sont énumérés ci-dessous.

Abstraction du système hôte loin de l'application conteneurisée

Les conteneurs sont censés être complètement standardisés. Cela signifie que le conteneur se connecte à l'hôte et à tout ce qui se trouve en dehors du conteneur à l'aide d'interfaces définies. Une application conteneurisée ne doit pas s'appuyer sur les détails des ressources ou de l'architecture de l'hôte sous-jacent ni s'en soucier. Cela simplifie les hypothèses de développement concernant l'environnement d'exploitation. De même, pour l'hôte, chaque conteneur est une boîte noire. Il ne se soucie pas des détails de l'application à l'intérieur.

Évolutivité facile

L'un des avantages de l'abstraction entre le système hôte et les conteneurs est que, compte tenu de la conception correcte de l'application, la mise à l'échelle peut être simple et directe. La conception orientée service (abordée plus loin) combinée à des applications conteneurisées fournit les bases d'une évolutivité facile.

Un développeur peut exécuter quelques conteneurs sur son poste de travail, tandis que ce système peut être mis à l'échelle horizontalement dans une zone de test ou de test. Lorsque les conteneurs entrent en production, ils peuvent à nouveau évoluer.

Gestion simple des dépendances et gestion des versions des applications

Les conteneurs permettent à un développeur de regrouper une application ou un composant d'application avec toutes ses dépendances en tant qu'unité. Le système hôte n'a pas à se préoccuper des dépendances nécessaires pour exécuter une application spécifique. Tant qu'il peut exécuter Docker, il devrait pouvoir exécuter tous les conteneurs Docker.

Cela facilite la gestion des dépendances et simplifie également la gestion des versions des applications. Les systèmes hôtes et les équipes d'exploitation ne sont plus responsables de la gestion des besoins de dépendance d'une application car, à l'exception de la dépendance aux conteneurs associés, ils doivent tous être contenus dans le conteneur lui-même.

Environnements d'exécution extrêmement légers et isolés

Bien que les conteneurs n'offrent pas le même niveau d'isolation et de gestion des ressources que les technologies de virtualisation, ils gagnent en échange un environnement d'exécution extrêmement léger. Les conteneurs sont isolés au niveau du processus, partageant le noyau de l'hôte. Cela signifie que le conteneur lui-même n'inclut pas de système d'exploitation complet, ce qui entraîne des temps de démarrage presque instantanés. Les développeurs peuvent facilement exécuter des centaines de conteneurs à partir de leur poste de travail sans problème.

Superposition partagée

Les conteneurs sont légers dans un sens différent dans la mesure où ils sont engagés en « couches ». Si plusieurs conteneurs sont basés sur la même couche, ils peuvent partager la couche sous-jacente sans duplication, ce qui réduit au minimum l'utilisation de l'espace disque pour les images ultérieures.

Composabilité et prévisibilité

Les fichiers Docker permettent aux utilisateurs de définir les actions exactes nécessaires pour créer une nouvelle image de conteneur. Cela vous permet d'écrire votre environnement d'exécution comme s'il s'agissait de code, en le stockant dans le contrôle de version si nécessaire. Le même fichier Docker construit dans le même environnement produira toujours une image de conteneur identique.

Utilisation de Dockerfiles pour des builds reproductibles et cohérents

Bien qu'il soit possible de créer des images de conteneur à l'aide d'un processus interactif, il est souvent préférable de placer les étapes de configuration dans un Dockerfile une fois que les étapes nécessaires sont connues. Les Dockerfiles sont des fichiers de construction simples qui décrivent comment créer une image de conteneur à partir d'un point de départ connu.

Les Dockerfiles sont incroyablement utiles et assez faciles à maîtriser. Certains des avantages qu'ils offrent sont :

• Gestion facile des versions : les Dockerfiles eux-mêmes peuvent être affectés au contrôle de version pour suivre les modifications et annuler les erreurs
• Prédicatabilité : la création d'images à partir d'un Dockerfile permet d'éliminer les erreurs humaines du processus de création d'images.
• Responsabilité : si vous envisagez de partager vos images, il est souvent judicieux de fournir le Dockerfile qui a créé l'image afin que d'autres utilisateurs puissent auditer le processus. Il fournit essentiellement un historique des commandes des étapes suivies pour créer l'image.
• Flexibilité : la création d'images à partir d'un Dockerfile vous permet de remplacer les valeurs par défaut attribuées aux versions interactives. Cela signifie que vous n'avez pas besoin de fournir autant d'options d'exécution pour que l'image fonctionne comme prévu.

Les Dockerfiles sont un excellent outil pour automatiser la création d'images de conteneurs afin d'établir un processus reproductible.

L'architecture des applications conteneurisées

Lors de la conception d'applications à déployer dans des conteneurs, l'un des premiers sujets de préoccupation est l'architecture réelle de l'application. Généralement, les applications conteneurisées fonctionnent mieux lors de la mise en œuvre d'une conception orientée services.

Les applications orientées services divisent la fonctionnalité d'un système en composants discrets qui communiquent entre eux via des interfaces bien définies. La technologie des conteneurs elle-même encourage ce type de conception car elle permet à chaque composant d'évoluer ou de se mettre à niveau indépendamment.

Les applications mettant en œuvre ce type de conception doivent avoir les qualités suivantes :

• Ils ne doivent pas se soucier ou se fier aux spécificités du système hôte
• Chaque composant doit fournir des API cohérentes que les consommateurs peuvent utiliser pour accéder au service
• Chaque service doit s'inspirer des variables environnementales lors de la configuration initiale
• Les données d'application doivent être stockées à l'extérieur du conteneur sur des volumes montés ou dans des conteneurs de données

Ces stratégies permettent à chaque composant d'être remplacé ou mis à niveau indépendamment tant que l'API est maintenue. Ils se prêtent également à une évolutivité horizontale ciblée en raison du fait que chaque composant peut être mis à l'échelle en fonction du goulot d'étranglement rencontré.

Plutôt que de coder en dur des valeurs spécifiques, chaque composant peut généralement définir des valeurs par défaut raisonnables. Le composant peut les utiliser comme valeurs de secours, mais doit préférer les valeurs qu'il peut collecter à partir de son environnement. Ceci est souvent accompli à l'aide d'outils de découverte de service, que le composant peut interroger lors de sa procédure de démarrage.

Retirer la configuration du conteneur réel et la placer dans l'environnement permet de modifier facilement le comportement de l'application sans reconstruire l'image du conteneur. Cela permet également à un seul paramètre d'influencer plusieurs instances d'un composant. En général, la conception orientée services s'associe bien aux stratégies de configuration environnementale, car les deux permettent des déploiements plus flexibles et une mise à l'échelle plus simple.

Utilisation d'un registre Docker pour la gestion des conteneurs

Une fois que votre application est divisée en composants fonctionnels et configurée pour répondre de manière appropriée aux autres conteneurs et indicateurs de configuration dans l'environnement, l'étape suivante consiste généralement à rendre vos images de conteneur disponibles via un registre. Le téléchargement d'images de conteneurs dans un registre permet aux hôtes Docker de dérouler l'image et de lancer des instances de conteneur en connaissant simplement le nom de l'image.

Il existe différents registres Docker disponibles à cet effet. Certains sont des registres publics où n'importe qui peut voir et utiliser les images qui ont été validées, tandis que d'autres registres sont privés. Les images peuvent être étiquetées afin qu'elles soient faciles à cibler pour les téléchargements ou les mises à jour.

Conclusion

Docker fournit le bloc de construction fondamental nécessaire aux déploiements de conteneurs distribués. En regroupant les composants d'application dans leurs propres conteneurs, la mise à l'échelle horizontale devient un simple processus de démarrage ou d'arrêt de plusieurs instances de chaque composant. Docker fournit les outils nécessaires non seulement pour créer des conteneurs, mais également pour les gérer et les partager avec de nouveaux utilisateurs ou hôtes.

Bien que les applications conteneurisées fournissent l'isolation et le conditionnement des processus nécessaires pour faciliter le déploiement, de nombreux autres composants sont nécessaires pour gérer et mettre à l'échelle de manière adéquate les conteneurs sur un cluster distribué d'hôtes. Dans notre prochain guide, nous expliquerons comment la découverte de services et les magasins de configuration distribués à l'échelle mondiale contribuent aux déploiements de conteneurs en cluster.