Tutoriel Docker Compose

La popularité de Docker en tant qu'outil de développement est en augmentation. Docker a inspiré une nouvelle vie dans le mouvement des conteneurs. Les développeurs aiment l'utiliser car il est rapide et facile à apprendre. Il aide les équipes de développement à partager des environnements standard sans se soucier de perdre du temps et des ressources.

Les développeurs peuvent configurer l'environnement souhaité dans un conteneur Docker, enregistrer le conteneur comme image et le partager facilement avec leurs équipes de développement. Le processus fonctionne très bien pour un seul conteneur. Cependant, les environnements multi-container sont plus difficiles à maintenir. Docker Compose fournit la solution.

Avec Docker Compose, les développeurs peuvent définir un fichier YAML pour configurer la configuration de plusieurs services. Ensuite, ils peuvent démarrer les services multi-continents avec une seule commande. Il simplifie le processus de travail avec des applications multi-container.

Prérequis

Nous supposons que vous avez une compréhension de base de Docker. Sinon, regardez Comment installer et utiliser Docker sur Ubuntu. Les exemples utilisent WordPress, Mysql, Flask et Python. Cependant, aucune connaissance préalable de ces outils n'est nécessaire.

Docker Compose Process: en un coup d'œil

1. Définir l'environnement d'application: Utilisez dockerfile pour définir l'environnement de l'application pour le rendre facilement reproductible.
2. Définir l'environnement de composition de Docker: Utiliser Docker-Compose.YML pour définir les services dans l'application.
3. Exécuter l'application: Utilisez Docker-Composer pour exécuter l'application multi-container.

Exemple de fichier docker compose

Version: '3'

prestations de service:

DB:

Image: Mysql: 5.7

Volumes:

- db_data: / var / lib / mysql

redémarrer: toujours

environnement:

Mysql_root_password: rootpassword123

Mysql_database: wordpress

Mysql_user: wordpress_user

Mysql_password: wordpress_password

WordPress:

dépend de:

- db

Image: WordPress: Dernière

PORTS:

- "8000: 80"

redémarrer: toujours

environnement:

Wordpress_db_host: db: 3306

Wordpress_db_user: wordpress_user

Wordpress_db_password: wordpress_password

Volumes:

db_data:

Si le docker-compose ci-dessus.Le fichier YML est invoqué avec Docker UP, il créera un service WordPress qui se connecte à un service de base de données MySQL.

Commandes de compose docker

Vous pouvez utiliser docker-compose-help Pour trouver la commande docker compose

Quand utiliser docker compose?

Actuellement, Docker est principalement utilisé dans les environnements de développement. Certaines des utilisations populaires de Docker Compose sont:

1. Prototypage et développement

Le processus de prototypage et de développement des applications est ralenti en raison du manque d'environnements standard. Les développeurs doivent souvent perdre du temps à installer le même environnement plusieurs fois. De plus, la lecture des guides pour configurer les paramètres de l'environnement prend du temps.

Docker Compose simplifie le processus. Une fois un environnement configuré, les équipes de développement peuvent partager les fichiers Docker à travers l'organisation. Il peut économiser un temps énorme perdu sur les problèmes de gestion de la configuration.

2. Processus de test et d'automatisation

L'intégration continue et la livraison continue (CI / CD) deviennent des processus standard dans les environnements de développement agile d'aujourd'hui. Les tests automatisés sont un composant important de CI / CD. Docker Compose aide à définir le processus de test automatisé. Toutes les complications du démarrage de nouveaux services peuvent être soigneusement placées dans les fichiers de configuration Docker. Les testeurs peuvent utiliser ces fichiers pour déclencher des services temporaires, exécuter des scripts de texte et détruire les services après avoir collecté les résultats des tests. Il fait gagner du temps car le démarrage manuellement des services est long et sujette aux erreurs.

3. Déploiement de la production future

Docker est principalement utilisé dans les environnements de développement. Cependant, à mesure que les fonctionnalités de Docker deviennent plus robustes, Docker sera utilisé pour plus de travail au niveau de la production. Docker Compose peut être un outil précieux pour les déploiements d'hôtes uniques.

Exercice: une application Web simple

Essayons notre main. Nous utiliserons le framework Web Flask pour créer une application qui communique avec une base de données en mémoire Redis pour suivre le nombre de fois où l'application Web a été visitée.

La structure du répertoire ressemblera à ceci:

Simple_app

├til

│ ├fiques

Code │ └fique

│ ├fique.py

│ └fiques.SMS

└fiques-compose docker.YML

La structure du répertoire ci-dessus n'est pas nécessaire pour une application de base. Cependant, cela montre comment l'organisation des informations peut être utile pour une mise en œuvre plus efficace de Docker Compose.

Étape 1: Créer une structure et des fichiers du répertoire

Créons la structure du répertoire et les fichiers nécessaires:

$ mkdir simple_app

$ mkdir simple_app / contenu

$ mkdir simple_app / contenu / code

$ touch simple_app / docker-compose.YML

$ touch simple_app / contenu / dockerfile

$ touch simple_app / contenu / code / simple_app.py

$ touch simple_app / contenu / code / exigences.SMS

La commande tactile ne fait que créer des fichiers vides. Vous pouvez accéder manuellement dans les dossiers et créer les fichiers.

Étape 2: code d'application Web

Le dossier de code contient le code d'application Web. Mettre ce qui suit Simple_app.py déposer:

De Flask Import Flask

à partir de redis import redis

app = flacon (__ name__)

redis = redis (host = 'redis', port = 6379)

@app.itinéraire('/')

Def Hello ():

Count = redis.incr («coups»)

retour 'Bienvenue à Docker Compose leçons! Vous avez visité ce site fois.\ n '.format (comte)

Si __name__ == "__main__":

appliquer.Run (host = "0.0.0.0 ", debug = true)

L'application ci-dessus crée une page de bienvenue qui affiche le nombre de fois où la page a été visitée. Le compteur de visites est maintenu dans une base de données redis. Redis utilise le port 6379 comme port d'écoute par défaut. Ensuite, remplissez le exigences.SMS déposer:

ballon

redis

Cela permettra à PIP d'installer des dépendances Python sur le conteneur Web. Nous exécuterons PIP dans le cadre de l'initialisation de notre service.

Étape 3: Dockerfile

Rempli le Simple_app / Content / dockerfile avec le code suivant:

De Python: 3.6.3-jessie

AJOUTER ./ code / code

Workdir / code

Exécuter les exigences de l'installation PIP -R.SMS

Cmd ["python", "simple_app.py "]

Ce qui précède Dockerfile réalise ce qui suit:

1. Crée une image à partir de python: 3.6.3-jessie. S'il n'est pas disponible localement, il le télécharge à partir de Docker Hub.
2. Copie les éléments dans Simple_app / Content / Code dans /code sur le conteneur
3. Ensemble /code Comme le répertoire de travail sur le conteneur
4. Utilise PIP pour installer les dépendances Python
5. Définit le point de départ par défaut pour que le conteneur fonctionne Python Simple_App.py.

Étape 4: Docker Compose

Rempli le Simple_app / docker-compose.YML fichier avec le code suivant:

Version: '3'

prestations de service:

la toile:

construire: ./contenu

PORTS:

- "5000: 5000"

Volumes:

- ./ Contenu / Code: / Code

redis:

Image: "Redis: Alpine"

Le composer docker.YML Le fichier définit deux conteneurs: Web et redis. Il utilise le format Docker Compose Version 3.

Pour le service Web:

• Construit le service Web en utilisant Simple_app / Content / dockerfile
• Forme vers le port 5000 du conteneur web au port de l'hôte 5000. Le port 5000 est le port par défaut pour les applications Flask.
• Volume Simple_app / Content / Code est monté comme /code sur le conteneur. Cela signifie que si vous changez quelque chose dans le Simple_app / Content / Code, il sera reflété dans /code dossier sur le conteneur web.

Pour le service redis:

• Utilise l'image Redis: Alpine de Docker Hub pour créer le service redis.

Étape 5: Exécution des applications à l'aide de Docker Compose

La demande est prête pour le déploiement. Du Simple_app dossier, exécutez la commande suivante:

$ docker-compose

La sortie doit démarrer comme ceci:

$ docker-compose

Bâtiment Web

Étape 1/5: de Python: 3.6.3-jessie

3.6.3-Jessie: Tirer de la bibliothèque / Python

85b1f47fba49: téléchargement [==========>] 12.43 Mo / 52.6 Mo

5409E9A7FA9E: Télécharger Complete

661393707836: Téléchargement [==============>] 13.71 Mo / 43.23 Mo

1BB98C08D57E: Téléchargement [>] 1.081MB / 134.7 Mo

…

Une fois toutes les images construites et en cours d'exécution, vous devriez voir ce qui suit:

Statut: Image plus récente téléchargée pour Redis: Alpine

Création de Simpleapp_redis_1…

Création de SimpleApp_Web_1…

Création de Simpleapp_redis_1

Création de SimpleApp_Web_1… fait

Piètement à Simpleapp_redis_1, SimpleApp_web_1

redis_1 | 1: M 21 octobre 02:06:33.639 * Prêt à accepter les connexions

web_1 | * Courir sur http: // 0.0.0.0: 5000 / (Appuyez sur Ctrl + C pour quitter)

web_1 | * Redémarrer avec STAT

web_1 | * Le débogueur est actif!

web_1 | * Pin de débogueur: 237-189-083

Vous pouvez tester l'application en allant sur http: // localhost: 5000:. Si vous actualisez la page plusieurs fois, cela devrait refléter le nombre de visites. Vous pouvez vérifier l'état des services ou des conteneurs en cours d'exécution:

$ docker ps

Commande d'image d'ID de conteneur Image Créé les noms de ports d'état

22852E0AD98A Redis: Alpine "Docker-Entrypoint…" Il y a 5 minutes en haut de 5 minutes 6379 / TCP Simpleapp_redis_1

d51739d0a3ac simleapp_web "python simple_app.py "il y a 5 minutes en haut de 5 minutes 0.0.0.0: 5000-> 5000 / TCP SIMPEAPP_WEB_1

Si vous démarrez un shell bash dans SimpleApp_Web_1 (votre nom de conteneur peut différer), vous serez connecté au répertoire de travail / code:

$ docker exec -it Simpleapp_web_1 bash

root @ d51739d0a3ac: / code # ls

exigences.txt simple_app.py

root @ d51739d0a3ac: / code #

Le /code Le répertoire devrait refléter le contenu de Simple_app / Content / Code à l'intérieur comme vu ci-dessus (Simple_app.py et exigences.SMS).

Si vous mettez à jour votre Simple_app.pyLigne de:

retour 'Bienvenue à Docker Compose leçons! Vous avez visité ce site fois.\ n '.format (comte)

Pour:

retour 'Bienvenue à Docker Compose leçons! Êtes-vous intrigué? Vous avez visité ce site fois.\ n '.format (comte)

Il devrait réfléchir sur http: // localhost: 5000:

Étape 6: Arrêt des services

Vous pouvez arrêter l'application en utilisant:

$ docker-compose stop

Arrêt SimpleApp_redis_1… fait

Arrêt SimpleApp_Web_1… fait

Les volumes montés persisteront. Vous pouvez supprimer entièrement les conteneurs incluant les volumes en utilisant la commande suivante.

$ docker-compose - Volume

Supprimer SimpleApp_redis_1… fait

Supprimer SimpleApp_Web_1… fait

Suppression du réseau Simpleapp_default

Toutes nos félicitations! Vous maîtrisez les bases de Docker Compose.

Une étude plus approfondie

Pour une étude plus approfondie, regardez la documentation suivante:

• Documentation Docker
• Docker compose la référence du fichier
• Docker Compose Networking

Les références:

• https: // docs.docker.com / compose / aperçu / # Développement-environnements
• https: // docs.docker.com / compose / getStarted /
• https: // blog.codes.com / orchestrate-continers-for-développement-with-docker-compose /
• https: // www.sumologique.com / blog / devops / comment-to-build-applications-docker-compose /
• https: // docs.docker.com / compose / wordpress / # define-the-project