Nextcloud se ha es­ta­ble­ci­do como una solución en la nube de código abierto. El software también incluye, además de los clientes para sistemas ope­ra­ti­vos de es­cri­to­rio y móviles, un co­m­po­ne­n­te de servidor. A co­n­ti­nua­ción, descubre cómo se puede instalar un Nextcloud Server en un entorno Docker.

Free Cloud Server Trial
Servidor virtual privado para empresas
  • vServer basado en KVM para de­sa­rro­lla­do­res
  • Integrado en IONOS Compute Engine
  • Escalable hasta la nube em­pre­sa­rial Incl. 200 € de crédito inicial en el 1er mes

Instalar Nextcloud en Docker

Nextcloud es una solución en la nube de código abierto que nació como una bi­fu­r­ca­ción del proyecto ownCloud. Su gama de funciones se asemeja a la de otras so­lu­cio­nes pro­pie­ta­rias en la nube, como Microsoft 365 o Google Workspace. Nextcloud si­n­cro­ni­za datos como ca­le­n­da­rios y contactos entre personas y di­s­po­si­ti­vos. Además de la si­n­cro­ni­za­ción de archivos obli­ga­to­ria, tiene otras funciones orie­n­ta­das a la co­la­bo­ra­ción y co­mu­ni­ca­ción interna del equipo. Nextcloud también sirve de base para la “Bu­n­de­s­cloud” de la Ad­mi­ni­s­tra­ción Federal Alemana, que está en fu­n­cio­na­mie­n­to desde 2020.

Como es habitual en las so­lu­cio­nes en la nube similares, Nextcloud consta tanto de una sección dedicada a se­r­vi­do­res como de una dedicada a los clientes para sistemas ope­ra­ti­vos de or­de­na­do­res y móviles. Nextcloud Server gestiona los datos y se comunica con los clientes, aunque también pro­po­r­cio­na una interfaz web in­de­pe­n­die­n­te del cliente.

Descubre cómo instalar un Nextcloud Server en Ubuntu Linux. Es decir, una in­s­ta­la­ción en una es­tru­c­tu­ra en la nube, para lo que se usa Docker Compose. También es posible instalar el servidor en un hardware propio e incluso instalar Nextcloud en una Raspberry Pi, por ejemplo.

Consejo

Nextcloud y ownCloud tienen muchos puntos en común. En el artículo sobre ownCloud vs. Nextcloud puedes encontrar las di­fe­re­n­cias entre ambos.

Ar­qui­te­c­tu­ra de Nextcloud en Docker

En primer lugar, descubre qué co­m­po­ne­n­tes tiene un Nextcloud Server con Docker y cómo se conectan estos entre sí. Además del software de Nextcloud pro­pia­me­n­te dicho se utilizan otros tres servicios de co­n­te­ne­do­res. Para poder apro­vi­sio­nar a la red de co­n­te­ne­do­res y poder co­n­tro­lar­la como una sola unidad se utiliza una Docker tool llamada Compose. A co­n­ti­nua­ción, se presenta una lista con los distintos servicios que se utilizan:

  1. Nginx Reverse Proxy: se utiliza para poder acceder a Nextcloud mediante co­ne­xio­nes HTTPS en­cri­p­ta­das
  2. Let’s Encrypt: sirve para co­n­fi­gu­rar au­to­má­ti­ca­me­n­te los ce­r­ti­fi­ca­dos SSL
  3. MariaDB: se utiliza para almacenar los datos generados por el servidor mientras Nextcloud está en uso
  4. Nextcloud Server: es el que pro­po­r­cio­na la verdadera fu­n­cio­na­li­dad de Nextcloud; se comunica con los clientes de Nextcloud y lleva a cabo el hosting de la interfaz web

Preparar la in­s­ta­la­ción del Nextcloud Server

En un nuevo sistema operativo de Linux Ubuntu hay que instalar Docker Engine y Docker Compose primero. Docker Engine pro­po­r­cio­na el núcleo de las funciones de co­n­te­ne­do­res, mientras que Docker Compose permite la gestión de conjuntos de co­n­te­ne­do­res re­la­cio­na­dos. Si ya tienes instalado Docker Engine y Docker Compose, puedes saltarte esta sección.

Instalar Docker Engine en Ubuntu

En esta sección puedes aprender a instalar Docker Engine en Ubuntu Linux. Para ello se siguen las in­s­tru­c­cio­nes de in­s­ta­la­ción oficiales. Para realizar la in­s­ta­la­ción en otras di­s­tri­bu­cio­nes de Linux se pueden encontrar in­s­tru­c­cio­nes al respecto en la web de Docker. A co­n­ti­nua­ción, se presentan los pasos para instalar Docker Engine:

  1. Elimina cualquier in­s­ta­la­ción de Docker ya existente:
sudo apt-get remove docker docker-engine docker.io containerd runc
  1. Actualiza el in­s­ta­la­dor a la versión más reciente:
sudo apt-get update
  1. Prepara los re­po­si­to­rios:
sudo apt-get install \
ca-certificates \
curl \
gnupg \
lsb-release
  1. Añade la clave GPG oficial de Docker:
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
  1. Configura un re­po­si­to­rio estable de Docker:
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. Actualiza los re­po­si­to­rios a la versión más reciente:
sudo apt-get update
  1. Instala Docker Engine junto a sus co­m­po­ne­n­tes de­pe­n­die­n­tes:
sudo apt-get install docker-ce docker-ce-cli containerd.io
  1. Por último, pero no por ello menos im­po­r­ta­n­te, ejecuta el co­n­te­ne­dor “Hello World” a modo de prueba.

Si se ha instalado Docker Engine co­rre­c­ta­me­n­te, el co­n­te­ne­dor se ejecutará y emitirá el mensaje co­rre­s­po­n­die­n­te.

sudo docker run hello-world

Instalar Docker Compose en Ubuntu

A co­n­ti­nua­ción, procede a la in­s­ta­la­ción de Docker Compose. El proceso de in­s­ta­la­ción es más sencillo y menos vo­lu­mi­no­so que el del Docker Engine. En concreto, estos son los pasos que seguir:

  1. Activa el re­po­si­to­rio Universe de Ubuntu:
sudo add-apt-repository universe
  1. Actualiza la gestión de paquetes a la versión más reciente:
sudo apt update
  1. Instala Docker Compose:
sudo apt install docker-compose
  1. Compueba que Docker Compose se ha instalado co­rre­c­ta­me­n­te:
docker-compose --version

Si te muestra el número de la versión de tu Docker Compose, sabes que se ha instalado co­rre­c­ta­me­n­te.

Llevar a cabo la in­s­ta­la­ción del Nextcloud Server

Una vez in­s­ta­la­dos Docker Engine y Docker Compose, se comienza con la in­s­ta­la­ción de Nextcloud pro­pia­me­n­te dicha. Para ello, hay que co­n­fi­gu­rar in­di­vi­dua­l­me­n­te cada co­n­te­ne­dor Docker para que preste su servicio designado. Para co­n­fi­gu­rar los volúmenes y redes de Docker al igual que los co­n­te­ne­do­res ne­ce­sa­rios se utilizan dos archivos de co­n­fi­gu­ra­ción:

Archivo Ex­pli­ca­ción
docker-compose.yaml In­s­tru­c­cio­nes de Docker Compose en formato YAML para generar la es­tru­c­tu­ra de la apli­ca­ción mu­l­ti­co­n­te­ne­dor
.env Archivo de texto con variables del entorno; se define una variable por línea

Docker Compose se utiliza para gestionar apli­ca­cio­nes mu­l­ti­co­n­te­ne­dor. Las entradas rea­li­za­das en Docker Compose se usan para definir cómo se construye la apli­ca­ción y cómo in­ter­ac­túan los co­m­po­ne­n­tes in­di­vi­dua­les entre sí. Las entradas de Docker Compose describen los di­fe­re­n­tes servicios, elementos y co­n­fi­gu­ra­cio­nes de Docker y están escritas en el lenguaje YAML (“Yet Another Markup Language”). Descubre cómo el archivo docker-compose.yaml paso a paso.

Además de docker-compose.yaml, se necesita también otro archivo. Este contiene las variables de entorno que se integran en las entradas de Docker Compose. Las variables de entorno y sus valores se almacenan por defecto en un archivo .env en la carpeta del proyecto. El archivo .env no figura en el sistema de control de versiones para proteger datos sensibles, como las co­n­tra­se­ñas, de ser di­vu­l­ga­dos ac­ci­de­n­ta­l­me­n­te.

Al utilizar un archivo .env resulta muy fácil definir di­fe­re­n­tes co­n­fi­gu­ra­cio­nes para distintos entornos de apli­ca­ción. Por ejemplo, para utilizar di­fe­re­n­tes co­n­fi­gu­ra­cio­nes en una página web en vivo y en un sitio de staging, basta con cambiar el archivo .env co­rre­s­po­n­die­n­te.

Crear las es­tru­c­tu­ras ne­ce­sa­rias para Nextcloud Server

Para empezar a instalar Nextcloud Server se necesita un cierto número de es­tru­c­tu­ras. Estas es­tru­c­tu­ras se crean con los si­guie­n­tes pasos:

  1. Crea la carpeta del proyecto. Crea la carpeta nextcloud-docker en el di­re­c­to­rio principal del usuario:
mkdir ~/nextcloud-docker/
  1. Crea archivos. Crea los archivos docker-compose.yaml y .env en la carpeta del proyecto:
touch ~/nextcloud-docker/docker-compose.yaml
touch ~/nextcloud-docker/.env
  1. Crea una red Docker. Utiliza el comando docker para crear una nueva red. Los cuatro co­n­te­ne­do­res se comunican dentro de esa misma red.
docker network create nextcloud_network

Una vez creadas estas es­tru­c­tu­ras hay que continuar con la in­s­ta­la­ción de Nextcloud Server.

Co­n­fi­gu­rar el proxy inverso para Nextcloud Server

Comienza con la in­s­ta­la­ción de Nextcloud Server co­n­fi­gu­ra­n­do el proxy inverso. Para ello se utiliza Nginx. Dado que se está co­n­s­tru­ye­n­do la apli­ca­ción a partir de co­n­te­ne­do­res, la mayor parte del proceso de in­s­ta­la­ción tiene lugar en el archivo docker-compose.yaml. Describe en detalle cómo editar este archivo. Sigue los si­guie­n­tes pasos para la in­s­ta­la­ción:

  1. Abre el archivo docker-compose.yaml para editarlo.

El comando que se muestra a co­n­ti­nua­ción abre el archivo, que todavía está vacío, en el editor “Nano”:

nano ~/nextcloud-docker/docker-compose.yaml
  1. Inserta el siguiente bloque de código en Nano y guarda el archivo.

Para cerrar el archivo, utiliza la co­m­bi­na­ción de teclas [Ctrl] + [X] o [Ctrl] + [X]. Responde a la pregunta de guardar el archivo con “y” que significa “yes”/“sí”. Con la tecla [Enter] confirma que quieres mantener el nombre del archivo actual.

Como al­te­r­na­ti­va, puedes dejar el editor abierto y utilizar la co­m­bi­na­ción de teclas [Ctrl] + [O] (“Write out”, es decir, “escribir en el archivo”) para escribir el texto del editor en el archivo.

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

¿Qué significa cada una de las entradas in­di­vi­dua­les? Primero, dices a Docker Compose que cree un nuevo servicio llamado proxy usando una imagen Nginx de Alpine Linux. También hay que es­pe­ci­fi­car que el proxy inverso debe co­mu­ni­car­se con los otros servicios a través de la red Docker llamada nextcloud_network.

Asigna los puertos 80 y 443 es­tá­n­da­res de HTTP y HTTPS re­s­pe­c­ti­va­me­n­te entre el sistema host y el co­n­te­ne­dor. De esta manera, las co­ne­xio­nes que llegan se enrutan a través del proxy. Como último paso en la co­n­fi­gu­ra­ción, crea varios volúmenes Docker y es­pe­ci­fi­ca que el proxy inverso se debe reiniciar au­to­má­ti­ca­me­n­te si no ha sido detenido ex­plí­ci­ta­me­n­te.

Co­n­fi­gu­rar el servicio Let's Encrypt para Nextcloud Server

Continúa entonces con la in­s­ta­la­ción de Let's Encrypt. Este servicio permite la co­mu­ni­ca­ción cifrada con Nextcloud Server mediante HTTPS.

  1. Abre el archivo docker-compose.yaml para editarlo:
nano ~/nextcloud-docker/docker-compose.yaml
  1. Añade otro service block.

Procede como se ha descrito en el apartado anterior y presta atención a la sangría: El inicio del bloque que comienza con letse­n­cr­y­pt: debe estar a la misma altura que proxy:. Esto también se debe aplicar a futuros service blocks que quieras añadir.

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

De nuevo, define un nuevo servicio bajo el nombre letse­n­cr­y­pt, basado en el co­n­te­ne­dor letse­n­cr­y­pt-nginx-proxy-companion. Es­pe­ci­fi­ca que el servicio letse­n­cr­y­pt depende del servicio de proxy inverso y se comunica en la misma red Docker. Además, define los volúmenes Docker ne­ce­sa­rios para el in­te­r­ca­m­bio de datos. También establece que este servicio nuevo se debe reiniciar au­to­má­ti­ca­me­n­te si no se ha detenido de forma explícita.

Consejo

¿Quieres que tu web tenga un cifrado pro­fe­sio­nal? Adquiere tu propio ce­r­ti­fi­ca­do SSL barato con IONOS.

Co­n­fi­gu­rar el servicio MariaDB para Nextcloud Server

Con la co­n­fi­gu­ra­ción del proxy inverso y Let's Encrypt has co­m­ple­ta­do la mitad de la in­s­ta­la­ción. Ahora hay que continuar con la base de datos MariaDB, necesaria para gestionar los datos que se acumulan durante el uso de Nextcloud. El verdadero al­ma­ce­na­mie­n­to se hace a través de un volumen Docker externo al co­n­te­ne­dor.

  1. Abre el archivo docker-compose.yaml para editarlo:
nano ~/nextcloud-docker/docker-compose.yaml
  1. Inserta otro service block:
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 estas alturas, la mayoría de los ajustes ya te deberían resultar fa­mi­lia­res. Define un servicio db a partir de la imagen Docker con el nombre de mariadb. A co­n­ti­nua­ción, define la red nextcloud_network­, que ya se utiliza para el resto de servicios, y un volumen Docker para almacenar los datos.

La novedad en este bloque que estás co­n­fi­gu­ra­n­do es el uso de variables de entorno. En la sección del entorno es­pe­ci­fi­ca los nombres de las variables de entorno ne­ce­sa­rias para MariaDB. Una vez ejecutado Docker Compose, los valores reales se pueden ver en el archivo .env.

Co­n­fi­gu­rar el co­n­te­ne­dor Nextcloud Server

Ha llegado el momento: empieza con la in­s­ta­la­ción del software del Nextcloud Server pro­pia­me­n­te dicho.

  1. Abre el archivo docker-compose.yaml para editarlo:
nano ~/nextcloud-docker/docker-compose.yaml
  1. Introduce otro service block:
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

A partir de la imagen Docker de­no­mi­na­da nextcloud crea un servicio llamado app, que se comunica mediante la red, ya conocida, con el nombre de nextcloud_network. Para asegurar que el co­n­te­ne­dor nextcloud sea el último en iniciarse, configura los demás servicios como de­pe­n­die­n­tes de este. Además, define los volúmenes Docker y las variables de entorno ne­ce­sa­rios.

Terminar la co­n­fi­gu­ra­ción de Nextcloud Server

Para completar la co­n­fi­gu­ra­ción del Nextcloud Server son ne­ce­sa­rias algunas entradas más en el archivo docker-compose.yaml. Además, crea el archivo .env y co­m­plé­ta­lo con los valores adecuados.

  1. Abre el archivo docker-compose.yaml para editarlo:
nano ~/nextcloud-docker/docker-compose.yaml
  1. Inserta los si­guie­n­tes bloques.

En este caso no se trata de service blocks, por lo que la sangría debe estar a la misma altura que services:.

volumes:
    nextcloud:
    db:
networks:
    nextcloud_network:
  1. Abre el archivo .env vacío para editarlo:
nano ~/nextcloud-docker/.env
  1. Escribe tanto las variables de entorno como los valores del archivo .env:

Copia el siguiente código a la ventana del editor y sustituye los <ma­r­ca­do­res de posición> por los valores deseados antes de guardar.

# MariaDB
MYSQL_ROOT_PASSWORD=toor
MYSQL_PASSWORD=mysql
MYSQL_DATABASE=nextcloud
MYSQL_USER=nextcloud
# Nextcloud
VIRTUAL_HOST=<tu.dominio></tu.dominio>
LETSENCRYPT_HOST=<tu.dominio></tu.dominio>
LETSENCRYPT_EMAIL=<tu@email></tu@email>
  1. Después de guardar, muestra el contenido del archivo .env para comprobar que los valores se han in­tro­du­ci­do co­rre­c­ta­me­n­te:
cat ~/nextcloud-docker/.env

Co­n­fi­gu­ra­ción completa de Nextcloud Server

Antes de pasar a Docker Compose la co­n­fi­gu­ra­ción re­cie­n­te­me­n­te redactada y uti­li­zar­la para crear e iniciar los co­n­te­ne­do­res, comprueba que todo lo necesario está en su sitio.

  1. Accede a la co­n­fi­gu­ra­ción actual:
cat ~/nextcloud-docker/docker-compose.yaml
  1. Compara con la plantilla. La co­n­fi­gu­ra­ción que se obtiene debe coincidir con el siguiente código:
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:

Si tu versión del archivo YAML coincide con la que acabas de leer, puedes proceder al último paso.

Completar la in­s­ta­la­ción Nextcloud Server

Para conseguir que Nextcloud Server se convierta en una apli­ca­ción mu­l­ti­co­n­te­ne­dor a partir de las entradas rea­li­za­das en Docker Compose, debes ejecutar el siguiente comando en la línea de comandos:

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

A co­n­ti­nua­ción, comprueba si los co­n­te­ne­do­res se han iniciado:

docker ps -a

Para ello, la lista de co­n­te­ne­do­res en ejecución que se muestra debe contener los cuatro co­n­te­ne­do­res definidos en el archivo docker-compose.yaml.

Ir al menú principal