Nextcloud è una soluzione cloud open source piuttosto affermata e molto diffusa. Oltre ai client per sistemi operativi mobili e desktop, il software offre un com­po­nen­te server. In questo articolo vi mo­stre­re­mo come in­stal­la­re un server Nextcloud in un ambiente Docker.

Free Cloud Server Trial
Server virtuali pro­fes­sio­na­li di livello en­ter­pri­se
  • vServer basato su KVM per gli svi­lup­pa­to­ri
  • Integrato con IONOS Compute Engine
  • Scalabile fino al cloud aziendale Incl. € 200 di credito iniziale nel 1° mese

In­stal­la­re Nextcloud su Docker

Nextcloud è una soluzione cloud open source, prodotto derivato dal progetto ownCloud. La sua gamma di funzioni è pa­ra­go­na­bi­le a quella di soluzioni cloud come Microsoft 365 o Google Workspace. Nextcloud sin­cro­niz­za dati come ca­len­da­rio e contatti tra utenti e di­spo­si­ti­vi. Accanto alla sin­cro­niz­za­zio­ne di file ob­bli­ga­to­ria, la suite offre funzioni per la col­la­bo­ra­zio­ne e la co­mu­ni­ca­zio­ne interna ai team. Dal 2020 Nextcloud è persino uti­liz­za­to come base per il servizio cloud del Governo federale tedesco.

Come per altre soluzioni cloud, la gamma di funzioni di Nextcloud comprende anche un com­po­nen­te server e client sia per sistemi operativi desktop che mobili. Il server di Nextcloud gestisce i dati e comunica con i client; inoltre, mette a di­spo­si­zio­ne un’in­ter­fac­cia web in­di­pen­den­te.

In questo articolo vi guideremo at­tra­ver­so l’in­stal­la­zio­ne di un server Nextcloud su Ubuntu-Linux. Per farlo, ci serviremo di Docker Compose e pren­de­re­mo come ri­fe­ri­men­to l’in­stal­la­zio­ne su un’in­fra­strut­tu­ra cloud. In al­ter­na­ti­va, esiste la pos­si­bi­li­tà di in­stal­la­re il server su un proprio hardware e con­fi­gu­ra­re, ad esempio, Nextcloud su un Raspberry Pi.

Consiglio

Nextcloud e ownCloud hanno molto in comune. Nel nostro articolo ownCloud vs Nextcloud: due soluzioni cloud a confronto vi il­lu­stria­mo anche in cosa si dif­fe­ren­zia­no.

L’ar­chi­tet­tu­ra di Nextcloud

Per prima cosa, esa­mi­nia­mo quali com­po­nen­ti sono inclusi nel server di Nextcloud e come sono connessi tra loro. Oltre al software stesso di Nextcloud, vengono impiegati tre ulteriori servizi salvati in container (let­te­ral­men­te “con­te­ni­to­re” in italiano). Per fornire la rete del gruppo di container e ma­no­vrar­li come unità unica, ci serviamo di Compose, uno dei tool di Docker

Di seguito, una pa­no­ra­mi­ca dei singoli servizi:

  1. Nginx Reverse Proxy: ne­ces­sa­rio per rea­liz­za­re con­nes­sio­ni HTTPS crit­to­gra­fa­te per l’accesso a Nextcloud.
  2. Let’s Encrypt: uti­liz­za­to per la con­fi­gu­ra­zio­ne au­to­ma­ti­ca di cer­ti­fi­ca­ti SSL.
  3. MariaDB: per il sal­va­tag­gio dei dati a carico del server durante l’utilizzo di Nextcloud.
  4. Server Nextcloud: mette a di­spo­si­zio­ne la fun­zio­na­li­tà effettiva di Nextcloud co­mu­ni­can­do con i client di Nextcloud e oc­cu­pan­do­si dell’hosting della piat­ta­for­ma web.

Preparare il server di Nextcloud all’in­stal­la­zio­ne

Prima di tutto, è ne­ces­sa­rio in­stal­la­re Docker Engine e Docker Compose su un sistema Ubuntu-Linux appena con­fi­gu­ra­to. Docker Engine prepara le fun­zio­na­li­tà di base dei container, mentre Docker Compose permette la gestione di gruppi di container simili. Se Docker Engine e Docker Compose sono già in­stal­la­ti, potete saltare questo passaggio.

In­stal­la­re Docker Engine su Ubuntu

In questo articolo vi il­lu­stre­re­mo come procedere all’in­stal­la­zio­ne su Ubuntu-Linux facendo ri­fe­ri­men­to alle istru­zio­ni ufficiali. Per altre di­stri­bu­zio­ni Linux trovate le ri­spet­ti­ve istru­zio­ni sul sito web di Docker. Co­min­cia­mo quindi con l’in­stal­la­zio­ne di Docker Engine:

  1. Rimuovere l’eventuale in­stal­la­zio­ne Docker, se presente:
sudo apt-get remove docker docker-engine docker.io containerd runc
  1. Ag­gior­na­re il file “installer” alla versione più recente:
sudo apt-get update
  1. Preparare i re­po­si­to­ry:
sudo apt-get install \
ca-certificates \
curl \
gnupg \
lsb-release
  1. Ag­giun­ge­re la chiave GPG Docker ufficiale:
 curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
  1. Con­fi­gu­ra­re un re­po­si­to­ry Docker stabile:
 echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
  1. Ag­gior­na­re i re­po­si­to­ry alla versione più recente:
sudo apt-get update
  1. In­stal­la­re Docker Engine, incluse le di­pen­den­ze:
sudo apt-get install docker-ce docker-ce-cli containerd.io
  1. Per finire, eseguire il container “Hello World” a fini di verifica.

Se Docker Engine è stato in­stal­la­to cor­ret­ta­men­te, il container “Hello World” verrà eseguito fornendo l’omonimo messaggio.

sudo docker run hello-world

In­stal­la­re Docker Compose su Ubuntu

Suc­ces­si­va­men­te, ci oc­cu­pe­re­mo dell’in­stal­la­zio­ne di Docker Compose. Il processo di in­stal­la­zio­ne è più semplice e veloce rispetto all’in­stal­la­zio­ne di Docker Engine. Nello specifico, dovremo compiere i seguenti passaggi:

  1. Attivare il re­po­si­to­ry Universe di Ubuntu:
sudo add-apt-repository universe
  1. Ag­gior­na­re la gestione dei pacchetti alla versione più recente:
sudo apt update
  1. In­stal­la­re Docker Compose:
sudo apt install docker-compose
  1. Ve­ri­fi­ca­re se Docker Compose sia stato in­stal­la­to cor­ret­ta­men­te:
docker-compose --version

Se appare un numero di versione, significa che Docker Compose è stato in­stal­la­to cor­ret­ta­men­te.

Eseguire l’in­stal­la­zio­ne del server Nextcloud

Non appena Docker Engine e Docker Compose sono stati in­stal­la­ti, si può procedere con la vera e propria in­stal­la­zio­ne di Nextcloud. Per farlo, con­fi­gu­re­re­mo i container Docker per i diversi servizi. Per la con­fi­gu­ra­zio­ne dei container, dei volumi e delle reti Docker ne­ces­sa­rie si impiegano due file di con­fi­gu­ra­zio­ne:

File Spie­ga­zio­ne
docker-compose.yaml Istru­zio­ni Docker Compose in formato YAML per la co­stru­zio­ne di ap­pli­ca­zio­ni multi-container
.env File di testo con variabili di ambiente; una de­fi­ni­zio­ne di variabile per riga

Come già accennato, Docker Compose serve alla gestione di ap­pli­ca­zio­ni multi-container. A tal proposito si uti­liz­za­no istru­zio­ni Docker Compose che de­fi­ni­sco­no come deve essere strut­tu­ra­ta l’ap­pli­ca­zio­ne e come in­te­ra­gi­sco­no i singoli com­po­nen­ti tra loro. Le istru­zio­ni Docker Compose de­scri­vo­no i singoli servizi, gli elementi Docker e le im­po­sta­zio­ni; inoltre sono scritti in lin­guag­gio YAML (“Yet Another Markup Language”, tradotto in italiano: “l’ennesimo lin­guag­gio di markup”). Pro­ce­dia­mo ora a creare pro­gres­si­va­men­te il file docker-compose.yaml uti­liz­za­to.

Accanto a docker-compose.yaml è ne­ces­sa­rio un ulteriore file, il quale contiene variabili di ambiente, incluse nelle istru­zio­ni di Docker Compose. Per im­po­sta­zio­ne pre­de­fi­ni­ta, le variabili di ambiente si rac­col­go­no in un file .env nella cartella del progetto insieme ai valori. Il file .env, che non viene acquisito nel sistema di controllo delle versioni, si occupa di pro­teg­ge­re dati sensibili come le password.

L’utilizzo di un file .env rende superfluo definire diverse im­po­sta­zio­ni per diversi ambienti di ap­pli­ca­zio­ne. Ad esempio, per uti­liz­za­re im­po­sta­zio­ni dif­fe­ren­ti per un sito live e uno di staging, è ne­ces­sa­rio mo­di­fi­ca­re esclu­si­va­men­te il ri­spet­ti­vo file .env.

Creare le strutture ne­ces­sa­rie per il server Nextcloud

Per iniziare con l’in­stal­la­zio­ne del server Nextcloud ci servono una serie di strutture. Nei seguenti passaggi vi spie­ghia­mo come crearle:

  1. Creare la cartella del progetto. Create la cartella nextcloud-docker nella directory home dell’utente:
mkdir ~/nextcloud-docker/
  1. Creare i file. Create i file docker-compose.yaml ed .env nella cartella del progetto:
touch ~/nextcloud-docker/docker-compose.yaml
touch ~/nextcloud-docker/.env
  1. Creare una rete Docker. Uti­liz­za­te il comando docker per creare una nuova rete. I quattro container co­mu­ni­ca­no all’interno della rete.
docker network create nextcloud_network

Una volta create le strutture, pro­se­guia­mo con l’in­stal­la­zio­ne del server Nextcloud.

Con­fi­gu­ra­re un reverse proxy per il server Nextcloud

Per in­stal­la­re il server Nextcloud iniziate con la con­fi­gu­ra­zio­ne di un reverse proxy e per farlo, servitevi di Nginx. Dal momento che la vostra ap­pli­ca­zio­ne sarà composta da container, la maggior parte della routine di in­stal­la­zio­ne avrà luogo all’interno del file docker-compose.yaml. Di seguito vi il­lu­stre­re­mo in dettaglio come mo­di­fi­ca­re questo file. Replicate gli esempi raf­fi­gu­ra­ti nei seguenti passaggi del processo di in­stal­la­zio­ne:

  1. Aprire il file docker-compose.yaml per l’ela­bo­ra­zio­ne.

Il seguente comando apre il file ancora vuoto nell’editor “Nano”:

nano ~/nextcloud-docker/docker-compose.yaml
  1. Ag­giun­ge­re il seguente blocco di codice in Nano e salvare il file.

Per chiudere il file uti­liz­za­te la com­bi­na­zio­ne di tasti [Ctrl] + [X]. Alla domanda se vogliate salvare il file ri­spon­de­te premendo “Y” per “yes” (“sì”). Con­fer­ma­te l’utilizzo del nome del file esistente con il tasto [Invio].

In al­ter­na­ti­va, lasciate aperto l’editor e uti­liz­za­te la com­bi­na­zio­ne di tasti [Ctrl] + [O] (“Write out”, ovvero “Scrivi nel file”) per scrivere il testo dell’editor nel file.

version: '3'
services:
  proxy:
    image: jwilder/nginx-proxy:alpine
    labels:
      - "com.github.jrcs.letsencrypt_nginx_proxy_companion.nginx_proxy=true"
    container_name: nextcloud-proxy
    networks:
      - nextcloud_network
    ports:
      - 80:80
      - 443:443
    volumes:
      - ./proxy/conf.d:/etc/nginx/conf.d:rw
      - ./proxy/vhost.d:/etc/nginx/vhost.d:rw
      - ./proxy/html:/usr/share/nginx/html:rw
      - ./proxy/certs:/etc/nginx/certs:ro
      - /etc/localtime:/etc/localtime:ro
      - /var/run/docker.sock:/tmp/docker.sock:ro
    restart: unless-stopped

Ma cosa si­gni­fi­ca­no le singoli voci? In­nan­zi­tut­to, date l’ordine a Docker Compose di creare un nuovo servizio con il nome proxy e uti­liz­za­re un’immagine Nginx basata su Alpine-Linux. Suc­ces­si­va­men­te, stabilite che il reverse proxy deve co­mu­ni­ca­re con gli altri servizi tramite la rete Docker nextcloud_network.

Dopodiché, mappate le porte standard HTTP e HTTPS 80, o meglio 443, del sistema host sui container. In questo modo le con­nes­sio­ni in entrata vengono inoltrate tramite il proxy. L’ultimo passaggio della con­fi­gu­ra­zio­ne prevede di creare diversi volumi Docker e stabilire che il reverse proxy si riavvii au­to­ma­ti­ca­men­te, a meno che non sia stato espli­ci­ta­men­te in­ter­rot­to.

Con­fi­gu­ra­re il servizio Let’s Encrypt per il server Nextcloud

Pro­se­gui­te in­stal­lan­do Let’s Encrypt. Ciò per­met­te­rà la co­mu­ni­ca­zio­ne crit­to­gra­fa­ta con il server Nextcloud tramite HTTPS.

  1. Aprire il file docker-compose.yaml per ela­bo­rar­lo:
nano ~/nextcloud-docker/docker-compose.yaml
  1. Ag­giun­ge­re un blocco Service.

Procedete come descritto nel pre­ce­den­te passaggio, facendo at­ten­zio­ne all’in­den­ta­zio­ne: l’inizio del blocco che inizia con le­tsen­crypt: deve essere sul medesimo livello di proxy:. Questo vale anche per i blocchi Service suc­ces­si­vi.

letsencrypt:
  image: jrcs/letsencrypt-nginx-proxy-companion
  container_name: nextcloud-letsencrypt
  depends_on:
    - proxy
  networks:
    - nextcloud_network
  volumes:
    - ./proxy/certs:/etc/nginx/certs:rw
    - ./proxy/vhost.d:/etc/nginx/vhost.d:rw
    - ./proxy/html:/usr/share/nginx/html:rw
    - /etc/localtime:/etc/localtime:ro
    - /var/run/docker.sock:/var/run/docker.sock:ro
  restart: unless-stopped

Come in pre­ce­den­za, definite un nuovo servizio con il nome le­tsen­crypt, il quale si basa sul container le­tsen­crypt-nginx-proxy-companion. Stabilite che il servizio sia di­pen­den­te dal servizio del reverse proxy e comunichi nella medesima rete Docker. Suc­ces­si­va­men­te, indicate i volumi Docker necessari per lo scambio di dati. Anche in questo caso, stabilite che il servizio si riavvii au­to­ma­ti­ca­men­te a meno che non sia stato in­ter­rot­to espli­ci­ta­men­te.

Consiglio
De­si­de­ra­te una crit­to­gra­fia pro­fes­sio­na­le per il vostro sito web? Ac­qui­sta­te un cer­ti­fi­ca­to SSL sul sito web di IONOS!

Con­fi­gu­ra­re il servizio MariaDB per il server Nextcloud

Una volta com­ple­ta­ta la con­fi­gu­ra­zio­ne del reverse proxy e di Let’s Encrypt, siete a metà dell’in­stal­la­zio­ne. Pro­se­gui­te ora con il database MariaDB, in­di­spen­sa­bi­le per la gestione dei dati prodotti durante l’utilizzo di Nextcloud. Il sal­va­tag­gio effettivo tramite volumi Docker avviene al di fuori del container.

  1. Aprire il file docker-compose.yaml per l’ela­bo­ra­zio­ne:
nano ~/nextcloud-docker/docker-compose.yaml
  1. Ag­giun­ge­re un altro blocco Service:
db:
  image: mariadb
  container_name: nextcloud-mariadb
  networks:
    - nextcloud_network
  volumes:
    - db:/var/lib/mysql
    - /etc/localtime:/etc/localtime:ro
  environment:
    - MYSQL_ROOT_PASSWORD
    - MYSQL_PASSWORD
    - MYSQL_DATABASE
    - MYSQL_USER
  restart: unless-stopped

A questo punto, la maggior parte delle im­po­sta­zio­ni dovrebbe esservi nota. Definite ora un servizio db basato sull’immagine Docker mariadb. Infine, stabilite la rete nextcloud_network, già impiegata per gli altri servizi, e un volume Docker per il sal­va­tag­gio dei dati.

La novità in questo blocco di con­fi­gu­ra­zio­ne è l’utilizzo di variabili di ambiente. Nel segmento en­vi­ron­ment immettete il nome per le variabili di ambiente ne­ces­sa­rie per MariaDB. I valori effettivi saranno letti in seguito durante l’ese­cu­zio­ne di Docker Compose a partire dal file .env.

Con­fi­gu­ra­re il container del server Nextcloud

Fi­nal­men­te, siamo arrivati all’in­stal­la­zio­ne vera e propria del software server Nextcloud.

  1. Aprire il file docker-compose.yaml per l’ela­bo­ra­zio­ne:
nano ~/nextcloud-docker/docker-compose.yaml
  1. Inserire un ulteriore blocco Service:
app:
  image: nextcloud:latest
  container_name: nextcloud-app
  networks:
    - nextcloud_network
  depends_on:
    - letsencrypt
    - proxy
    - db
  volumes:
    - nextcloud:/var/www/html
    - ./app/config:/var/www/html/config
    - ./app/custom_apps:/var/www/html/custom_apps
    - ./app/data:/var/www/html/data
    - ./app/themes:/var/www/html/themes
    - /etc/localtime:/etc/localtime:ro
  environment:
    - VIRTUAL_HOST
    - LETSENCRYPT_HOST
    - LETSENCRYPT_EMAIL
  restart: unless-stopped

Create un servizio con il nome app, il quale si basa sull’immagine Docker nextcloud e che comunica nella già nota rete nextcloud_network. Per as­si­cu­rar­vi che il container Nextcloud venga avviato per ultimo, de­ter­mi­na­te che gli altri servizi siano di­pen­den­ze. Per ultimo, definite i volumi Docker necessari e le variabili di ambiente.

Portare a termine la con­fi­gu­ra­zio­ne del server Nextcloud

Per con­clu­de­re la con­fi­gu­ra­zio­ne del server Nextcloud, avrete bisogno di inserire un altro paio di voci all’interno del file docker-compose.yaml. Sarà anche ne­ces­sa­rio creare il file .env in­se­ren­do­vi i ri­spet­ti­vi valori.

  1. Aprire il file docker-compose.yaml per l’ela­bo­ra­zio­ne:
nano ~/nextcloud-docker/docker-compose.yaml
  1. Ag­giun­ge­re i seguenti blocchi.

In questo caso non si tratta di blocchi Service; l’in­den­ta­zio­ne deve quindi avvenire sullo stesso livello di services:.

volumes:
  nextcloud:
  db:
networks:
  nextcloud_network:
  1. Aprire il file vuoto .env per l’ela­bo­ra­zio­ne:
nano ~/nextcloud-docker/.env
  1. Scrivere le variabili di ambiente, inclusi i valori contenuti nel file .env:

Copiate il seguente codice nella finestra dell’editor e, prima di salvarlo, so­sti­tui­te i <se­gna­po­sto> con i valori de­si­de­ra­ti.

# MariaDB
MYSQL_ROOT_PASSWORD=toor
MYSQL_PASSWORD=mysql
MYSQL_DATABASE=nextcloud
MYSQL_USER=nextcloud
# Nextcloud
VIRTUAL_HOST=<your.domain></your.domain>
LETSENCRYPT_HOST=<your.domain></your.domain>
LETSENCRYPT_EMAIL=<your@email></your@email>
  1. Dopo il sal­va­tag­gio, vi­sua­liz­za­te il contenuto del file .env per ve­ri­fi­ca­re che l’in­se­ri­men­to dei valori sia avvenuto cor­ret­ta­men­te:
cat ~/nextcloud-docker/.env

Con­fi­gu­ra­zio­ne completa del server Nextcloud

Prima di tra­smet­te­re la con­fi­gu­ra­zio­ne creata a Docker Compose e quindi creare e avviare i container, ve­ri­fi­ca­te che tutto il ne­ces­sa­rio sia al suo posto.

  1. Emettere la con­fi­gu­ra­zio­ne esistente:
cat ~/nextcloud-docker/docker-compose.yaml
  1. Con­fron­ta­re con il vostro esempio. L’output della con­fi­gu­ra­zio­ne dovrebbe cor­ri­spon­de­re al seguente codice:
version: '3'
services:
  proxy:
    image: jwilder/nginx-proxy:alpine
    labels:
      - "com.github.jrcs.letsencrypt_nginx_proxy_companion.nginx_proxy=true"
    container_name: nextcloud-proxy
    networks:
      - nextcloud_network
    ports:
      - 80:80
      - 443:443
    volumes:
      - ./proxy/conf.d:/etc/nginx/conf.d:rw
      - ./proxy/vhost.d:/etc/nginx/vhost.d:rw
      - ./proxy/html:/usr/share/nginx/html:rw
      - ./proxy/certs:/etc/nginx/certs:ro
      - /etc/localtime:/etc/localtime:ro
      - /var/run/docker.sock:/tmp/docker.sock:ro
    restart: unless-stopped
  letsencrypt:
    image: jrcs/letsencrypt-nginx-proxy-companion
    container_name: nextcloud-letsencrypt
    depends_on:
      - proxy
    networks:
      - nextcloud_network
    volumes:
      - ./proxy/certs:/etc/nginx/certs:rw
      - ./proxy/vhost.d:/etc/nginx/vhost.d:rw
      - ./proxy/html:/usr/share/nginx/html:rw
      - /etc/localtime:/etc/localtime:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
    restart: unless-stopped
  db:
    image: mariadb
    container_name: nextcloud-mariadb
    networks:
      - nextcloud_network
    volumes:
      - db:/var/lib/mysql
      - /etc/localtime:/etc/localtime:ro
    environment:
      - MYSQL_ROOT_PASSWORD
      - MYSQL_PASSWORD
      - MYSQL_DATABASE
      - MYSQL_USER
    restart: unless-stopped
  app:
    image: nextcloud:latest
    container_name: nextcloud-app
    networks:
      - nextcloud_network
    depends_on:
      - letsencrypt
      - proxy
      - db
    volumes:
      - nextcloud:/var/www/html
      - ./app/config:/var/www/html/config
      - ./app/custom_apps:/var/www/html/custom_apps
      - ./app/data:/var/www/html/data
      - ./app/themes:/var/www/html/themes
      - /etc/localtime:/etc/localtime:ro
    environment:
      - VIRTUAL_HOST
      - LETSENCRYPT_HOST
      - LETSENCRYPT_EMAIL
    restart: unless-stopped
volumes:
  nextcloud:
  db:
networks:
  nextcloud_network:

Se la vostra versione del file YAML cor­ri­spon­de a quella riportata qui, potete pro­se­gui­re con l’ultimo passaggio.

Con­clu­de­re l’in­stal­la­zio­ne del server Nextcloud

Per generare il server Nextcloud come ap­pli­ca­zio­ne multi-container dalle istru­zio­ni di Docker Compose, eseguite il seguente comando sulla riga di comando:

cd ~/nextcloud-docker/ && docker-compose up -d

Infine, ve­ri­fi­ca­te che i container siano stati avviati:

docker ps -a

L’elenco dei container avviati dovrebbe contenere i quattro container definiti nel file docker-compose.yaml.

Vai al menu prin­ci­pa­le