Tuto Docker | Gérer vos container avec Docker compose

Article publiée le 10 Février 2017

Après mon tuto sur Docker (http://journaldunadminlinux.fr/tuto-docker-demarrer-avec-docker/) je continue dans ma lancée en vous présentant l’outil docker-compose. Docker-compose est un outil officiel Docker  absolument génial qui permet de gérer à 100% vos container uniquement avec un fichier de configuration yml. Cet outil est d’autant plus pratique si vos applications nécessite l’installation de plusieurs containers pour fonctionner.

I) Installation

L’installation est très simple (curl doit être installé sur votre machine):

curl -L https://github.com/docker/compose/releases/download/1.11.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

chmod +x /usr/local/bin/docker-compose

 

La commande docker-compose doit fonctionner:

 

2) Utiliser Docker Compose

Pour vous montrer comment fonctionne docker-compose je vais prendre comme exemple l’installation d’un GITLAB complet sous Docker (base de données + application).

Après une petite recherche, on trouve facilement un template d’une configuration docker-compose.yml:

version: ‘2’

services:
redis:
restart: always
image: sameersbn/redis:latest
command:
– –loglevel warning
volumes:
– /srv/docker/gitlab/redis:/var/lib/redis:Z

postgresql:
restart: always
image: sameersbn/postgresql:9.6-2
volumes:
– /srv/docker/gitlab/postgresql:/var/lib/postgresql:Z
environment:
– DB_USER=gitlab
– DB_PASS=password
– DB_NAME=gitlabhq_production
– DB_EXTENSION=pg_trgm

gitlab:
restart: always
image: sameersbn/gitlab:8.16.4
depends_on:
– redis
– postgresql
ports:
– « 10080:80 »
– « 10022:22″
volumes:
– /srv/docker/gitlab/gitlab:/home/git/data:Z
environment:
– DEBUG=false

– DB_ADAPTER=postgresql
– DB_HOST=postgresql
– DB_PORT=5432
– DB_USER=gitlab
– DB_PASS=password
– DB_NAME=gitlabhq_production

– REDIS_HOST=redis
– REDIS_PORT=6379

– TZ=Asia/Kolkata
– GITLAB_TIMEZONE=Kolkata

– GITLAB_HTTPS=false
– SSL_SELF_SIGNED=false

– GITLAB_HOST=localhost
– GITLAB_PORT=10080
– GITLAB_SSH_PORT=10022
– GITLAB_RELATIVE_URL_ROOT=
– GITLAB_SECRETS_DB_KEY_BASE=long-and-random-alphanumeric-string
– GITLAB_SECRETS_SECRET_KEY_BASE=long-and-random-alphanumeric-string
– GITLAB_SECRETS_OTP_KEY_BASE=long-and-random-alphanumeric-string

– GITLAB_ROOT_PASSWORD=
– GITLAB_ROOT_EMAIL=

– GITLAB_NOTIFY_ON_BROKEN_BUILDS=true
– GITLAB_NOTIFY_PUSHER=false

– GITLAB_EMAIL=notifications@example.com
– GITLAB_EMAIL_REPLY_TO=noreply@example.com
– GITLAB_INCOMING_EMAIL_ADDRESS=reply@example.com

– GITLAB_BACKUP_SCHEDULE=daily
– GITLAB_BACKUP_TIME=01:00

– SMTP_ENABLED=false
– SMTP_DOMAIN=www.example.com
– SMTP_HOST=smtp.gmail.com
– SMTP_PORT=587
– SMTP_USER=mailer@example.com
– SMTP_PASS=password
– SMTP_STARTTLS=true
– SMTP_AUTHENTICATION=login

– IMAP_ENABLED=false
– IMAP_HOST=imap.gmail.com
– IMAP_PORT=993
– IMAP_USER=mailer@example.com
– IMAP_PASS=password
– IMAP_SSL=true
– IMAP_STARTTLS=false

– OAUTH_ENABLED=false
– OAUTH_AUTO_SIGN_IN_WITH_PROVIDER=
– OAUTH_ALLOW_SSO=
– OAUTH_BLOCK_AUTO_CREATED_USERS=true
– OAUTH_AUTO_LINK_LDAP_USER=false
– OAUTH_AUTO_LINK_SAML_USER=false
– OAUTH_EXTERNAL_PROVIDERS=

– OAUTH_CAS3_LABEL=cas3
– OAUTH_CAS3_SERVER=
– OAUTH_CAS3_DISABLE_SSL_VERIFICATION=false
– OAUTH_CAS3_LOGIN_URL=/cas/login
– OAUTH_CAS3_VALIDATE_URL=/cas/p3/serviceValidate
– OAUTH_CAS3_LOGOUT_URL=/cas/logout

– OAUTH_GOOGLE_API_KEY=
– OAUTH_GOOGLE_APP_SECRET=
– OAUTH_GOOGLE_RESTRICT_DOMAIN=

– OAUTH_FACEBOOK_API_KEY=
– OAUTH_FACEBOOK_APP_SECRET=

– OAUTH_TWITTER_API_KEY=
– OAUTH_TWITTER_APP_SECRET=

– OAUTH_GITHUB_API_KEY=
– OAUTH_GITHUB_APP_SECRET=
– OAUTH_GITHUB_URL=
– OAUTH_GITHUB_VERIFY_SSL=

– OAUTH_GITLAB_API_KEY=
– OAUTH_GITLAB_APP_SECRET=

– OAUTH_BITBUCKET_API_KEY=
– OAUTH_BITBUCKET_APP_SECRET=

– OAUTH_SAML_ASSERTION_CONSUMER_SERVICE_URL=
– OAUTH_SAML_IDP_CERT_FINGERPRINT=
– OAUTH_SAML_IDP_SSO_TARGET_URL=
– OAUTH_SAML_ISSUER=
– OAUTH_SAML_LABEL= »Our SAML Provider »
– OAUTH_SAML_NAME_IDENTIFIER_FORMAT=urn:oasis:names:tc:SAML:2.0:nameid-format:transient
– OAUTH_SAML_GROUPS_ATTRIBUTE=
– OAUTH_SAML_EXTERNAL_GROUPS=
– OAUTH_SAML_ATTRIBUTE_STATEMENTS_EMAIL=
– OAUTH_SAML_ATTRIBUTE_STATEMENTS_NAME=
– OAUTH_SAML_ATTRIBUTE_STATEMENTS_FIRST_NAME=
– OAUTH_SAML_ATTRIBUTE_STATEMENTS_LAST_NAME=

– OAUTH_CROWD_SERVER_URL=
– OAUTH_CROWD_APP_NAME=
– OAUTH_CROWD_APP_PASSWORD=

– OAUTH_AUTH0_CLIENT_ID=
– OAUTH_AUTH0_CLIENT_SECRET=
– OAUTH_AUTH0_DOMAIN=

– OAUTH_AZURE_API_KEY=
– OAUTH_AZURE_API_SECRET=
– OAUTH_AZURE_TENANT_ID=

 

Le fichier docker-compose ci-dessus va créer 3 container: deux container pour GITLAB et un pour PostgresSQL. Le fichier contient tout les paramètres de connexions à la base données, de l’applicatif, réseau (avec le mapping des ports) ainsi que le répertoire des volumes persistants très utile notamment pour les tablespaces de la base de données PostGRESQL.

 

Une fois le fichier docker-compose adapté à vos besoins, il ne reste plus qu’à builder vos container. Pour cela veillez à être dans le répertoire contenant votre fichier docker-compose.yml puis lancez la commande suivante pour builder les containers:

docker-compose up -d

On vérifie la présence des containers:

Comme prévus, trois containers ont été créés: un pour la base de données et deux pour GITLAB).

Dans le fichier docker-compose.yml (aussi via votre docker ps -a) il est indiqué que le port 80 du container est mappé sur le port 10080 accessible depuis l’extérieur.

Il ne reste plus qu’à tester (http://ip ou DNS de votre machine :10080):

3) Les commandes utiles

Les commandes ci-dessous sont à utiliser quand vous êtes positionné dans le répertoire contenant le  fichier docker-compose.yml:

Stopper le/les containers
docker-compose stop

Démarrer le/les containers
docker-compose start

Supprimer le/les containers
docker-compose rm

Builder le/les Containers
docker-compose up -d

Check des logs
docker logs -f <nom de container>




Tuto Docker | Démarrer avec Docker

Article publié le 09/02/2017

Mis à jour le 22/08/2018

Après pas mal de temps, j’ai enfin décidé à me mettre à étudier Docker. Étant très hésitant au départ, je me suis vite aperçu que Docker est un outil extrêmement puissant, flexible avec un potentiel Devops incroyable.

La question que se posent beaucoup de personnes est: qu’est-ce que c’est Docker? Contrairement à la virtualisation classique ou vous virtualisez l’intégralité de la machine et tout se qu’elle héberge, Docker n’héberge  que les applications et les librairies!

I) Installation

Sous Debian: 

On ajoute les dépôts docker et on installe:

sudo apt-get install apt-transport-https ca-certificates curl gnupg2 software-properties-common
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add –
sudo add-apt-repository « deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable »
sudo apt-get update
sudo apt-get install docker-ce

systemctl enable docker
systemctl start docker

Sous Centos:

On ajoute les dépôts docker et on installe:

sudo yum install -y yum-utils device-mapper-persistent-data lvm2
sudo yum-config-manager –add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo yum install docker-ce
systemctl enable docker
systemctl start docker
Afin de nous faciliter la vie, on attribue les droits à notre utilisateur pour éviter de bosser avec root.
usermod -a -G docker  <votre user>

 II) Création d’un container

Dans l’exemple ci-dessous, on va chercher une image nginx:

docker search nginx

On rapatrie l’image sur notre machine :

docker pull nginx

On vérifie notre liste d’images:

docker images

On s’aperçoit que notre image nginx a bien été rapatrié:

On installe le container

docker run -d –name=ServeurNginx nginx:latest

On vérifie que le container est bien installé:

docker ps  -a

On démarre notre container:

docker start <container id>

docker start 1f8b15c5b642

Nous allons maintenant inspecter la configuration de notre container afin de déterminer l’adresse IP local du container:

docker inspect <id du container>

Vous verrez toutes les informations de votre container et notamment un élément qui nous intéresse:

  « IPAddress »: « 172.17.0.2 »,
« IPPrefixLen »: 16,

L’IP ci-dessus correspond à l’interface virtuel  de votre container. Si vous tentez de vous connecter en HTTP via l’adresse de votre container, le serveur nginx hébergé dans votre container va répondre:

elinks 172.0.0.2

Bon j’imagine que vous allez me poser la question suivante: « comment on fait pour que notre container soit accessible de l’extérieur? »

Pour cela rien de plus simple, nous allons créer un deuxième container depuis l’image nginx avec quelques arguments en plus:

 docker run -d -p 9876:80 –name=Webserver3 nginx:latest

Votre container sera joignable via le port 9876 depuis l’extérieur:

Allons encore un peu plus loin en mappant des répertoires internes de votre container directement sur un répertoire de votre serveur (par exemple pour mettre à jour le contenu d’un site web hébergé dans votre container).
docker run -d -p 9876:80 –name=WebServer4 -v /home/usr/www:/usr/share/nginx/html nginx:latest

III) DockerFile

Il est possible avec Docker de créer un container  à partir d’un fichier de configuration nommé Dockerfile.

Pour cela créer un fichier nommé Dockerfile.

Dans notre fichier nous allons créer un container Debian et installer un serveur apache2 accessible depuis l’extérieur.

Ci-dessous le contenu du Dockerfile

# Image
FROM debian:stable
#Information sur le propriétaire du container
MAINTAINER vdahmane@gmail.com
# Commande RUN utilisé uniquement lors de la creation du container (necessite un docker build)
RUN apt-get update && apt-get upgrade -y && apt-get install -y apache2 telnet  elinks openssh-server
# Creation variable
ENV VARIABLE ma-variable
# PORT 80 Ouvert
EXPOSE  80
# On expose le port SSH pour pouvoir se connecter sur la machine
EXPOSE 22
# Commande passé une fois le container créé (ne neccessite pas un docker build juste un run)
#     Commande               1er arg 2eme arg
CMD [« /usr/sbin/apache2ctl », »-D », »FOREGROUND »]
Reste plus qu’à créer notre container depuis le Dockerfile.
On crée notre image Docker:
docker build -t myapache .
On installe notre container:
docker run -d -P 9999:80 –name=Debianapache myapache:latest
Il ne reste plus qu’à vérifier via l’IP de votre serveur Docker si le serveur apache est accessible:

IV) Autre commandes utiles

Supprimer tout les container actifs:
docker rm `docker ps -a -q`
Démarrer ou arrêter un container :
docker start <container>
docker stop <container>
Supprimer tout les container actif:
docker rm `docker ps -a -q`
Supprimer une image docker (vérifier qu’aucun container n’est actif):
docker rmi <image>
Vous connecter directement sur votre container:
docker run -it <votre container> /bin/bash

VI) Repository

Le repository docker https://hub.docker.com/explore/ contient toutes les images dockers possible et imaginable. Vous pouvez aussi bien trouver des container apache que nginx voir même des images de distributions Linux comme Centos ou Debian. Je vous suggère de créer un compte et d’y  aller faire un tour.

Un tuto pour créer votre propre Registry Docker est disponible ici

VII) Docker Compose

Docker-compose est un outil officiel Docker  absolument génial qui permet de gérer à 100% vos container uniquement un fichier de configuration yml. Cet outil est d’autant plus pratique si vos applications nécessite l’installation de plusieurs containers pour fonctionner.

Le tutoriel sur docker-compose est disponible ici:

Tuto Docker | Gérer vos container avec Docker compose

VIII) Docker Swarm

Docker swarm est l’orchestrateur de container officiel Docker. Un tutoriel sur son déploiement est disponible:

Tutoriel | Installer et utiliser DockerSwarm

IX) Registry Privé

Un tutoriel sur l’installation d’un registry privé Docker est disponible:

Tutoriel | Installation, configuration et utilisation d’un Docker Registry

X) Kubernetes

Kubernetes est un puissant orchestrateur de container extrêmement utilisé aujourd’hui. Un tutoriel sur son déploiement est disponible:

Tutoriel | Installez facilement un cluster Kubernetes sous Debian ou Centos

XI) Portainer

Portainer est un outil puissant permettant de gérer vos environnement Docker via une interface Web extrêmement simple d’utilisation:

Tutoriel | Gérez vos container docker avec Portainer