Sauvegarde et restauration de Gitlab dans Docker

Commis promis dans l’article Installer Gitlab en https avec Docker et Nginx, nous allons voir comment créer des backups de Docker Gitlab et les restaurer.

Attention, la source et la destination du fichier de restauration doivent avoir exactement la même version. Si la source à une version plus ancienne que la destination, il faut mettre à jour vers la bonne version.

Création d’une sauvegarde de Gitlab:

docker exec -it gitlab.example.com gitlab-rake gitlab:backup:create

Ré-import de l’archive Gitlab:

#copie de l'archive dans le dossier backup du Gitlab de destination
cp 1475786020_gitlab_backup.tar /srv/gitlab/data/backups/

#connexion au conteneur et import de l'archive
docker exec -it gitlab.example.com /bin/bash
gitlab-ctl stop unicorn
gitlab-ctl stop sidekiq
# Verification
gitlab-ctl status

gitlab-rake gitlab:backup:restore BACKUP=1475786020

gitlab-ctl start
gitlab-rake gitlab:check SANITIZE=true

exit

Création d’une archive des fichiers de configuration:

umask 0077;tar cfz $(date "+etc-gitlab-%s.tgz") -C / /srv/gitlab/config -P

sources:
https://gitlab.com/gitlab-org/gitlab-ce/blob/master/doc/raketasks/backup_restore.md
https://docs.gitlab.com/omnibus/settings/backups.html

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Installer Redmine en https avec Docker et Nginx

docker-redminePour faire suite à l’article précédent sur Gitlab, voici comment installer Redmine avec Docker

Dans ce tuto, le port 3000 du conteneur est mappé sur le ports 4432.
Cela veux dire que le reverse proxy de Nginx installé sur l’host devra « écouter » sur le port 4432.

1 – Configuration du conteneur Docker

1.1 – Création du conteneur

Premièrement, il faut récupérer la dernière image Docker de Redmine.

#https://hub.docker.com/_/redmine/
docker pull redmine

1.2 – docker-compose

On créé un fichier docker-compose.yml avec le contenu suivant:

version: '2'
services:

  redmine:
    image: redmine
    container_name: 'redmine.example.com'
    volumes:
      - "/srv/redmine/files:/usr/src/redmine/files"
      - "/srv/redmine/config/configuration.yml:/usr/src/redmine/config/configuration.yml"
    ports:
      - 4432:3000
    environment:
      REDMINE_DB_MYSQL: mariadb
      REDMINE_DB_PASSWORD: password
    depends_on:
      - mariadb
    restart: always

  mariadb:
    image: mariadb
    container_name: mariadb
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: redmine
    restart: always
    volumes:
      - "/srv/mariadb:/var/lib/mysql"

Pour ajouter un conteneur phpmyadmin lié à mariadb ajoutez ceci au fichier docker-compose.yml

  phpmyadmin:
    image: nazarpc/phpmyadmin
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: redmine
    restart: always
    ports:
      - 1234:80
    links:
      - mariadb:mysql

On peut ensuite accéder à phpmyadmin sur cette URL: http://127.0.0.1:1234

Lancement du conteneur

docker-compose up -d

2 – Configuration SMTP

Dans le fichier docker-compose.yml le fichier de configuration est monté sur /srv/redmine/config/configuration.yml .
Ce fichier contient la configuration SMTP.
Exemple de configuration avec Gmail:

  email_delivery:
    delivery_method: :smtp
    smtp_settings:
      enable_starttls_auto: "true"
      address: "smtp.gmail.com"
      port: 587
      domain: "smtp.gmail.com"
      authentication: :plain
      user_name: "USER@gmail.com"
      password: "PASSWORD"

Une fois la configuration effectuée, il faut redémarrer le conteneur:

docker-compose stop
docker-compose up -d

3 – Configuration du reverse proxy sur la machine host

Dans ce tutoriel nous allons utiliser Nginx pour mettre en place un reverse proxy mais vous pouvez également utiliser Apache.

Installation de Nginx

apt-get install nginx

Configuration du proxy

cd /etc/nginx/
vim sites-available/redmine.example.com

Contenu de /etc/nginx/sites-available/redmine.example.com

server {
        listen *:443 ssl http2;


	## Strong SSL Security
	## https://raymii.org/s/tutorials/Strong_SSL_Security_On_nginx.html & https://cipherli.st/
	ssl on;
	ssl_certificate /srv/redmine/ssl/redmine.example.com.crt;
	ssl_certificate_key /srv/redmine/ssl/redmine.example.com.key;

	ssl_ciphers 'ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA:ECDHE-RSA-AES128-SHA:ECDHE-RSA-DES-CBC3-SHA:AES256-GCM-SHA384:AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256:AES256-SHA:AES128-SHA:DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!MD5:!PSK:!RC4';
	ssl_protocols  TLSv1 TLSv1.1 TLSv1.2;
	ssl_prefer_server_ciphers on;
	ssl_session_cache  builtin:1000  shared:SSL:10m;
	ssl_session_timeout  5m;


	server_tokens off; ## Don't show the nginx version number, a security best practice

        proxy_redirect  off;
        proxy_set_header        Host    $host;
        proxy_set_header        X-Real-IP $remote_addr;
        proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header        X-Forwarded-Proto https;

        server_name  redmine.example.com;
        access_log  /var/log/redmine.example.com.access.log;
        error_log  /var/log/redmine.example.com.nginx_error.log debug;
        location / {
                proxy_pass         http://127.0.0.1:4432/;
        }

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
                root   /var/www/nginx-default;
        }
}

Pour terminer:

ln -s /etc/nginx/sites-available/redmine.example.com sites-enabled/redmine.example.com
/etc/init.d/nginx restart

4 – Première connexion

Rendez vous sur https://redmine.example.com/ pour la première authentification.
Les accès par défaut sont admin/admin.

Rendez-vous sur https://redmine.example.com/settings pour configurer le hostname et le protocol https et sur https://redmine.example.com/settings?tab=authentication pour empêcher la création de compte.

 

BONUS: Backup/Restore

Pour faire une backup de Redmine, il suffit d’exporter la base « redmine » de mariadb et de faire une archive du dossier /srv/redmine/files qui contient les fichiers uploadés.

Pour exporter la base redmine de l’instance mariadb:

docker exec mariadb sh -c 'exec mysqldump -uroot -p"password" redmine' > /chemin/sur/host/redmine.sql

Script bash pour la création automatique d’une archive du dossier /srv/redmine/file:

#!/bin/bash

# Number of backups to keep
NBACKUPS_TO_KEEP=6

# Also keep backups of the first day of each month
KEEP_FIRST_DAY_MONTH=true

REDMINE_VOLUMES_PATH="/srv/redmine"

BACKUP_PATH="/path/to/backups"

EMAIL_DEST="admin@redmine.example.com"

EMAIL_SUBJECT="redmine.example.com - backup"

TODAY=$(date)

HOST=$(hostname)

NEWLINE_CHAR="\n"

if [ ! -d $BACKUP_PATH/files ]; then
	mkdir -p $BACKUP_PATH/files;
fi

echo "----------------"
MESSAGE_TO_SEND="----------------"

echo "$TODAY - $HOST"
MESSAGE_TO_SEND=$MESSAGE_TO_SEND"${NEWLINE_CHAR}$TODAY - $HOST"

echo "Backing up redmine into $BACKUP_PATH"
MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}"backing up redmine into $BACKUP_PATH"

echo "----------------"
MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}"----------------"
echo ""


LINE="creating /usr/src/redmine/files archive.."
MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}$LINE
echo $LINE
umask 0077;tar cfz $BACKUP_PATH/files/$(date "+files-redmine-%s.tgz") -C / $REDMINE_VOLUMES_PATH/files -P
echo "done"
MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}"done"${NEWLINE_CHAR}

echo ""
MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}"Removing old backups"
echo "Removing old backups"

backups=( $( ls $BACKUP_PATH/files/ | sort -n -r -t _ -k 2 ) );
i=1;
for filename in "${backups[@]}";do

	if [ $i -gt $NBACKUPS_TO_KEEP ]
	then
		if [ $KEEP_FIRST_DAY_MONTH == true ]
		then
			day=$( date -d @$( echo $filename | sed -e "s/files-redmine-//g" | sed -e "s/.tgz//g") '+%d' )
			if [ ! $day == 01 ]
			then
				rm "$BACKUP_PATH/files/$filename"
				LINE="removed $filename"
				MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}$LINE
				echo $LINE
			else
				LINE="keeping $filename"
				MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}$LINE
				echo $LINE
			fi
			
		else
			rm "$BACKUP_PATH/files/$filename"
			LINE="removed $filename"
			MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}$LINE
			echo $LINE
		fi
	fi
	i=$[i+1]
done
MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}"done"
echo "done"

echo "----------------";
MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}"----------------"
echo -e $MESSAGE_TO_SEND | mail -s "$EMAIL_SUBJECT" $EMAIL_DEST

Pour restaurer, extraire l’archive des fichiers dans /srv/redmine/files et importer /chemin/sur/host/redmine.sql dans l’instance mariadb.

sources:
http://www.redmine.org/boards/2/topics/14177
https://github.com/docker-library/docs/tree/master/mariadb
https://hub.docker.com/r/nazarpc/phpmyadmin/
redmine.org/projects/redmine/wiki/redmineinstall

Pour l’installation de docker-compose ou pour générer les certificats SSL jetez un oeil à mon précédent article: Installer Gitlab en https avec Docker et Nginx

Tutoriel réalisé sous Ubuntu Xenial (16.04 LTS)

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Installer Gitlab en https avec Docker et Nginx

277d9badcbd723e913b3a41e64e8d2f3d2c80598

Nous allons aujourd’hui utiliser la puissance de Docker pour créer une instance en https de Gitlab derrière un proxy Nginx.

docker_logo-1455828502290

Dans ce tuto, les ports 443 (SSL) et 22 (SSH) du conteneur sont mappés respectivement sur les ports 4431 et 2201 de l’host mais libre à vous de changer ces valeurs.
Cela veux dire que le reverse proxy de Nginx installé sur l’host devra « écouter » sur le port 4431 et que l’url SSH de vos dépôts sera du type « ssh://git@gitlab.example.com:2201/user/repo.git »

1 – Configuration du conteneur Docker

1.1 – Création du conteneur

Premièrement, il faut récupérer la dernière image Docker de Gitlab.

#https://hub.docker.com/r/gitlab/gitlab-ce/
docker pull gitlab/gitlab-ce

On lance ensuite le conteneur, n’oubliez par de remplacer gitlab.example.com par votre nom de domaine.
Les différents fichiers de Gitlab seronts stockés dans /srv/gitlab/

docker run --detach \
    --hostname gitlab.example.com \
    --publish 4431:443 --publish 2201:22 \
    --name gitlab.example.com \
    --restart always \
    --volume /srv/gitlab/config:/etc/gitlab \
    --volume /srv/gitlab/logs:/var/log/gitlab \
    --volume /srv/gitlab/data:/var/opt/gitlab \
    --volume /srv/gitlab/logs/reconfigure:/var/log/gitlab/reconfigure \
    gitlab/gitlab-ce:latest

1.2 – Configuration

Configuration de Gitlab /etc/gitlab/gitlab.rb

#ouverture de gitlab.rb dans le conteneur
docker exec -it gitlab.example.com vi /etc/gitlab/gitlab.rb

Dans le fichier gitlab.rb, remplacez les valeurs par défaut par les vôtres

#configuration de l'url de Gitlab. Notez le https.
#https://docs.gitlab.com/omnibus/docker/
external_url 'https://gitlab.example.com'

#modification du port ssh pour coller avec le mapping du conteneur
gitlab_rails['gitlab_shell_ssh_port'] = 2201

#configuration du smtp avec un compte gmail
#https://docs.gitlab.com/omnibus/settings/smtp.html
gitlab_rails['smtp_enable'] = true
gitlab_rails['smtp_address'] = "smtp.gmail.com"
gitlab_rails['smtp_port'] = 587
gitlab_rails['smtp_user_name'] = "USERNAME@gmail.com"
gitlab_rails['smtp_password'] = "PSW_GMAIL"
gitlab_rails['smtp_domain'] = "smtp.gmail.com"
gitlab_rails['smtp_authentication'] = :plain
gitlab_rails['smtp_enable_starttls_auto'] = true
gitlab_rails['smtp_tls'] = false
gitlab_rails['smtp_openssl_verify_mode'] = 'peer'

# on garde les backups pendant 7 jours
#https://docs.gitlab.com/ee/raketasks/backup_restore.html
gitlab_rails['backup_keep_time'] = 604800

Reconfiguration de Gitlab pour prendre en compte les changements

docker exec -it gitlab.example.com gitlab-ctl reconfigure

1.3 – Alternative: docker-compose

Cette configuration peut être faite bien plus simplement avec docker-compose.

Après avoir fait un docker pull gitlab/gitlab-ce comme vu précédemment, on créé un fichier docker-compose.yml avec le contenu suivant:

web:
  image: 'gitlab/gitlab-ce:latest'
  restart: always
  hostname: 'gitlab.example.com'
  container_name: 'gitlab.example.com'
  environment:
    GITLAB_OMNIBUS_CONFIG: |
      external_url 'https://gitlab.example.com'
      gitlab_rails['gitlab_shell_ssh_port'] = 2201
      gitlab_rails['smtp_enable'] = true
      gitlab_rails['smtp_address'] = "smtp.gmail.com"
      gitlab_rails['smtp_port'] = 587
      gitlab_rails['smtp_user_name'] = "USERNAME@gmail.com"
      gitlab_rails['smtp_password'] = "PSW_GMAIL"
      gitlab_rails['smtp_domain'] = "smtp.gmail.com"
      gitlab_rails['smtp_authentication'] = :plain
      gitlab_rails['smtp_enable_starttls_auto'] = true
      gitlab_rails['smtp_tls'] = false
      gitlab_rails['smtp_openssl_verify_mode'] = 'peer'
      gitlab_rails['backup_keep_time'] = 604800
  ports:
    - '4431:443'
    - '2201:22'
  volumes:
    - '/srv/gitlab/config:/etc/gitlab'
    - '/srv/gitlab/logs:/var/log/gitlab'
    - '/srv/gitlab/data:/var/opt/gitlab'

CF: https://gitlab.com/gitlab-org/omnibus-gitlab/blob/master/docker/docker-compose.yml

Si docker-compose n’est pas installé:

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

Lancement du conteneur

docker-compose up -d

2 – Création du certificat SSL

Après avoir ouvert et redirigé le port 443 sur votre box ADSL, on peut utiliser letsencrypt pour générer des certificats gratuits. Attention, ces certificats ne sont valides que 90 jours, il faut penser à les renouveler.

#https://certbot.eff.org/#ubuntuxenial-other
apt-get install letsencrypt 
letsencrypt certonly --standalone -d gitlab.example.com

Copie des certificats dans le dossier config de Gitlab

cd /etc/letsencrypt/live/gitlab.example.com/
mkdir -p /srv/gitlab/config/ssl
chmod 700 /srv/gitlab/config/ssl
cp privkey.pem /srv/gitlab/config/ssl/gitlab.example.com.key
cp cert.pem /srv/gitlab/config/ssl/gitlab.example.com.crt

Reconfiguration de Gitlab pour prendre en compte les changements

docker exec -it gitlab.example.com gitlab-ctl reconfigure

3 – Configuration du reverse proxy sur la machine host

Dans ce tutoriel nous allons utiliser Nginx pour mettre en place un reverse proxy mais vous pouvez également utiliser Apache.

Installation de Nginx

apt-get install nginx

Configuration du proxy

cd /etc/nginx/
vim sites-available/gitlab.example.com

Contenu de /etc/nginx/sites-available/gitlab.example.com

## Redirects all HTTP traffic to the HTTPS host
server {
	listen 0.0.0.0:80;
	listen [::]:80 ipv6only=on;
	server_name gitlab.example.com; 
	server_tokens off;
	return 301 https://$http_host$request_uri;

	access_log  /var/log/gitlab.example.com80.access.log;
	error_log  /var/log/gitlab.example.com80.nginx_error.log debug;
}

server {
        listen *:443 ssl http2;

	ssl on;
	ssl_certificate /srv/gitlab/config/ssl/gitlab.example.com.crt;
	ssl_certificate_key /srv/gitlab/config/ssl/gitlab.example.com.key;

	ssl_ciphers 'ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA:ECDHE-RSA-AES128-SHA:ECDHE-RSA-DES-CBC3-SHA:AES256-GCM-SHA384:AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256:AES256-SHA:AES128-SHA:DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!MD5:!PSK:!RC4';
	ssl_protocols  TLSv1 TLSv1.1 TLSv1.2;
	ssl_prefer_server_ciphers on;
	ssl_session_cache  builtin:1000  shared:SSL:10m;
	ssl_session_timeout  5m;

	server_tokens off;

        server_name  gitlab.example.com;
        access_log  /var/log/gitlab.example.com.access.log;
        error_log  /var/log/gitlab.example.com.nginx_error.log debug;
        location / {
                proxy_pass         https://127.0.0.1:4431/;
        }

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
                root   /var/www/nginx-default;
        }
}

Pour terminer:

ln -s /etc/nginx/sites-available/gitlab.example.com sites-enabled/giltab.example.com
/etc/init.d/nginx restart

4 – Première connexion

Rendez vous sur https://gitlab.example.com/ pour la première authentification.
Saisissez deux fois un mot de passe que vous choisissez et connecter vous avec l’utilisateur root et ce mot de passe.

Pour empêcher la création de compte allez sur: https://gitlab.example.com/admin/application_settings

5 – Mise à jour de l’image

Avec docker-compose, il suffit de lancer les commande suivantes:

docker-compose pull 
docker-compose up

Dans un prochain article, j’aborderai comment créer des backups et les restaurer.

Tutoriel réalisé sous Ubuntu Xenial (16.04 LTS)

sources:
https://docs.gitlab.com/omnibus/docker/
https://forum.gitlab.com/t/nginx-as-reverse-proxy-for-gitlab-with-ssl/1641
https://docs.gitlab.com/omnibus/settings/nginx.html
https://gitlab.com/gitlab-org/gitlab-recipes/raw/master/web-server/nginx/gitlab-omnibus-ssl-nginx.conf
ttps://gitlab.com/gitlab-org/gitlab-ce/issues/1331

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

T411 – comment contourner le blocage DNS avec le fichier hosts

t411Si comme moi vous utilisez T411 pour télécharger des fichiers, légaux bien sur (et oui il y en a) mais que votre fournisseur d’accès à fait un blocage DNS des domaines t411.io ou/et t411.me, voici comment le contourner rapidement en utilisant le fichier hosts.

Premièrement il faut récupérer l’IP du serveur ou est hébergé T411. On peut pour cela utiliser un service web de « ping » comme https://cloudmonitor.ca.com/en/ping.php

Avec ce service, on voit que T411 est hébergé sur deux IP différentes:

108.162.204.254
108.162.203.254

Il suffit alors d’en prendre une au hasard et d’ajouter ce qui suit dans votre fichier hosts.
Sous Ubuntu, le fichier est localisé dans /etc/hosts

108.162.203.254 www.t411.io 
108.162.203.254 t411.io
108.162.203.254 www.t411.me
108.162.203.254 t411.me
108.162.203.254 forum.t411.io
108.162.203.254 forum.t411.me
108.162.203.254 tracker.t411.me
108.162.203.254 tracker.t411.io

Et voilà !

Une réflexion au sujet de « T411 – comment contourner le blocage DNS avec le fichier hosts »

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *