Mise en place de l'application Nextcloud sur un NAS QNAP

Dernière modification : 7 Novembre 2023
Temps de lecture : 18 minute(s) - 3812 mots
Tags: Nextcloud Cloud QNAP Docker

Vous trouverez dans cet article, l’ensemble des éléments pour mettre en place l’application Nextcloud sur un NAS QNAP en utilisant l’application QNAP Container Station et plus spécifiquement Docker.

La mise en place est spécifique au NAS QNAP de la série TS-x31P3 Series qui a une contrainte limitant l’utilisation des images Docker de manière général et par conséquent bloquant l’utilisation de l’image Nextcloud AIO.

Qu’est ce qu’un NAS

Un NAS (Network Attached Storage) est un serveur de stockage réseau qui permet de stocker, sauvegarder, partager, sécuriser et faciliter l’accès aux fichiers numériques (photos, vidéos, musiques, documents) et permet aussi d’exécuter des applications permettant d’enrichir les services accessibles (vpn, sftp, serveur web, …).

Qu’est ce que Nextcloud

Nextcloud est un logiciel (libre) offrant une plateforme de services de stockage et partage de fichiers ainsi que des applications en ligne.

Objectif

L’objectif de cette démarche est de pouvoir avoir un cloud privée (basé sur Nextcloud) permettant à toute la famille de stocker, partager et gérer ces données tout en utilisant un ancien NAS QNAP déjà existant.

L’application Nextcloud doit être accessible en local en utilisant l’adresse HTTPS suivante : https://110.110.110.151

Note : Pour rendre l’application Nextcloud accessible depuis internet, il faut ajouter une règle NAT sur votre routeur ou votre box internet permettant de rediriger le trafic des ports 80 et 443 vers l’adresse 110.110.110.151

Contrainte spécifique au NAS QNAP

La contrainte spécifique liée au NAS QNAP de la série TS-x31P3 Series est la suivante :

  • Ce NAS possède un processeur ARM v7 mais dont l’application QNAP Container Station a été modifiée pour implémenter un page size de 32k au lieu de celui par défaut

Une grande majorité d’image Docker ne fonctionne tout simplement pas dont Nextcloud AIO (qui est l’image Docker recommandée par Nextcloud).

Le message d’erreur qui s’affiche est : /bin/sh: error while loading shared libraries: libc.so.6: ELF load command address/offset not page-aligned

Caractéristique du NAS QNAP

  • OS : QTS 5.X
  • CPU : Quad-Core ARM Cortex-A15
  • Memoire : 4GB
  • IP Static : 110.110.110.110

Démarche

Nous allons utiliser les éléments suivants :

  • Application QNAP Container Station (Docker et Docker Compose)
  • Application Nextcloud v27 (archive)
  • Utilisation d’une IP spécifique pour l’accès à Nextcloud (110.110.110.151)

Les étapes seront les suivantes :

  1. Création d’un utilisateur spécifique pour Docker
  2. Création d’un répertoire partagé pour Docker
  3. Activation d’un accès SSH sur le NAS QNAP
  4. Installation de l’application QNAP Container Station
  5. Se connecter en SSH sur le NAS QNAP
  6. Création d’un fichier Dockerfile
  7. Création d’un fichier Docker Compose
  8. Création des fichiers de configurations pour l’application Nextcloud
  9. Création d’un script d’initialisation pour l’application Nextcloud
  10. Création d’un fichier de configuration pour l’ensemble des variables d’environnement
  11. Mise en place d’un script de démarrage sur le NAS QNAP

Détails

Création d’un utilisateur spécifique pour Docker

Création d’un utilisateur spécifique pour Docker afin de limiter les droits sur l’ensemble des éléments et services du NAS QNAP :

  1. Allez dans Main Menu > ControlPanel > Privilege > Users
  2. Cliquez sur le bouton Create, puis sur l’option Create a User
  3. Renseignez les différents éléments du formulaire et choisissez le nom (username) dockeruser
  4. Cliquez sur le bouton Create

Note : Gardez de côté le PUID (ex : 501) et le PGID (ex: 100), car ils seront nécessaires pour les droits du conteneur Docker contenant l’application Nextcloud

20231107_Blog_use_nextcloud_on_qnap_01

Création d’un répertoire partagé pour Docker

Pour créer un répertoire partagé spécifique pour les fichiers de données et de configuration du conteneur Docker contenant l’application Nextcloud, il faut suivre les étapes suivantes :

  1. Allez dans Main Menu > ControlPanel > Privilege > Shared Folders
  2. Cliquez sur le bouton Create, puis sur l’option Create A Shared Folder
  3. Renseignez les différents éléments et cliquez sur le bouton Next
    1. Folder Name : Nom du répertoire
    2. Comment : Commentaire pour le répertoire
    3. Disk Volume : Disque où sera créé le répertoire
    4. Path : Chemin du répertoire
  4. Dans la fenêtre Configure access privileges for users, sélectionnez l’option RW (lecture & écriture) pour votre utilisateur d’administration et pour l’utilisateur dockeruser) et cliquez sur le bouton Next
  5. Dans la fenêtre Properties, sélectionnez les options souhaitées et cliquez sur le bouton Finish

20231107_Blog_use_nextcloud_on_qnap_02

Activation d’un accès SSH sur le NAS QNAP

Pour pouvoir se connecter en SSH sur le NAS QNAP, il faut commencer par activer le service en suivant les étapes suivantes :

  1. Allez dans Main Menu > ControlPanel > Network & File Services > Telnet / SSH
  2. Cochez l’option Allow SSH connection et renseignez le numéro du port souhaité
  3. Cliquez sur le bouton Apply

Note : Dans notre cas nous allons utiliser le port 23422 pour l’accès SSH

20231107_Blog_use_nextcloud_on_qnap_03

Installation de l’application QNAP Container Station

Pour pouvoir utiliser Docker sur le NAS QNAP, il faut installer l’application QNAP Container Station, en suivant les étapes suivantes :

  1. Allez dans Main Menu > App Center > QNAP Store > All Apps
  2. Recherchez l’application Container Station (Utilities) et cliquez sur l’option + Install

Note : un raccourci nommé Container Station doit être présent sur la page d’accueil de votre NAS QNAP.

20231107_Blog_use_nextcloud_on_qnap_04

Se connecter en SSH sur le NAS QNAP

Pour se connecter au NAS QNAP en SSH, il suffit d’utiliser la commande suivante : ssh <useradmin>@<ip NAS QNAP> -p <port> Dans notre cas, la commande sera : ssh admin@110.110.110.110 -p 23422

Nous allons en profiter pour créer les premiers répertoires nécessaires pour Docker et le conteneur Docker contenant l’application Nextcloud

  1. Allez dans le répertoire partagé Docker : cd /share/Docker
  2. Créez le répertoire nextcloud qui permettra de stocker toutes les données associées à l’application Nextcloud : mkdir /share/Docker/nextcloud
  3. Créez le répertoire scripts qui permettra de stocker tous les scripts et fichiers de configuration nécessaires à la construction de l’image et du conteneur Docker contenant l’application Nextcloud : mkdir /share/Docker/scripts

Création d’un fichier Dockerfile

Pour pouvoir mettre en place l’application Nextcloud sur le NAS QNAP, nous allons créer les différents éléments nécessaires.

Création des répertoires nécessaires pour l’image Docker

Nous allons créer un répertoire nextcloud_app dans lequel nous mettrons l’ensemble des éléments nécessaires à la construction de l’image Docker contenant l’application Nextcloud :

  1. Créez un répertoire nextcloud_app : mkdir /share/Docker/scripts/nextcloud_app
  2. Créez un sous-répertoire config permettant de stocker l’ensemble des fichiers de configurations nécessaires pour l’application Nextcloud : mkdir /share/Docker/scripts/nextcloud_app/config

Création du fichier Dockerfile

Créez un fichier nommé Dockerfile dans le répertoire /share/Docker/scripts/nextcloud_app.

Le contenu du fichier est le suivante :

 1# Based on ubuntu image
 2FROM ubuntu:22.04
 3
 4# Default value
 5ARG build_TZ=Europe/Paris
 6ARG build_PUID=501
 7ARG build_PGID=100
 8
 9# Config environment
10ENV TZ=$build_TZ
11ENV DEBIAN_FRONTEND noninteractive
12ENV PUID=$build_PUID
13ENV PGID=$build_PGID
14
15# Work directory
16WORKDIR /
17
18# Update Ubuntu system
19RUN apt-get update -y && apt-get upgrade -y
20
21# Install tools (apache2, mariadb and php)
22RUN apt-get install sudo vim wget cron curl ffmpeg apache2 mariadb-server libapache2-mod-php \
23php-gd php-mysql php-curl php-mbstring php-intl php-gmp php-bcmath php-xml php-imagick php-zip \
24php-bz2 php-ldap php-smbclient php-imap php-apcu -y
25
26# Clean APT cache
27RUN apt-get clean
28RUN rm -rf /var/lib/apt/lists/*
29
30# Install Nextcloud in the folder /var/www
31RUN wget https://download.nextcloud.com/server/releases/latest-27.tar.bz2 -O /tmp/nextcloud-27.tar.bz2
32RUN tar -xjvf /tmp/nextcloud-27.tar.bz2 -C /tmp
33RUN cp -r /tmp/nextcloud /var/www
34RUN chown -R www-data:www-data /var/www/nextcloud
35
36# Copy the template nextcloud config files for run_nextcloud.sh later use
37RUN cp -r /tmp/nextcloud/config /tmp/nextcloud_config
38
39# Clean nextcloud temporary folder
40RUN rm -rf /tmp/nextcloud
41RUN rm /tmp/nextcloud-27.*
42
43# Manage SSL certificate
44RUN openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/ssl/private/apache-selfsigned.key -out /etc/ssl/certs/apache-selfsigned.crt \
45-subj /C=FR/ST=France/L=Paris/O=NAS/OU=Nextcloud/CN=nas@nas.nas
46
47# Create specific folder
48RUN mkdir /scripts
49
50# Copy config files
51COPY ./config /config
52# Prepare execution of the run_nextcloud.sh script
53RUN chmod +x /config/run_nextcloud.sh
54
55# Configuration Crontab
56RUN echo exit 0 > /usr/sbin/policy-rc.d
57RUN echo "*/5  *  *  *  * php -f /var/www/nextcloud/cron.php" | crontab -u www-data -
58
59# Expose ports for Nextcloud application
60EXPOSE 80
61EXPOSE 443
62EXPOSE 3478
63
64# Define Entrypoint to execute the run_nextcloud.sh script
65ENTRYPOINT ["bash","/config/run_nextcloud.sh",">","/var/log/nextcloud/run_nextcloud.log"]

Création d’un fichier Docker Compose

Afin de faciliter l’utilisation de Docker pour la mise en place de l’application Nextcloud, nous allons utiliser Docker Compose en créant un fichier nommé docker-compose.yml dans le répertoire /share/Docker/scripts/nextcloud_app.

Ce fichier va nous permettre de définir le build de l’image Docker ainsi que le réseau (network) Docker qui seront utilisés par le conteneur Docker contenant l’application Nextcloud.

Le contenu du fichier est le suivant :

 1version: "3.7"
 2
 3services:
 4  # Nextcloud application
 5  nextcloud:
 6    image: nextcloud-qnas-img:v27
 7    # Build configuration
 8    build:
 9      context: .
10      dockerfile: Dockerfile
11      # Default argument for the build
12      args:
13        build_PUID : 501
14        build_PGID : 100
15        build_TZ : Europe/Paris
16    # Name of the application for QNAP Container Station
17    container_name: nextcloud-qnas
18    # Define the Static IP from QNET Network
19    networks:
20      qnet-static-eth0:
21        ipv4_address: 110.110.110.151
22    # Define the Env file to initialise environment variable for the container
23    env_file:
24      - ./config/.env
25    # Define all the volume to store the data and logs into the shared folder (and not into the container)
26    volumes:
27      - /share/Docker/nextcloud/nc_data:/var/www/nextcloud/data
28      - /share/Docker/nextcloud/nc_apps:/var/www/nextcloud/apps
29      - /share/Docker/nextcloud/db_data:/var/lib/mysql
30      - /share/Docker/nextcloud/nc_log:/var/log/nextcloud
31      - /share/Docker/nextcloud/db_log:/var/log/mysql
32    # Define the exposed port
33    ports:
34      - 80:80
35      - 443:443
36      - 3478:3478
37    # Don't restart the container only if we manually stop it
38    restart: unless-stopped
39
40# Define the network based en NAS QNAP interfaces
41networks:
42  qnet-static-eth0 :
43    driver: qnet
44    driver_opts:
45      iface: "eth0"
46    ipam:
47      driver: qnet
48      options:
49        iface: "eth0"
50      config:
51        - subnet: 110.110.110.0/24
52          gateway: 110.110.110.1

Précision concernant les volumes :

  • Le répertoire /share/Docker/nextcloud/nc_data contiendra l’ensemble des données utilisateurs de l’application Nextcloud
  • Le répertoire /share/Docker/nextcloud/nc_apps contiendra l’ensemble des applications internes de l’application Nextcloud
  • Le répertoire /share/Docker/nextcloud/db_data contiendra l’ensemble des données de la base de données MariaDB utilisée par l’application Nextcloud
  • Le répertoire /share/Docker/nextcloud/nc_log contiendra l’ensemble des logs de l’application Nextcloud
  • Le répertoire /share/Docker/nextcloud/db_log contiendra l’ensemble des logs de la base de données MariaDB utilisée par l’application Nextcloud

Note : L’objectif est de garder les données de la base de données mariaDB et de l’application Nextcloud dans le répertoire partagé afin de pouvoir faciliter les sauvegarde et pouvoir dissocier les données du conteneur.

Création des fichiers de configurations pour l’application Nextcloud

Afin de pouvoir configurer les services nécessaires à l’application Nextcloud lors de l’exécution du conteneur Docker, nous allons préparer les fichiers de configuration suivants :

I. Pour le service Apache2 :

  1. Créez le répertoire de configuration mkdir /share/Docker/scripts/nextcloud_app/config/apache2
  2. Créez le fichier de configuration nextcloud.conf dans le répertoire créé

Contenu du fichier nextcloud.conf :

 1<VirtualHost *:80>
 2    ServerName ${NC_HOSTNAME}
 3    Redirect permanent / https://${NC_HOSTNAME}/
 4</VirtualHost>
 5
 6<VirtualHost *:443>
 7     ServerName ${NC_HOSTNAME}
 8     DocumentRoot ${ROOT_NC}/
 9
10     Alias / "${ROOT_NC}/"
11
12     SSLEngine on
13     SSLCertificateFile /etc/ssl/certs/apache-selfsigned.crt
14     SSLCertificateKeyFile /etc/ssl/private/apache-selfsigned.key
15
16     <Directory ${ROOT_NC}/>
17       Options +FollowSymlinks
18        AllowOverride All
19        Require all granted
20          <IfModule mod_dav.c>
21            Dav off
22          </IfModule>
23        SetEnv HOME ${ROOT_NC}
24        SetEnv HTTP_HOME ${ROOT_NC}
25        SetEnv HTTPS_HOME ${ROOT_NC}
26     </Directory>
27
28     ErrorLog ${APACHE_LOG_DIR}/error.log
29     CustomLog ${APACHE_LOG_DIR}/access.log combined
30
31</VirtualHost>

II. Pour le service MariaDB :

  1. Créez le répertoire de configuration mkdir /share/Docker/scripts/nextcloud_app/config/mariadb
  2. Créez le fichier de configuration 50-server.conf dans le répertoire créé en reprenant le template souhaité et modifiez la ligne commençant par datadir avec la ligne suivante datadir = ${ROOT_DB_DATA}

III. Pour l’application Nextcloud :

  1. Créez le répertoire de configuration mkdir /share/Docker/scripts/nextcloud_app/config/nextcloud
  2. Créez les fichiers de configuration nommés autoconfig.php et docker.config.php dans le répertoire créé afin de configurer automatique l’application Nextcloud lors de la 1ère exécution

Contenu du fichier autoconfig.php :

 1<?php
 2$AUTOCONFIG = array(
 3  "dbtype"        => "mysql",
 4  "dbname"        => "${MYSQL_DATABASE}",
 5  "dbuser"        => "${MYSQL_USER}",
 6  "dbpass"        => "${MYSQL_PASSWORD}",
 7  "dbhost"        => "localhost",
 8  "dbtableprefix" => "oc_",
 9  "adminlogin"    => "admin",
10  "adminpass"     => "${NC_ADMIN_PASSWORD}",
11  "directory"     => "${ROOT_NC_DATA}",
12  "trusted_domains" => 
13  array (
14    0 => "${STATIC_IP}",
15    1 => "${NC_HOSTNAME}",
16  ),
17);

Contenu du fichier docker.config.php :

 1<?php
 2$CONFIG = array (
 3  'overwriteprotocol' => 'https',
 4  'overwritewebroot' => '/',
 5  'overwrite.cli.url' => 'https://${NC_HOSTNAME}',
 6  'htaccess.RewriteBase' => '/',
 7  'mysql.utf8mb4' => true,
 8  'default_language' => 'fr',
 9  'force_language' => 'fr',
10  'default_locale' => 'fr_FR',
11  'default_phone_region' => 'FR',
12  'force_locale' => 'fr_FR',
13  'knowledgebaseenabled' => true,
14  'allow_user_to_change_display_name' => true,
15  'auth.bruteforce.protection.enabled' => true,
16  'auth.bruteforce.protection.testing' => false,
17  'ratelimit.protection.enabled' => true,
18  'auth.webauthn.enabled' => true,
19  'auth.storeCryptedPassword' => true,
20  'lost_password_link' => 'disabled',
21  'mail_domain' => '${MAIL_DOMAINE}',
22  'updatechecker' => true,
23  'updater.server.url' => 'https://updates.nextcloud.com/updater_server/',
24  'updater.release.channel' => 'stable',
25  'has_internet_connection' => true,
26  'connectivity_check_domains' => [
27    'www.nextcloud.com',
28    'www.startpage.com',
29    'www.eff.org',
30    'www.edri.org'
31  ],
32  'log_type' => 'file',
33  'log_type_audit' => 'file',
34  'logfile' => '${ROOT_NC_LOG}/nextcloud.log',
35  'logfile_audit' => '${ROOT_NC_LOG}/audit.log',
36  'logfilemode' => 0640,
37  'loglevel' => 2,
38  'loglevel_frontend' => 2,
39  'syslog_tag' => 'Nextcloud',
40  'syslog_tag_audit' => 'Nextcloud',
41  'logdateformat' => 'F d, Y H:i:s',
42  'logtimezone' => '${TZ}',
43  'customclient_desktop' =>
44	'https://nextcloud.com/install/#install-clients',
45'customclient_android' =>
46	'https://play.google.com/store/apps/details?id=com.nextcloud.client',
47'customclient_ios' =>
48	'https://itunes.apple.com/us/app/nextcloud/id1125420102?mt=8',
49'customclient_ios_appid' =>
50		'1125420102',
51  'defaultapp' => 'dashboard,files',
52  'appstoreenabled' => true,
53  'apps_paths' => [
54    [
55      'path'=> OC::$SERVERROOT . '/apps',
56      'url' => '/apps',
57      'writable' => true,
58    ],
59  ],
60  'enable_previews' => false,
61  'memcache.local' => '\OC\Memcache\APCu',
62);

IV. Pour le service PHP :

  1. Créez le répertoire de configuration mkdir /share/Docker/scripts/nextcloud_app/config/php
  2. Créez le fichier de configuration nommé 20-pdo_mysql.ini dans le répertoire créé

Contenu du fichier 20-pdo_mysql.ini :

 1; configuration for php mysql module
 2; priority=20
 3extension=pdo_mysql.so
 4
 5[mysql]
 6mysql.allow_local_infile=On
 7mysql.allow_persistent=On
 8mysql.cache_size=2000
 9mysql.max_persistent=-1
10mysql.max_links=-1
11mysql.default_port=3306
12mysql.default_socket=/var/lib/mysql/mysql.sock
13mysql.default_host=localhost
14mysql.connect_timeout=60
15mysql.trace_mode=Off

Création d’un script d’initialisation pour Nextcloud

Afin de pouvoir réaliser l’initialisation de l’application Nextcloud lors de l’exécution du conteneur, nous allons mettre en place le script run_nextcloud.sh dans le répertoire /share/Docker/scripts/nextcloud_app/config.

Contenu du script run_nextcloud.sh :

  1#!/bin/sh
  2
  3# ENV
  4ROOT_CONF="/config"
  5
  6# Check one environment variable (if .env is ok)
  7if [ -z "${ROOT_DB_DATA}" ]; then
  8    echo "$(date +"%Y-%m-%d %H:%M:%S") - Error - Environment variable issues"
  9    exit 1
 10fi
 11
 12
 13# Check data folder to do the initialisation only if one or more folders are emppty
 14CHECK_FOLDER_MARIADB=$(ls "${ROOT_DB_DATA}" | wc -l)
 15CHECK_FOLDER_NC=$(ls "${ROOT_NC_DATA}" | wc -l)
 16CHECK_FOLDER_NC_CONF=$(ls "${ROOT_NC_CONF}" | wc -l)
 17if [ $CHECK_FOLDER_MARIADB -eq 0 ] || [ $CHECK_FOLDER_NC -eq 0 ] || [ $CHECK_FOLDER_NC_CONF -eq 0 ]; then
 18
 19    echo "$(date +"%Y-%m-%d %H:%M:%S") - Info - Init Nextcloud"
 20
 21    # Delete old data
 22    echo "$(date +"%Y-%m-%d %H:%M:%S") - Info - Delete existing Data"
 23    rm -rf $ROOT_DB_DATA/*
 24    rm -rf $ROOT_NC_DATA/*
 25    rm -rf $ROOT_NC_CONF/*
 26
 27    # Copy config files
 28    echo "$(date +"%Y-%m-%d %H:%M:%S") - Info - Copy config files"
 29    # Mariadb
 30    cat $ROOT_CONF/mariadb/50-server.cnf | sed 's|${ROOT_DB_DATA}|'"${ROOT_DB_DATA}"'|g' > /etc/mysql/mariadb.conf.d/50-server.cnf
 31    # Apache2 and PHP
 32    echo "apc.enable_cli = 1" >> /etc/php/8.1/apache2/php.ini
 33    cat $ROOT_CONF/php/20-pdo_mysql.ini > /etc/php/8.1/apache2/conf.d/20-pdo_mysql.ini
 34    cat $ROOT_CONF/apache2/nextcloud.conf | sed 's|${NC_HOSTNAME}|'"${NC_HOSTNAME}"'|g' \
 35        | sed 's|${ROOT_NC}|'"${ROOT_NC}"'|g' \
 36        > /etc/apache2/sites-available/nextcloud.conf
 37    # Nextcloud
 38    cp /tmp/nextcloud_config/* $ROOT_NC_CONF/.
 39    cat $ROOT_CONF/nextcloud/autoconfig.php | sed 's|${NC_HOSTNAME}|'"${NC_HOSTNAME}"'|g' \
 40        | sed 's|${ROOT_NC_DATA}|'"${ROOT_NC_DATA}"'|g' \
 41        | sed 's|${MYSQL_DATABASE}|'"${MYSQL_DATABASE}"'|g' \
 42        | sed 's|${MYSQL_USER}|'"${MYSQL_USER}"'|g' \
 43        | sed 's|${MYSQL_PASSWORD}|'"${MYSQL_PASSWORD}"'|g' \
 44        | sed 's|${STATIC_IP}|'"${STATIC_IP}"'|g' \
 45        | sed 's|${NC_ADMIN_PASSWORD}|'"${NC_ADMIN_PASSWORD}"'|g' \
 46        > ${ROOT_NC_CONF}/autoconfig.php
 47    cat $ROOT_CONF/nextcloud/docker.config.php | sed 's|${NC_HOSTNAME}|'"${NC_HOSTNAME}"'|g' \
 48        | sed 's|${MAIL_DOMAINE}|'"${MAIL_DOMAINE}"'|g' \
 49        | sed 's|${ROOT_LOG}|'"${ROOT_LOG}"'|g' \
 50        | sed 's|${TZ}|'"${TZ}"'|g' \
 51        | sed 's|${ROOT_NC_LOG}|'"${ROOT_NC_LOG}"'|g' \
 52        | sed 's|${ROOT_NC_APPS}|'"${ROOT_NC_APPS}"'|g' \
 53        > ${ROOT_NC_CONF}/docker.config.php
 54
 55    # Manage right on config files
 56    echo "$(date +"%Y-%m-%d %H:%M:%S") - Info - Manage right on config files"
 57    chmod 644 /etc/mysql/mariadb.conf.d/50-server.cnf
 58    chmod 644 /etc/php/8.1/apache2/conf.d/20-pdo_mysql.ini
 59    chmod 644 /etc/php/8.1/apache2/php.ini
 60    chmod 644 /etc/apache2/sites-available/nextcloud.conf
 61    chmod 644 ${ROOT_NC_CONF}/*
 62
 63    # Init MariaDB service
 64    echo "$(date +"%Y-%m-%d %H:%M:%S") - Info - MariasDB : Install DB (mysql)"
 65    mariadb-install-db --user=mysql
 66    if [ $? -ne 0 ]; then echo "$(date +"%Y-%m-%d %H:%M:%S") - Error - MariasDB Install"; exit 1 ; fi
 67
 68    # Start MariaDB service
 69    echo "$(date +"%Y-%m-%d %H:%M:%S") - Info - MariasDB : Start service"
 70    service mariadb start
 71    if [ $? -ne 0 ]; then echo "$(date +"%Y-%m-%d %H:%M:%S") - Error - MariasDB Start"; exit 1 ; fi
 72
 73    # Create nextcloud user into MariaDB
 74    QRY_SQL="CREATE USER IF NOT EXISTS '${MYSQL_USER}'@'localhost' IDENTIFIED BY '${MYSQL_PASSWORD}';
 75    CREATE DATABASE IF NOT EXISTS ${MYSQL_DATABASE} CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
 76    GRANT ALL PRIVILEGES ON ${MYSQL_DATABASE}.* TO '${MYSQL_USER}'@'localhost';
 77    FLUSH PRIVILEGES;"
 78
 79    echo "$(date +"%Y-%m-%d %H:%M:%S") - Info - MariasDB : Create user et database"
 80    mariadb -u root -e "${QRY_SQL}"
 81    if [ $? -ne 0 ]; then echo "$(date +"%Y-%m-%d %H:%M:%S") - Error - MariasDB exec QRY"; exit 1 ; fi
 82
 83
 84    # Init Apache2 service
 85    echo "$(date +"%Y-%m-%d %H:%M:%S") - Info - Apache2 : Init conf"
 86    echo "ServerName ${STATIC_IP}" >> /etc/apache2/apache2.conf
 87    a2ensite nextcloud.conf
 88    a2enmod rewrite headers env dir mime ssl
 89
 90    # Start Apache2 service
 91    echo "$(date +"%Y-%m-%d %H:%M:%S") - Info - Apache2 : Start service"
 92    service apache2 start
 93    if [ $? -ne 0 ]; then echo "$(date +"%Y-%m-%d %H:%M:%S") - Error - apache2 service start"; exit 1 ; fi
 94
 95    # Manage folders rights
 96    echo "$(date +"%Y-%m-%d %H:%M:%S") - Info - Manage folders chown"
 97    chown -R www-data:www-data ${ROOT_NC}
 98    chown -R www-data:www-data ${ROOT_NC_DATA}
 99    chown -R www-data:www-data ${ROOT_NC_CONF}
100    chown -R www-data:www-data ${ROOT_NC_APPS}
101    chown -R mysql:mysql ${ROOT_DB_DATA}
102    chmod -R 766 ${ROOT_NC_LOG}
103    chmod -R 766 ${ROOT_DB_LOG}
104    chown -R www-data:www-data ${ROOT_NC_LOG}
105    chown -R www-data:www-data ${ROOT_DB_LOG}
106    
107
108    # Execute Nextcloud for the first time with HTTPS (initialize admin user and data folder)
109    openssl s_client -showcerts -connect ${NC_HOSTNAME}:443 </dev/null | sed -n -e '/-.BEGIN/,/-.END/ p' > /tmp/nextcloud.pem
110    curl --cacert /tmp/nextcloud.pem https://${NC_HOSTNAME}
111    rm /tmp/nextcloud.pem
112
113    # Start Cron service
114    service cron start
115    if [ $? -ne 0 ]; then echo "$(date +"%Y-%m-%d %H:%M:%S") - Error - cron service start"; exit 1 ; fi
116
117else
118    # If init already done : Start services
119    service mariadb start
120    if [ $? -ne 0 ]; then echo "$(date +"%Y-%m-%d %H:%M:%S") - Error - mariadb service start"; exit 1 ; fi
121    service apache2 start
122    if [ $? -ne 0 ]; then echo "$(date +"%Y-%m-%d %H:%M:%S") - Error - apache2 service start"; exit 1 ; fi
123    service cron start
124    if [ $? -ne 0 ]; then echo "$(date +"%Y-%m-%d %H:%M:%S") - Error - cron service start"; exit 1 ; fi
125
126fi
127
128# Infinite loop to keep service up
129while [ 1 ]; do 
130    sleep 300
131
132    # Check Apache2 service
133    CHECK_APACHE=$(service apache2 status | grep 'is running' | wc -l)
134    if [ "$CHECK_APACHE" != "1" ]; then
135        echo "$(date +"%Y-%m-%d %H:%M:%S") - Info - Restart apache2 service"
136        service apache2 start
137        CHECK_APACHE_2=$(service apache2 status | grep 'is running' | wc -l)
138        if [ "$CHECK_APACHE_2" != "1" ]; then
139            echo "$(date +"%Y-%m-%d %H:%M:%S") - Error - Service apache2 KO"
140            exit 1
141        fi
142    fi
143
144    # Check MariaDB service
145    CHECK_MARIADB=$(service mariadb status | grep 'Uptime' | wc -l)
146    if [ "$CHECK_MARIADB" != "1" ]; then
147        echo "$(date +"%Y-%m-%d %H:%M:%S") - Info - Restart mariadb service"
148        service mariadb start
149        CHECK_MARIADB_2=$(service mariadb status | grep 'Uptime' | wc -l)
150        if [ "$CHECK_MARIADB_2" != "1" ]; then
151            echo "$(date +"%Y-%m-%d %H:%M:%S") - Error - Service mariadb KO"
152            exit 1
153        fi
154    fi
155
156done
157
158exit 0

Création d’un fichier de configuration pour l’ensemble des variables d’environnement

Afin de pouvoir finaliser la création de l’image Docker, nous avons besoin de mettre en place un fichier .env afin de centraliser l’ensemble des variables d’environnements nécessaires au container et plus spécifique au script d’initialisation run_nextcloud.sh.

Ce fichier d’environnement est définie au niveau du fichier docker-compose.yml. Le fichier .envdoit être créé dans le répertoire /share/Docker/scripts/nextcloud_app/config.

Le contenu du fichier .env est le suivant : (en remplaçant les valeurs nécessaires pour votre environnement)

 1PUID=501
 2PGID=100
 3ROOT_DB_DATA=/var/lib/mysql
 4ROOT_NC=/var/www/nextcloud
 5ROOT_NC_DATA=/var/www/nextcloud/data
 6ROOT_NC_CONF=/var/www/nextcloud/config
 7ROOT_NC_LOG=/var/log/nextcloud
 8ROOT_DB_LOG=/var/log/mysql
 9ROOT_NC_APPS=/var/www/nextcloud/apps
10NC_HOSTNAME=<hostname (ex: nextcloud.nas.nas)>
11MYSQL_DATABASE=nextcloud
12MYSQL_USER=<nextcloud username for mariadb>
13MYSQL_PASSWORD=<nextcloud user password for mariadb>
14STATIC_IP=110.110.110.151
15MAIL_DOMAINE=nas@nas.nas
16TZ=Europe/Paris
17NC_ADMIN_PASSWORD=<nextcloud admin password>

Mise en place d’un script de démarrage sur le NAS QNAP

Afin de pouvoir relancer au démarrage du NAS QNAP le conteneur Docker de l’application Nextcloud :

  1. Allez dans Main Menu > ControlPanel > System > Hardware
  2. Dans l’onglet General, cochez l’option Run user defined processes during startup
  3. Connectez vous en SSH sur le NAS QNAS avec un compte administrateur : ssh <user>@<ip> -p <port>
  4. Exécutez les commandes suivante pour monter le répertoire /tmp/config
1ubiattach -m 6 -d 2
2/bin/mount -t ubifs ubi2:config /tmp/config
  1. Créez le fichier /tmp/config/autorun.sh avec le contenu suivant :
1#!/bin/sh
2cd /share/Docker/scripts/nextcloud_app
3docker compose up -d
  1. Exécuter les commandes suivante pour rendre exécutable le fichier /tmp/config/autorun.sh
1chmod +x /tmp/config/autorun.sh
2umount /tmp/config
3ubidetach -m 6

Exécution de l’application Nextcloud

Les étapes pour exécuter manuellement l’application Nextcloud sont les suivantes :

  1. Connectez vous SSH sur le NAS QNAP avec un compte administrateur : ssh <user>@<ip> -p <port>
  2. Positionnez vous dans le répertoire contenant les éléments de l’image docker : cd /share/Docker/scripts/nextcloud_app
  3. Exécutez la commande docker compose suivante : docker compose up -d
  4. Attendez quelques secondes/minutes et vérifiez la bonne exécution du conteneur en vous connectant sur l’application Nextcloud https://110.110.110.151

Vous pouvez vérifier la bonne exécution du conteneur en allant voir les informations dans l’application QNAP Container Station ou en utilisant les commande Docker (stats, logs, ps, …).

20231107_Blog_use_nextcloud_on_qnap_05

20231107_Blog_use_nextcloud_on_qnap_06

20231107_Blog_use_nextcloud_on_qnap_07

Commandes Docker

Quelques commandes concernant l’utilisation de Docker :

  • docker build -t nextcloud-qnas-img:v27 . : Permet de construire (build) l’image à partir du fichier Dockerfile du répertoire courant
    • docker build -t nextcloud-qnas-img:v27 . --build-arg build_TZ=Europe/Paris --build-arg build_PUID=501 --build-arg build_PGID=100 : Commande build avec argument
  • docker ps : Liste des conteneurs en cours d’exécution
  • docker ps -a : Liste de l’ensemble des conteneurs existants
  • docker stats : Statistiques d’utilisation des conteneurs en cours d’exécution
  • docker logs nextcloud-qnas : Message de log (sortie standard) du conteneur
  • docker create -i -t -v /share/Docker/nextcloud/...:/... -v ... --name nextcloud-qnas nextcloud-qnas-img:v27 : Création d’un conteneur nextcloud-qnas à partir de l’image nextcloud-qnas-img:v27
  • docker container start -a -i nextcloud-qnas : Démarrage d’un conteneur en accédant directement à la console
  • docker rm nextcloud-qnas : Permet de supprimer le conteneur

Si vous avez besoin de recréer manuellement les network propre au NAS QNAP pour Docker :

1# Create dhcp network
2docker network create -d qnet --opt=iface=eth0 --ipam-driver=qnet --ipam-opt=iface=eth0 qnet-dhcp-eth0
3
4# Create static network
5docker network create -d qnet --opt=iface=eth0 --ipam-driver=qnet --ipam-opt=iface=eth0 \
6      --subnet=110.110.110.0/24 --gateway=110.110.110.1 qnet-static-eth0

Quelques commandes concernant l’utilisation de Docker Compose : (Il faut se positionner dans le répertoire contenant le fichier `docker-compose.yaml)

  • docker compose build --build-arg TZ=Europe/Paris --build-arg PUID=501 --build-arg PGID=100 : Permet de faire la construction (build) à l’image de la commande Docker
  • docker compose up -d : Permet de créer et démarrer les conteneurs définis
  • docker compose down : Permet de d’arrêter et de supprimer les conteneurs définis
  • docker compose start : Permet de démarrer les conteneurs définis
  • docker compose stop : Permet d’arrêter les conteneurs définis