Générez automatiquement vos fichiers docker compose avec docker-autocompose

Article publié le 17 Février 2020.

 

J’ai découvert aujourd’hui un petit outil fortement sympathique qui pourrait servir à beaucoup de monde: docker-autocompose

Docker-autocompose permet de générer à partir d’un container existant le fichier docker-compose associé ce qui peut faire gagner du temps et s’avérer très pratique.

1) Prérequis

Docker-autocompose est codé en python, de ce fait il est nécessaire d’avoir les modules suivants d’installés:

  • pyaml
  • docker-py
  • setup-tools

Une petite installation via le gestionnaire de paquet de votre distribution ou via pip suffira.

2) Installation

L’adresse du repository git du projet:  https://github.com/Red5d/docker-autocompose

– Cloner le repo:

git clone https://github.com/Red5d/docker-autocompose

– Exécutez le script d’installation situé dans le répertoire docker-autocompose:

chmod 700 *.py && sudo python setup.py && sudo cp autocompose.py /usr/local/bin

– Testez votre installation

3) Fonctionnement

Maintenant nous allons tester le fonctionnement de cet outil fort sympathique.

– Nous allons, dans un premier temps, pour alimenter notre test, créer un container nginx:

docker run -d -p 80:80 nginx

– On vérifie que notre container tourne correctement:

docker ps -a

– Enfin on génère le docker-compose (commande: autocompose.py <nom ou id de votre container>):

autocompose.py busy_heyrovsky

 

Enjoy 😉




Tutoriel | Installez facilement un cluster Kubernetes sous Debian ou Centos

Article publié le 20 Août 2018

Aujourd’hui un petit tutoriel sur l’installation d’un Cluster Kubernetes. La procédure ci-dessous vous indiquera la méthode la plus simple pour installer Kubernetes.

Pour exemple et également pour tester ce tutoriel, mon cluster sera composé d’un master et de deux workers.

 

1)  Installation sous Debian/Ubuntu

– Installez la version de Docker supporté par Kubernetes (sur chaque node):

apt-get update
apt-get install -y apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add –
add-apt-repository « deb https://download.docker.com/linux/$(. /etc/os-release; echo « $ID ») $(lsb_release -cs) stable »
apt-get update && apt-get install -y docker-ce=$(apt-cache madison docker-ce | grep 17.03 | head -1 | awk ‘{print $3}’)

 

– Activez le démarrage automatique de Docker (sur chaque nodes) :

systemctl enable docker

– Paramétrez Docker afin qu’il utilise exclusivement systemd, pour cela éditez le fichier /etc/docker/daemon.json et ajoutez  le contenu suivant avant de redémarrer le service Docker (sur chaque nodes):

{

« exec-opts »: [« native.cgroupdriver=systemd »]

}

– Ajoutez les repo Kubernetes (sur chaque nodes):

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add –
cat <<EOF >/etc/apt/sources.list.d/kubernetes.list
deb http://apt.kubernetes.io/ kubernetes-xenial main
EOF
apt-get update

– Désactivez le swap (sur chaque nodes)

swapoff -a

 N’oubliez pas de commenter la ligne dans le fstab

– Installez les outils Kubernetes (sur chaque nodes)

apt-get install kubelet kubeadm kubectl

– Initialisez le cluster (sur le master  uniquement)

kubeadm init –pod-network-cidr=10.244.0.0/16

Faites ce qui est indiqué à l’écran et gardez dans un coin la commande « kubeadm join » qui nous permettra plus tard de rattacher des workers à notre Cluster.

– Installez les composants network Kubernetes (sur le master  uniquement)

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/v0.9.1/Documentation/kube-flannel.yml

– Vérifiez que l’installation se soit bien passé

kubectl get pods –all-namespaces

– Sur chaque worker lancez la commande « kubeadm join » que vous avez gardé dans un coin

– Depuis le master lancez la commande suivante afin de vérifier que vos nodes ont bien rejoins le cluster

kubectl get nodes

2) Installation sous Centos/RedHat

– Appliquez les dernière mises à jour de l’OS (sur chaque nodes):

yum update -y

– Désactiver SeLinux durant l’installation (sur chaque nodes):

setenforce 0

– Installez Docker

yum install -y docker

– Activez le démarrage automatique de Docker (sur chaque nodes) :

systemctl enable docker

– Ajoutez le repository Kubernetes (sur chaque nodes):

cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
exclude=kube*
EOF

– Installez Kubernetes (sur chaque nodes):

yum install -y kubelet kubeadm kubectl –disableexcludes=kubernetes

– Ajoutez les paramètres sysctl suivant (sur chaque nodes):

cat <<EOF > /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
sysctl –system

– Désactivez le swap (sur chaque nodes)

swapoff -a

 N’oubliez pas de commenter la ligne dans le fstab

– Initialisez le cluster Kubernetes(sur le master  uniquement) :

kubeadm init –pod-network-cidr=10.244.0.0/16

Faites ce qui est indiqué à l’écran et gardez dans un coin la commande « kubeadm join » qui nous permettra plus tard de rattacher des workers à notre Cluster.

– Installez les composants network Kubernetes (sur le master  uniquement)

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/v0.9.1/Documentation/kube-flannel.yml

– Vérifiez que l’installation se soit bien passé

kubectl get pods –all-namespaces

– Sur chaque worker lancez la commande « kubeadm join » que vous avez gardé dans un coin

– Depuis le master lancez la commande suivante afin de vérifier que vos nodes ont bien rejoins le cluster

kubectl get nodes

 

Enjoy! 😉




Tutoriel | Installer et utiliser DockerSwarm

Article publié le 15 Août 2018

Docker Swarm est un outil conçu par Docker permettant de gérer un cluster de Container très facilement. En plus d’être simple à implémenter, Docker Swarm est extrêmement performant. Il peut supporter mille noeuds et cinquante mille container sans aucune dégradation de performance.

Ci-dessous un tutoriel complet sur comment installer et utiliser DockerSwarm.

 

1) Prérequis

Pour ce tutoriel, je vais utiliser 3 machines (la distribution importe peu)

Docker 1.13 ou supérieur doit-être installé sur chaque machine. Pour rappel, un tutoriel sur l’installation de Docker est disponible ici.

 

2) Schéma

Ci-dessous un petit schéma qui résume très simplement le concept de Swarm et de ce que l’on va mettre en place avec ce tuto:

3) Création du Cluster Swarm

Un cluster swarm est composé de Managers chargés de l’orchestration du cluster et des Workers qui exécutent vos containers.

– Initialisation du cluster Swarm (la machine ou le cluster swarm sera initialisé deviendra Manager):

docker swarm init –advertise-addr <ip du host>

La commande devrait vous renvoyer quelque chose comme ci-dessous:

– Suivez les instructions en faisant un copier-coller de la commande sur chaque node (host) qui servira de worker:

– Vous pouvez vérifier l’état de votre cluster Swarm grâce à cette commande (à exécuter depuis le manager):

docker node ls

4) Création d’un service

Avec swarm nous allons beaucoup parler de service. Un service est, pour ainsi dire, le point d’entré de votre application. Un service est composé de 1-N container et apporte une dimension de clustering, de fault tolérance et de haute disponibilité à votre environnement docker.

– Dans l’exemple ci-dessous, nous allons créer un service httpd (apache) nommé « monserveurweb »:

docker service create –name monserveurweb –publish 80:80 httpd

– Vérifiez ensuite l’état de votre service:

docker service ls

Au final, vous devriez avoir un truc comme ceci:

Vous pourrez constater que si vous tapez http://<ip de votre manager ou d’un node> depuis votre navigateur que le serveur apache hébergé dans le container répond bien!

 

4.2) Scalabilité

En faisant un docker service ls, vous pouvez voir que le nombre de replica est à 1. Cela signifie qu’un seul container a été provisionné et déployé dans votre cluster. Il est possible d’augmenter le nombre de replica via cette commande:

docker service update –replicas <nombre de replica> <nom de votre service>

ou

docker service scale <nom de votre service>=<nombre de replicas>        (l’avantage avec cette commande est que vous pouvez modifier plusieurs service d’un seul coup)

Si l’on refait un « docker service ls » on pourra voir que le nombre de replicas a augmenté:

Pour rappel, votre manager fera lui même le loadbalancing entre chacun de vos replicas.

Vous pouvez avoir une vue détaillé de l’endroit où sont hébergés chacun de vos replicas grâce à cette commande

docker service ps <id de votre service>

Exemple:

 

4.3) Ajouter un manager

Vous l’aurez compris, le manager est un élément critique de votre cluster Swarm. Il est très fortement conseillé d’en avoir plusieurs afin de limiter au maximum le risque d’incidents critiques.

Pour créer un nouveau manager (qui sera un manager en standby):

– Récupérez le token:

docker swarm join-token manager

– Copiez-collez la commande qui vous est indiquée sur le host qui vous servira de manager

– En faisant un « docker node ls » vous pouvez voir votre nouveau node avec le statut « reachable ». Ce qui voudra dire qu’il prendra le relais en cas de perte du manager.

 Attention toutefois: afin que l’algorithme raft fonctionne bien (ce qui permet l’élection d’un nouveau manager en cas de perte de celui-ci), il est préconisé que le nombre de manager désigné soit impair !

5) Autres fonctionnalités

Ci-dessous quelques fonctionnalités qui pourront vous être fort utile:

  • Exemple de commande pour fixer des quota de  ressources:

docker service update –limit-cpu=.5 –reserve-cpu=.75 –limit-memory=128m –reserve-memory=256 monserveurweb

  • Les labels:

Cette fonctionnalité vous permettra de « tagger » vos nodes et vos services. Cela vous sera très utile; par exemple, si vous voulez que certains services se déploient sur certain nodes:

– Affecter un label à un node

docker node update –label-add nodelabel=<nom du label> <id de votre node>

– Créer un service qui sera déployé sur un node en fonction de son label:

docker service create –name <nom du service> –constraints ‘node.labels.nodelabel=='<nom du label>’  <nom de l’image>

  • Supprimer un node:

– Sur votre node tapez la commande suivante:

docker swarm leave

– Depuis le manager tapez la commande suivante:

docker node rm <id de votre node>

  • Swarm et docker-compose

– Il est possible de créer un service depuis un yaml docker-compose grâce à cette commande:

docker stack deploy –compose-file <fichiercompose.yml> <nom service>

 




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

Article publié le 13 Août 2018

Ce tutoriel complet expliquera comment installer, configurer, et utiliser un Docker Registry.

Pour suivre ce tutoriel, Docker doit-être installé sur votre machine. Un tutoriel vous expliquant comment installer Docker est disponible ici.

Nous allons travailler dans le répertoire /srv/myrepo.com et pour servir d’exemple l’adresse de notre repository sera myrepo.com. Le fichier host sera renseigné de tel manière à ce que l’IP de ma machine soit associé au nom myrepo.com.

– Dans notre répertoire de travail, nous allons créer deux répertoires:

mkdir -p /srv/myrepo.com/certs

mkdir -p /srv/myrepo.com/auth

– Nous allons ensuite généré dans le répertoire /srv/myrepo.com/certs un certificat TLS:

cd /srv/myrepo.com/certs && openssl req -x509 -newkey rsa:4096 -nodes -keyout myrepo.com.key -out myrepo.com.crt -days 365 -subj /CN=myrepo.com

– En faisans un « ls » vous devriez voir la clé privée plus le certificat:

– Copiez ensuite le crt dans le répertoire /etc/docker/certs.d/myrepo.com (pour rappel myrepo.com correspond au nom de votre repo)

sudo mkdir -p /etc/docker/certs.d/myrepo.com:5000 && cp /srv/myrepo.com/certs/myrepo.com.crt /etc/docker/certs.d/myrepo.com\:5000/

– Faites un pull de l’image Docker registry:

docker pull registry:2

– Générez ensuite un fichier htpasswd contenant le login et le mot de passe qui permettra de vous authentifier:

docker run –entrypoint htpasswd registry:2 -Bbn votrelogin votrepassword > /srv/myrepo.com/auth/htpasswd

– Lancez le container Docker Registry:

docker run -d -p 5000:5000 -v /srv/myrepo.com/certs:/certs -e REGISTRY_HTTP_TLS_CERTIFICATE=/certs/myrepo.com.crt -e REGISTRY_HTTP_TLS_KEY=/certs/myrepo.com.key -v /srv/myrepo.com/auth:/auth -e REGISTRY_AUTH_HTPASSWD_REALM= »Registry Realm » -e REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd registry:2

– Authentifiez-vous sur votre registry

docker login

Si l’authentification se déroule bien vous devriez avoir quelque chose comme ceci:

– Testez que votre repository fonctionne correctement.

  • Pour cela, on va faire un pull d’une image (busybox):

docker pull busybox

  • Taggez ensuite l’image pour la faire pointer vers votre registry

docker tag busybox myrepo.com:5000/testimage

  • Pushez l’image vers votre registry

docker push busybox myrepo.com:5000/testimage

 

 Dans ce tuto, le certificat utilisé est un certificat auto-signé. Si vous voulez utiliser votre registry depuis un autre serveur (ce qui, je pense, sera forcément le cas) il sera nécessaire de copier le répertoire /etc/docker/certs.d/myrepo.com\:5000/ sur chaque machine qui devra se connecter à votre registry et redémarrer le service Docker. Si vous ne faites pas cela,  vous risquez d’avoir un vilain message d’erreur vous indiquant que votre certificat TLS n’est pas bon…

Lister les images de votre repository:

Pour lister et connaître le contenu de votre repository, utiliser la commande curl suivante:

curl –insecure -u « login password » <URL de votre repository>

–insecure à utiliser si vous utilisez un certificat auto-signé

 




Migrer vos fichier docker compose vers kubernetes avec Kompose

Article publié le 24 Janvier 2018

Mini article rapide pour vous parler de Kompose, un outil fort bien pratique pour convertir vos fichiers docker-compose.yml en yaml Kubernetes. Ceci est fortement appréciable notamment pour ceux qui débutent avec l’écosystème Kubernetes.

Installation

Lancez la commande suivante (n’oubliez pas de checker le numéro de version dans le lien qui peut évoluer dans le temps depuis l’écriture de cet article):

curl -L https://github.com/kubernetes/kompose/releases/download/v1.7.0/kompose-linux-amd64 -o kompose && mv kompose /usr/local/bin && chmod 755 /usr/local/bin/kompose

Utilisation

Dans l’exemple ci-dessous, je vais convertir le docker-compose de jenkins.

Contenu du docker-compose.yml:

version: « 2 »
volumes:
data-jenkins:
driver: « local »
services:
jenkins:
image: « jenkins:2.60.3 »
ports:
– « 8080:8080 »
restart: « always »
volumes:
– « /srv/jenkins:/var/jenkins »

 

Convertissez votre fichier docker-compose avec la commande suivante:

kompose convert -f docker-compose.yml

Dans mon exemple cela donne ceci:

Kompose a créé les fichiers Kubernetes.

Nous allons ensuite tester les fichiers yaml généré en créant un pod Kubernetes avec le service associé:

Nous allons vérifier que tout est déployé correctement:

enjoy 😉




Tutoriel | Déployez facilement un cluster Kubernetes avec Rancher

Article publiée le 13 Janvier 2018

Article mis à jour le 21 Août 2018

Kubernetes est un orchestrateur de container docker extrêmement puissant mais également très fastidieux à déployer. Il existe pourtant un moyen très simple pour déployer Kubernetes en utilisant Rancher.

Rancher est un outil permettant de gérer vos environnements Docker de manière intuitive via une interface graphique  (site de Rancher: https://rancher.com/)

Pour ce tuto je vais utiliser trois machines sous Debian 9 avec docker installé. Pour ceux qui ne connaissent pas Docker, je leurs suggère de lire le tutoriel ci-dessous:

Tuto Docker | Démarrer avec Docker

Pour info un tutoriel rédigé le 20 Août 2018 explique comment installer Kubernetes from scratch (à la mano!) sur Debian ou Centos . Ce tuto est disponible ici

1) Installation de Rancher

Installer Rancher est très facile, il suffit de déployer le container fournit par l’éditeur:

Au moment de la rédaction de cet article, la version stable de Rancher est la version 1.6. La version 2.0 est une version Alpha en cours de développement (très instable).

Nous allons installer Rancher sur notre première machine:

docker run -d –restart=unless-stopped -p 8080:8080 rancher/server:stable

Une fois le container installé, connectez vous à l’interface Web: <ip de votre machine>:8080

Rancher est installé et opérationnel!

Petite parenthèse, si vous allez dans l’onglet « CATALOG » vous verrez que Rancher peut déployer un large panel d’outils:

 

2) Kubernetes

Revenons en à nos moutons, nous allons maintenant déployer Kubernetes via Rancher.

Dans un premier temps cliquez sur l’onglet « infrastructure » puis « Hosts »

Puis cliquez sur le bouton « Add Host »:

Contentez vous de copier la ligne de commande au paragraphe 5 et de la coller sur toutes les machines Linux qui serviront de nœud à votre infra kubernetes (dans mon cas les 3 machines sous Debian que j’ai créées).

Cette commande va déployer un container contenant un agent Rancher qui va gérer chacune de vos machines!

Retournez dans l’onglet « infrastructure »/ »Hosts » pour vérifier que vos machines sont bien remontées:

Cliquez ensuite sur « Catalog » puis cherchez « Kubernetes » et cliquez sur « View details »:

Laissez tout par défaut et validez en cliquant sur le bouton tout en bas de la page.

Un nouvel onglet  « Kubernetes devrait apparaître. En cliquant dessous, vous pourrez suivre l’avancement de l’installation:

Vous pouvez suivre avec plus de détails l’installation de chaque composant Kubernetes en cliquant sur l’onglet « Kubernetes » puis « Infrastructure Stacks »:

Une fois que tous les statuts seront à « Active », les composants Kubernetes seront installés:

 

Vous pouvez maintenant vous connectez à l’interface Kubernetes en cliquant sur l’onglet « Kubernetes » puis « Dashboard »:

Cliquez sur « Kubernetes UI »:

Vous voila connecté à l’interface Kubernetes.

Pour les personnes ayant plus de connaissances, une interface en ligne de commande est également disponible depuis l’interface de Rancher via l’onglet « Kubernetes »/ »_Cli »:

 

3) Déploiement d’un container

Pour vous prouver que je ne me moque pas de vous et que tout fonctionne, je vais déployer un container apache répliqué sur 2 deux nœuds:

Cliquez sur le bouton « CREATE » en haut à droite et remplissez les champs requis:

Deux container apache ont été déployés sur deux différents nœuds (très pratique pour la tolérance de panne ;-)):

En me connectant sur l’un des nœuds au hasard, mon apache répond bien!

Enjoy!

 




Tutoriel | Gérez vos container docker avec Portainer

Article publié le 2 Octobre 2017

Un petit tutoriel afin de vous présenter un outil peu connu mais extrêmement puissant vous permettant de gérer vos environnements Docker avec une simplicité sans égale: Portainer.

Si vous cherchez une interface graphique pour gérer votre environnement docker, portainer est fait pour vous!

Afin de suivre ce tuto, Docker doit-être installé sur votre machine. Un tuto sur l’installation et la configuration de  docker est disponible :

https://journaldunadminlinux.fr/tuto-docker-demarrer-avec-docker/

1) Installation de Portainer

Portainer est livré nativement dans un container docker. Pour le déployer :

docker run -d -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock -v /opt/portainer:/data portainer/portainer

Une fois le container déployé connectez vous à l’interface web via l’adresse suivante: http://ipdevotremachine:9000

 

2) Configuration

Lors de la première connexion, il vous sera demandé de créer le mot de passe du user admin:

Il vous sera demandé ensuite de « brancher » votre instance portainer à votre machine Docker.

Dans mon cas mon instance portainer est installée au même endroit que mon instance Docker.

Vous voilà connecté au dashboard:

2.1) Déployer un container

Nous allons tout d’abord faire un pull d’une image, pour cela cliquer sur « images » dans le menu de gauche:

Tapez le nom de l’image Docker que vous voulez utiliser puis cliquez sur « pull » (dans notre cas, nous allons faire un pull de l’image httpd).

Une fois le pull terminé, notre image sera présente dans la liste:

Nous allons maintenant déployer un container docker apache. Pour cela cliquez sur « container »

Puis sur le bouton « Add container ».

Procédez au paramétrage de votre container docker grâce à cette superbe interface intuitive puis cliquez sur le bouton « start container »

 

Votre container est à présent démarré!

En cliquant sur le nom de votre container, vous aurez accès à toute la supervision nécessaire:

 

 

En cliquant sur « Stats »:

2.2) Rajouter une machine docker ou un cluster docker Swarm

Comme vous avez pu le constater dans le chapitre précédent l’interface est extrêmement simple et intuitive. Cet outil vous simplifiera grandement la vie pour gérer vos environnements docker.

Pour rajouter une machine ou un cluster swarm, cliquez sur le bouton « Endpoints » situé dans le menu en bas à gauche

Comme vous l’avez compris grâce à cette fonctionnalité, vous pouvez ajouter et gérer tout vos environnement dockers!

 

Pour plus d’info le github du projet: https://github.com/portainer/portainer et un grand bravo aux développeurs!!




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

[email protected]
[email protected]
[email protected]

– 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
[email protected]
– SMTP_PASS=password
– SMTP_STARTTLS=true
– SMTP_AUTHENTICATION=login

– IMAP_ENABLED=false
– IMAP_HOST=imap.gmail.com
– IMAP_PORT=993
[email protected]
– 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 [email protected]
# 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