Skip to content

Un Owncloud avec Docker-Compose

owncloud-docker-banner

Ça fait un moment que je n’avais pas installé Owncloud. Je me suis dit, pourquoi pas essayer avec Docker quitte à faire ? J’ai donc commencé un Docker-compose avec Owncloud, MySQL et Nginx en front et un certificat ECDSA en passant. Owncloud recommande d’utiliser un gestionnaire de cache, j’ai donc rajouté REDIS à mon porte-container.

Je vais donc vous expliquer rapidement la démarche, ça me permettra aussi de garder mon fichier docker-compose.yml quelque part !

Tout d’abord, il faut générer les certificats TLS, avec Let’s Encrypt. Pour cela, vous pouvez lire mon tutoriel « Let’s Encrypt Nginx« . Vous aurez donc une connexion TLS notée en A+.

Pour commencer avec Owncloud, on va se placer dans le répertoire /srv/Owncloud afin de gérer nos containers. Je précise pas qu’il faut que Docker et Docker-compose soient installés.

mkdir /srv/Owncloud ; cd /srv/Owncloud

On va commencer par préparer nos dossiers afin d’y ajouter les certificats et la conf de Nginx. Il faut donc que vos certificats soient dans /etc/letsencrypt. :

mkdir /srv/Owncloud/etc/
cp -r /etc/letsencrypt/ /srv/Owncloud/etc/

Il est temps de créer notre fichier docker-compose.yml (dans /srv/Owncloud) :

cloud_web:
  image: nginx
  restart: always
  ports:
    - 80:80
    - 443:443
  log_driver: syslog
  links:
    - cloud_engine
  volumes:
    - ./etc/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
    - ./var/log/nginx:/var/log/nginx
    - ./etc/letsencrypt:/etc/letsencrypt
cloud_engine:
  image: owncloud:latest  
  expose:
    - "80"
  volumes:
    - /srv/Owncloud/data:/var/www/html/data
    - /srv/Owncloud/config:/var/www/html/config
  links:
    - cloud_db
    - cloud_cache
cloud_db:
  image: mysql:latest
  expose:
    - "3306"
  environment:
    MYSQL_DATABASE: owncloud
    MYSQL_USER: owncloud
    MYSQL_PASSWORD: password
    MYSQL_ROOT_PASSWORD: r00tpassword
  volumes:
    - /srv/Owncloud/mysql:/var/lib/mysql
cloud_cache:
  image: redis:latest
  expose:
    - "6379"

Pour expliquer rapidement, le premier bloc lance Nginx qui expose ses ports 80 et 443 avec plusieurs volumes pour les certificats, la conf et les logs. Ensuite, on lance l’image d’Owncloud avec deux volumes pour les documents et la config. Pour finir, on lance MySQL avec les variables d’environnements qui vont biens et la dernière image de REDIS. Ce dernier fera office de cache, tel que le montre ce schéma :

caching

On va maintenant pouvoir s’occuper de la conf de Nginx, qui va se placer dans le fichier /srv/Owncloud/etc/nginx/nginx.conf :

worker_processes  1;
 
events {
    worker_connections  1024;
}
http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;
    gzip on;
    gzip_disable "msie6";  
    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_buffers 16 32k;
    gzip_min_length  256;
    gzip_http_version 1.1;
    gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript application/javascript;
   
    server {
      listen         80;
      server_name    cloud.domain.com;
      return         301 https://$server_name$request_uri;
    }
    server { 
      listen 443 ssl http2;
      ssl_certificate /etc/letsencrypt/live-ecdsa/cloud.domain.com/chain.pem;
      ssl_certificate_key /etc/letsencrypt/live-ecdsa/cloud.domain.com/privkey-p384.pem;
      ssl_session_timeout 1d;
      ssl_session_cache shared:SSL:50m;
      ssl_session_tickets off;
      ssl_protocols TLSv1.2;
      ssl_ciphers 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!3DES:!MD5:!PSK';
      ssl_prefer_server_ciphers on;
      add_header Strict-Transport-Security max-age=15768000;
      ssl_stapling on;
      ssl_stapling_verify on;
      ssl_ecdh_curve secp384r1;
      resolver 8.8.8.8 8.8.4.4 valid=86400;
      root /var/www/html;
      index index.php;

      location / {
 proxy_pass http://cloud_engine; 
 proxy_set_header Accept-Encoding "";
 proxy_set_header Host $host;
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header X-Forwarded-Proto $scheme;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 add_header Front-End-Https on;
 add_header Strict-Transport-Security "max-age=63072000; includeSubdomains; preload";
 client_max_body_size 1024M;
 proxy_read_timeout 600s;
 proxy_send_timeout 600s;
 proxy_connect_timeout 600s;
      }     
    }
}

N’oubliez pas de modifier cloud.domain.com par votre domain, sinon ça ne marchera pas !
La notion de Proxy_pass se fait vers http://cloud_engine (Owncloud port 80) qui est linké à Nginx.

On va maintenant pouvoir lancer nos containers, cela va générer la config d’Owncloud, qu’on va modifier rapidement pour ajouter la cache REDIS,  on les détruira ensuite pour les reconstruire (c’est le but avec Docker).

docker-compose up -d

Vos 4 containers vont se lancer en mode détachés, pour garder la main sur le shell. Vous devriez pouvoir vous rendre sur votre nom de domaine afin de procéder à la première config d’Owncloud :

owncloud_first

Pour le nom de la base et le mot de passe, utilisez le même que dans le fichier de Docker-compose. Quant à l’hôte MySQL, ce n’est pas localhost mais cloud_db (comme on l’a nommé qu’on l’a linké à Owncloud). L’installation devrait se finir sans soucis. Si jamais vous avez un problème, vous pouvez voir les logs avec cette commande :

docker-compose logs

redis_logo

On va maintenant ajouter REDIS à la config d’Owncloud, sinon il sert à rien dans notre stack. On édite donc le fichier /srv/Owncloud/config/config.php :

'memcache.local' => '\OC\Memcache\Redis',
  'redis' => array(
    'host' => 'cloud_cache',
    'port' => 6379,
  ),

Faites attention de bien l’ajouter entre les parenthèses de l’array $CONFIG. Le nom d’hôte est cloud_cache car on l’a nommé ainsi dans le fichier docker-compose.

On a plus qu’à détruire et relancer nos containers pour que la modif sois prisent en compte :

docker-compose down ; docker-compose up -d

Et voilà, votre Owncloud devrait être up et sécurisé grâce à Let’s Encrypt :

owncloud-https

Pour mettre à jour votre stack, rien de plus simple, en une commande :

docker-compose down ; docker-compose pull ; docker-compose up -d

Si vous voulez faire des backups, il y a juste à sauvegarder le dossier /srv/Owncloud pour tout garder (la conf, les fichiers, la base SQL), top non ?

Published inDevOpsDockerLinuxTLSTutorielWebWeb server

7 Comments

  1. Bonjour,
    très intéressant,
    j’ai chez moi un serveur UBuntun 14.04 LTS, et j’aimerais installer Owncloud, pour me faire un serveur de fichier à la maison, en lisant le tuto,

    comment installer docker ?

    Comment je redirige un domaine sur le docker, sachant que sur mon serveur j’ai déjà un domaine qui pointe dessus ?

      • Merci,

        par contre avant de me lancer,
        sur mon serveur physique j’ai actuellement les services web suivant :

        Forum PHPBB, rainloop, TVHEADEND (avec TV Clé tnt et satelite), Transmission 🙂

        est ce que je risque de perdre mes services ci-dessus ?

        ou est ce que ça vas faire comme une machine virtuel et vraiment me faire une machine séparé avec une adresse ip a pars ?

        • valentin valentin

          Non, Docker ne fonctionne pas comme une VM, il sera bien sur ta machine hôte (isolé d’une certaine manière). Pour cela je t’invite à lire ceci : http://www.lemagit.fr/conseil/Conteneurs-Linux-et-Conteneurs-Docker-quelles-differences

          Tu peux donc très bien installer Owncloud sur ton serveur avec Docker, sans interférer avec tes services existants. Pour cela, il ne faut pas utiliser les mêmes ports. Tu dois sûrement déjà utiliser 80/443 pour tes appli Web, il te suffit donc de modifier le fichier docker-compose.yml pour modifier les ports Nginx vers 4080/4443 par exemple.

  2. Valentin Valentin

    Bonjour,
    Pas mal du tout l’article, par contre je sais pas si c’est à cause d’une version qui diffère mais moi le « link » dans le docker-compose.yml il ne passe pas, il faut mettre « links » pour que cela fonctionne.

  3. Amo Amo

    Salut et merci pour ce billet très instructif.

    Question, pourquoi il y a des  » .  » devant les volumes dans le docker-compose ?
    – ./etc/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
    – ./var/log/nginx:/var/log/nginx
    – ./etc/letsencrypt:/etc/letsencrypt

    Cordialement,

    • valentin valentin

      à l’époque, ça voulait dire que le volume était présent dans le dossier du fichier docker-compose.yml ( « . » en bash).
      Cependant, avec les volumes dans /var/lib/ il se peut que ça sois déprécié, voir que ça marche plus maintenant. 🙂

Laisser un commentaire

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

Proudly hosted with Open-sources Softwares.