Como instalar Nextcloud en Ubuntu o Debian

Como instalar Nextcloud en Ubuntu o Debian con tu propio servidor

Sigue estas instrucciones y crea tu propio servidor de Nextcloud,
basado en Ubuntu 20.04+ / 18.04+ LTS o Debian 10.3+ 64Bit, NGINX 1.17, TLSv1.3, PHP 7.4, MariaDB 10.5, Redis, UFW y fail2ban El sistema recibe una calificación de A+ de Nextcloud, así como de Qualys SSL Labs. Utilizan certificados SSL especialmente creados y renovados automáticamente de Let’s Encrypt. En el curso de esta guía sólo tiene que sustituir los valores marcados en rojo como your.dedyn.io o 192.168.2.x por los valores correspondientes de su sistema.

La historia detallada de la actualización se puede encontrar aquí.

Tabla de contenido

Preparación e instalación del servidor web de nginx
Instalación y configuración de PHP 7.4
Instalación y configuración del servidor de la base de datos MariaDB
Instalación del servidor Redis (“base de datos en memoria”)
Instalación y optimización del Nextcloud (incl. SSL)
Endurecimiento del sistema (fail2ban y ufw)
Optimizar y actualizar el Nextcloud a través de un script

1. preparación e instalación del servidor web de nginx

Primero cambia al modo de usuario privilegiado

sudo -s

y luego instalar los siguientes paquetes de software, que son necesarios como base para el funcionamiento del servidor:

apt install curl gnupg2 git lsb-release ssl-cert ca-certificates apt-transport-https tree locate software-properties-common dirmngr screen htop net-tools zip unzip curl ffmpeg ghostscript libfile-fcntllock-perl -y

Añadir los llamados repositorios de software (fuentes de software) al sistema para poder instalar las versiones actuales de los respectivos paquetes.

cd /etc/apt/sources.list.d

Sólo Ubuntu:

echo “deb [arch=amd64] http://nginx.org/packages/mainline/ubuntu $(lsb_release -cs) nginx” | tee nginx.list

echo “deb [arch=amd64] http://ppa.launchpad.net/ondrej/php/ubuntu $(lsb_release -cs) main” | tee php.list

echo “deb [arch=amd64] http://ftp.hosteurope.de/mirror/mariadb.org/repo/10.5/ubuntu $(lsb_release -cs) main” | tee mariadb.list

Para poder confiar en los respectivos depósitos, usamos las claves apropiadas:

apt-key adv –recv-keys –keyserver hkps://keyserver.ubuntu.com:443 4F4EA0AAE5267A6C

Sólo Debian:

echo “deb [arch=amd64] http://nginx.org/packages/mainline/debian $(lsb_release -cs) nginx” | tee nginx.list

echo “deb [arch=amd64] https://packages.sury.org/php/ $(lsb_release -cs) main” | tee php.list

echo “deb [arch=amd64] http://mirror2.hs-esslingen.de/mariadb/repo/10.5/debian $(lsb_release -cs) main” | tee mariadb.list

Para poder confiar en los respectivos depósitos, usamos las claves apropiadas:

wget -q https://packages.sury.org/php/apt.gpg -O- | apt-key add –

Ubuntu y Debian:

Añadimos más claves (nginx, mariadb), actualizamos el sistema y generamos los llamados certificados autofirmados, que serán reemplazados por certificados completos de Let’s Encrypt.

curl -fsSL https://nginx.org/keys/nginx_signing.key | sudo apt-key add –

apt-key adv –recv-keys –keyserver hkps://keyserver.ubuntu.com:443 0xF1656F24C74CD1D8

apt update && apt upgrade -y

make-ssl-cert generate-default-snakeoil -y

Para asegurarnos de que ninguna reliquia de las instalaciones anteriores interfiera con el funcionamiento del servidor web, las eliminamos:

apt remove nginx nginx-extras nginx-common nginx-full -y –allow-change-held-packages

También nos aseguramos de que la contraparte (Apache2) del servidor web de nginx no esté activa ni instalada.

systemctl stop apache2.service && systemctl disable apache2.service

Ahora los preparativos para la instalación del servidor web están terminados y podemos instalar el software con el siguiente comando

apt install nginx -y

y reiniciar el servicio para el inicio automático después de un servidor usando

systemctl enable nginx.service

Con vistas a ajustes posteriores, se guarda la configuración predeterminada y se abre un nuevo archivo de configuración:

mv /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak && touch /etc/nginx/nginx.conf

vim /etc/nginx/nginx.conf

Copie todo el contenido siguiente en el archivo y reemplace los valores marcados en rojo según su sistema:

user www-data;
worker_processes auto;
pid /var/run/nginx.pid;
events {
worker_connections 1024;
multi_accept on; use epoll;
}
http {
server_names_hash_bucket_size 64;
upstream php-handler {
server unix:/run/php/php7.4-fpm.sock;
}
access_log /var/log/nginx/access.log;
error_log /var/log/nginx/error.log warn;
set_real_ip_from 127.0.0.1;
set_real_ip_from 192.168.2.0/24;
# este es el rango de IP de su red privada/empresarial
real_ip_header X-Forwarded-For;
real_ip_recursive on;
include /etc/nginx/mime.types;
#include /etc/nginx/proxy.conf;
#include /etc/nginx/ssl.conf;
#include /etc/nginx/header.conf;
#include /etc/nginx/optimization.conf;
default_type application/octet-stream;
sendfile on;
send_timeout 3600;
tcp_nopush on;
tcp_nodelay on;
open_file_cache max=500 inactive=10m;
open_file_cache_errors on;
keepalive_timeout 65;
reset_timedout_connection on;
server_tokens off;
resolver 127.0.0.53 valid=30s;
# esta es la IP del servidor DNS local (127.0.0.53) o global (por ejemplo, la IP de su FritzBox 192.168.2.1)
resolver_timeout 5s;
include /etc/nginx/conf.d/*.conf;
}

Guarda el archivo y ciérralo para reiniciar el servidor web:

service nginx restart

Al prepararnos para los certificados SSL y los directorios web, creamos cuatro carpetas y establecemos los permisos correctos:

mkdir -p /var/nc_data /var/www/letsencrypt

chown -R www-data:www-data /var/nc_data /var/www

La instalación del servidor web ya se ha completado y continuamos con la instalación y los ajustes de PHP.

2. Instalación y configuración de PHP 7.4 (fpm)

El repositorio de PHP ya ha sido configurado y activado en el capítulo anterior, así que podemos empezar con la instalación directamente:

apt update && apt install php7.4-fpm php7.4-gd php7.4-mysql php7.4-curl php7.4-xml php7.4-zip php7.4-intl php7.4-mbstring php7.4-json php7.4-bz2 php7.4-ldap php-apcu imagemagick php-imagick php-smbclient ldap-utils -y

Establezca el formato de fecha correcto para permitir un registro correcto:

timedatectl set-timezone Europe/Berlin

Antes de empezar con las optimizaciones de PHP guardamos los archivos de configuración:

cp /etc/php/7.4/fpm/pool.d/www.conf /etc/php/7.4/fpm/pool.d/www.conf.bak
cp /etc/php/7.4/cli/php.ini /etc/php/7.4/cli/php.ini.bak
cp /etc/php/7.4/fpm/php.ini /etc/php/7.4/fpm/php.ini.bak
cp /etc/php/7.4/fpm/php-fpm.conf /etc/php/7.4/fpm/php-fpm.conf.bak
cp /etc/ImageMagick-6/policy.xml /etc/ImageMagick-6/policy.xml.bak

Ahora realice todas las optimizaciones posteriores:

sed -i “s/;env\[HOSTNAME\] = /env[HOSTNAME] = /” /etc/php/7.4/fpm/pool.d/www.conf
sed -i “s/;env\[TMP\] = /env[TMP] = /” /etc/php/7.4/fpm/pool.d/www.conf
sed -i “s/;env\[TMPDIR\] = /env[TMPDIR] = /” /etc/php/7.4/fpm/pool.d/www.conf
sed -i “s/;env\[TEMP\] = /env[TEMP] = /” /etc/php/7.4/fpm/pool.d/www.conf
sed -i “s/;env\[PATH\] = /env[PATH] = /” /etc/php/7.4/fpm/pool.d/www.conf
sed -i “s/pm.max_children =.*/pm.max_children = 120/” /etc/php/7.4/fpm/pool.d/www.conf
sed -i “s/pm.start_servers =.*/pm.start_servers = 12/” /etc/php/7.4/fpm/pool.d/www.conf
sed -i “s/pm.min_spare_servers =.*/pm.min_spare_servers = 6/” /etc/php/7.4/fpm/pool.d/www.conf
sed -i “s/pm.max_spare_servers =.*/pm.max_spare_servers = 18/” /etc/php/7.4/fpm/pool.d/www.conf
sed -i “s/;pm.max_requests =.*/pm.max_requests = 1000/” /etc/php/7.4/fpm/pool.d/www.conf

sed -i “s/output_buffering =.*/output_buffering = ‘Off’/” /etc/php/7.4/cli/php.ini
sed -i “s/max_execution_time =.*/max_execution_time = 3600/” /etc/php/7.4/cli/php.ini
sed -i “s/max_input_time =.*/max_input_time = 3600/” /etc/php/7.4/cli/php.ini
sed -i “s/post_max_size =.*/post_max_size = 10240M/” /etc/php/7.4/cli/php.ini
sed -i “s/upload_max_filesize =.*/upload_max_filesize = 10240M/” /etc/php/7.4/cli/php.ini
sed -i “s/;date.timezone.*/date.timezone = Europe\/\Berlin/” /etc/php/7.4/cli/php.ini

sed -i “s/memory_limit = 128M/memory_limit = 512M/” /etc/php/7.4/fpm/php.ini
sed -i “s/output_buffering =.*/output_buffering = ‘Off’/” /etc/php/7.4/fpm/php.ini
sed -i “s/max_execution_time =.*/max_execution_time = 3600/” /etc/php/7.4/fpm/php.ini
sed -i “s/max_input_time =.*/max_input_time = 3600/” /etc/php/7.4/fpm/php.ini
sed -i “s/post_max_size =.*/post_max_size = 10240M/” /etc/php/7.4/fpm/php.ini
sed -i “s/upload_max_filesize =.*/upload_max_filesize = 10240M/” /etc/php/7.4/fpm/php.ini
sed -i “s/;date.timezone.*/date.timezone = Europe\/\Berlin/” /etc/php/7.4/fpm/php.ini
sed -i “s/;session.cookie_secure.*/session.cookie_secure = True/” /etc/php/7.4/fpm/php.ini
sed -i “s/;opcache.enable=.*/opcache.enable=1/” /etc/php/7.4/fpm/php.ini
sed -i “s/;opcache.enable_cli=.*/opcache.enable_cli=1/” /etc/php/7.4/fpm/php.ini
sed -i “s/;opcache.memory_consumption=.*/opcache.memory_consumption=128/” /etc/php/7.4/fpm/php.ini
sed -i “s/;opcache.interned_strings_buffer=.*/opcache.interned_strings_buffer=8/” /etc/php/7.4/fpm/php.ini
sed -i “s/;opcache.max_accelerated_files=.*/opcache.max_accelerated_files=10000/” /etc/php/7.4/fpm/php.ini
sed -i “s/;opcache.revalidate_freq=.*/opcache.revalidate_freq=1/” /etc/php/7.4/fpm/php.ini
sed -i “s/;opcache.save_comments=.*/opcache.save_comments=1/” /etc/php/7.4/fpm/php.ini

sed -i ‘$aapc.enable_cli=1’ /etc/php/7.4/mods-available/apcu.ini

sed -i “s/rights=\”none\” pattern=\”PS\”/rights=\”read|write\” pattern=\”PS\”/” /etc/ImageMagick-6/policy.xml
sed -i “s/rights=\”none\” pattern=\”EPI\”/rights=\”read|write\” pattern=\”EPI\”/” /etc/ImageMagick-6/policy.xml
sed -i “s/rights=\”none\” pattern=\”PDF\”/rights=\”read|write\” pattern=\”PDF\”/” /etc/ImageMagick-6/policy.xml
sed -i “s/rights=\”none\” pattern=\”XPS\”/rights=\”read|write\” pattern=\”XPS\”/” /etc/ImageMagick-6/policy.xml

Ahora reinicie ambos servicios, nginx y PHP:

service php7.4-fpm restart
service nginx restart

PHP ya está instalado y optimizado para Nextcloud. Para más optimizaciones de PHP encontrarás más opciones de ajuste en este artículo. Ahora vamos a empezar con la instalación y configuración del servidor de la base de datos MariaDB.

3. Instalación y configuración de MariaDB 10.x

La instalación de MariaDB se hace con este comando:

apt update && apt install mariadb-server -y

Ahora vamos a endurecer el servidor de la base de datos usando la herramienta incluida “mysql_secure_installation”. Para una primera instalación no hay contraseña de root, por lo que puede confirmar la solicitud con ENTER. Se recomienda establecer una contraseña directamente, el diálogo correspondiente aparece automáticamente:

mysql_secure_installation

Switch to unix_socket authentication [Y/n] N
Enter current password for root (enter for none): <ENTER> or type the password
Set root password? [Y/n] Y

Remove anonymous users? [Y/n] Y
Disallow root login remotely? [Y/n] Y
Remove test database and access to it? [Y/n] Y
Reload privilege tables now? [Y/n] Y

Ahora detenga el servidor de la base de datos y guarde la configuración por defecto para poder hacer ajustes inmediatamente después:

service mysql stop
mv /etc/mysql/my.cnf /etc/mysql/my.cnf.bak
vim /etc/mysql/my.cnf

Copie todas las líneas subsiguientes en el archivo vacío:

[client]
default-character-set = utf8mb4
port = 3306
socket = /var/run/mysqld/mysqld.sock
[mysqld_safe]
log_error=/var/log/mysql/mysql_error.log
nice = 0
socket = /var/run/mysqld/mysqld.sock
[mysqld]
basedir = /usr
bind-address = 127.0.0.1
binlog_format = ROW
bulk_insert_buffer_size = 16M
character-set-server = utf8mb4
collation-server = utf8mb4_general_ci
concurrent_insert = 2
connect_timeout = 5
datadir = /var/lib/mysql
default_storage_engine = InnoDB
expire_logs_days = 2
general_log_file = /var/log/mysql/mysql.log
general_log = 0
innodb_buffer_pool_size = 1024M
innodb_buffer_pool_instances = 1
innodb_flush_log_at_trx_commit = 2
innodb_log_buffer_size = 32M
innodb_max_dirty_pages_pct = 90
innodb_file_per_table = 1
innodb_open_files = 400
innodb_io_capacity = 4000
innodb_flush_method = O_DIRECT
key_buffer_size = 128M
lc_messages_dir = /usr/share/mysql
lc_messages = en_US
log_bin = /var/log/mysql/mariadb-bin
log_bin_index = /var/log/mysql/mariadb-bin.index
log_error = /var/log/mysql/mysql_error.log
log_slow_verbosity = query_plan
log_warnings = 2
long_query_time = 1
max_allowed_packet = 16M
max_binlog_size = 100M
max_connections = 200
max_heap_table_size = 64M
myisam_recover_options = BACKUP
myisam_sort_buffer_size = 512M
port = 3306
pid-file = /var/run/mysqld/mysqld.pid
query_cache_limit = 2M
query_cache_size = 64M
query_cache_type = 1
query_cache_min_res_unit = 2k
read_buffer_size = 2M
read_rnd_buffer_size = 1M
skip-external-locking
skip-name-resolve
slow_query_log_file = /var/log/mysql/mariadb-slow.log
slow-query-log = 1
socket = /var/run/mysqld/mysqld.sock
sort_buffer_size = 4M
table_open_cache = 400
thread_cache_size = 128
tmp_table_size = 64M
tmpdir = /tmp
transaction_isolation = READ-COMMITTED
#unix_socket=OFF
user = mysql
wait_timeout = 600
[mysqldump]
max_allowed_packet = 16M
quick
quote-names
[isamchk]
key_buffer = 16M

Guarda y cierra el archivo, luego reinicia el servidor de la base de datos para configurar la base de datos de Nextcloud, el usuario de Nextcloud y su contraseña:

service mysql restart
mysql -uroot -p

Explicación:

Nombre de la base de datos: nextcloud

Usuario de la base de datos: nextcloud

Contraseña de usuario de la base de datos: nextcloud

CREATE DATABASE nextcloud CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci; CREATE USER nextcloud@localhost identified by ‘nextcloud‘; GRANT ALL PRIVILEGES on nextcloud.* to nextcloud@localhost; FLUSH privileges; quit;

Comprueba si el nivel de aislamiento (read commit) y el juego de caracteres (utf8mb4) están ajustados correctamente:

mysql -h localhost -uroot -p -e “SELECT @@TX_ISOLATION; SELECT SCHEMA_NAME ‘database’, default_character_set_name ‘charset’, DEFAULT_COLLATION_NAME ‘collation’ FROM information_schema.SCHEMATA WHERE SCHEMA_NAME=’nextcloud'”

Si la salida (resultset) “READ-COMMITTED” y “utf8mb4_general_ci” aparece, todo ha sido configurado correctamente y podemos continuar con la instalación de Redis.

4. Instalación y configuración de Redis

Estamos instalando el servidor de Redis para aumentar el rendimiento de Nextcloud, ya que Redis reduce la carga de la base de datos de Nextcloud de MariaDB:

apt update && apt install redis-server php-redis -y

Ajuste la configuración del disco rojo guardando y ajustando la configuración ejecutando los siguientes comandos:

cp /etc/redis/redis.conf /etc/redis/redis.conf.bak
sed -i “s/port 6379/port 0/” /etc/redis/redis.conf
sed -i s/\#\ unixsocket/\unixsocket/g /etc/redis/redis.conf
sed -i “s/unixsocketperm 700/unixsocketperm 770/” /etc/redis/redis.conf
sed -i “s/# maxclients 10000/maxclients 512/” /etc/redis/redis.conf
usermod -aG redis www-data

cp /etc/sysctl.conf /etc/sysctl.conf.bak
sed -i ‘$avm.overcommit_memory = 1’ /etc/sysctl.conf

Con suficiente experiencia en la instalación recomiendo reiniciar todo el servidor una vez:

reboot now

Felicitaciones, el servidor ya está instalado y configurado, para que la próxima nube pueda ser configurada.

5. Instalación y optimización del Nextcloud (incl. SSL)

Ahora configuramos varios vhost, es decir, archivos de configuración del servidor, y modificamos el archivo vhost estándar de forma persistente. Desde que el sistema se ha reiniciado, volvemos al modo de usuario privilegiado, guardamos el archivo vhost estándar llamado default.conf y creamos un archivo vacío.

sudo -s
[ -f /etc/nginx/conf.d/default.conf ] && mv /etc/nginx/conf.d/default.conf /etc/nginx/conf.d/default.conf.bak
touch /etc/nginx/conf.d/default.conf

Esto asegura que esta configuración predeterminada no afecta a la operación de Nextcloud, incluso si el servidor web nginx se actualiza más tarde. Vamos a crear el archivo vhost para Nextcloud:

vim /etc/nginx/conf.d/nextcloud.conf

Copie todas las siguientes líneas en el archivo nextcloud.conf y ajuste los valores marcados en rojo de acuerdo con su sistema:

server {
server_name your.dedyn.io;
# your.dedyn.io ist mit ihre Domain zu ersetzen
listen 80 default_server;
listen [::]:80 default_server;
location ^~ /.well-known/acme-challenge {
proxy_pass http://127.0.0.1:81;
proxy_set_header Host $host;
}
location / {
return 301 https://$host$request_uri;
}
}
server {
server_name your.dedyn.io;
# your.dedyn.io ist mit ihre Domain zu ersetzen
listen 443 ssl http2 default_server;
listen [::]:443 ssl http2 default_server;
root /var/www/nextcloud/;
location = /robots.txt {
allow all;
log_not_found off;
access_log off;
}
location = /.well-known/carddav {
return 301 $scheme://$host/remote.php/dav;
}
location = /.well-known/caldav {
return 301 $scheme://$host/remote.php/dav;
}
#SOCIAL app enabled? Please uncomment the following row
#rewrite ^/.well-known/webfinger /public.php?service=webfinger last;
#WEBFINGER app enabled? Please uncomment the following two rows.
#rewrite ^/.well-known/host-meta /public.php?service=host-meta last;
#rewrite ^/.well-known/host-meta.json /public.php?service=host-meta-json last;
client_max_body_size 10240M;
location / {
rewrite ^ /index.php;
}
location ~ ^/(?:build|tests|config|lib|3rdparty|templates|data)/ {
deny all;
}
location ~ ^/(?:\.|autotest|occ|issue|indie|db_|console) {
deny all;
}
location ^~ /apps/rainloop/app/data {
deny all;
}
location ~ \.(?:flv|mp4|mov|m4a)$ {
mp4;
mp4_buffer_size 100M;
mp4_max_buffer_size 1024M;
fastcgi_split_path_info ^(.+?.php)(\/.*|)$;
set $path_info $fastcgi_path_info;
try_files $fastcgi_script_name =404;
include fastcgi_params;
include php_optimization.conf;
}
location ~ ^\/(?:index|remote|public|cron|core\/ajax\/update|status|ocs\/v[12]|updater\/.+|oc[ms]-provider\/.+).php(?:$|\/) {
fastcgi_split_path_info ^(.+?.php)(\/.*|)$;
set $path_info $fastcgi_path_info;
try_files $fastcgi_script_name =404;
include fastcgi_params;
include php_optimization.conf;
}
location ~ ^\/(?:updater|oc[ms]-provider)(?:$|\/) {
try_files $uri/ =404;
index index.php;
}
location ~ \.(?:css|js|woff2?|svg|gif|map|png|html|ttf|ico|jpg|jpeg)$ {
try_files $uri /index.php$request_uri;
access_log off;
expires 360d;
}
}

Guarda y cierra este archivo y luego crea el archivo adicional vhost letsencrypt.conf

vim /etc/nginx/conf.d/letsencrypt.conf

Copia todas las líneas en el archivo:

server
{
server_name 127.0.0.1;
listen 127.0.0.1:81 default_server;
charset utf-8;
location ^~ /.well-known/acme-challenge
{
default_type text/plain;
root /var/www/letsencrypt;
}
}

Guarda y cierra este archivo y luego crea el archivo adicional de vhost ssl.conf:

vim /etc/nginx/ssl.conf

Copia todas las líneas en el archivo:

ssl_certificate /etc/ssl/certs/ssl-cert-snakeoil.pem;
ssl_certificate_key /etc/ssl/private/ssl-cert-snakeoil.key;
ssl_trusted_certificate /etc/ssl/certs/ssl-cert-snakeoil.pem;
#ssl_certificate /etc/letsencrypt/rsa-certs/fullchain.pem;
#ssl_certificate_key /etc/letsencrypt/rsa-certs/privkey.pem;
#ssl_certificate /etc/letsencrypt/ecc-certs/fullchain.pem;
#ssl_certificate_key /etc/letsencrypt/ecc-certs/privkey.pem;
#ssl_trusted_certificate /etc/letsencrypt/ecc-certs/chain.pem;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:SSL:50m;
ssl_session_tickets off;
ssl_protocols TLSv1.3 TLSv1.2;
ssl_ciphers ‘TLS-CHACHA20-POLY1305-SHA256:TLS-AES-256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES256-GCM-SHA384’;
ssl_ecdh_curve X448:secp521r1:secp384r1:prime256v1;
ssl_prefer_server_ciphers on;
ssl_stapling on;
ssl_stapling_verify on;

Guarda y cierra este archivo y luego crea el archivo adicional vhost proxy.conf:

vim /etc/nginx/proxy.conf

Copia todas las líneas en el archivo:

proxy_set_header Cache-Control “public, max-age=15778463”;
proxy_set_header Host $host;
proxy_set_header Referrer-Policy no-referrer;
proxy_set_header Strict-Transport-Security “max-age=63072000; includeSubdomains; preload;”;
proxy_set_header X-Content-Type-Options nosniff;
proxy_set_header X-Download-Options noopen;
proxy_set_header X-Forwarded-Host $host;
proxy_set_header X-Forwarded-Protocol $scheme;
proxy_set_header X-Forwarded-For $remote_addr;
proxy_set_header X-Forwarded-Port $server_port;
proxy_set_header X-Forwarded-Server $host;
proxy_set_header X-Permitted-Cross-Domain-Policies none;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Robots-Tag none;
proxy_set_header X-XSS-Protection “1; mode=block”;
proxy_connect_timeout 3600;
proxy_send_timeout 3600;
proxy_read_timeout 3600;
proxy_redirect off;

Guarda y cierra este archivo y luego crea el archivo adicional vhost header.conf:

vim /etc/nginx/header.conf

Copia todas las líneas en el archivo:

add_header Strict-Transport-Security “max-age=15768000; includeSubDomains; preload;”;
add_header X-Robots-Tag none always;
add_header X-Download-Options noopen always;
add_header X-Permitted-Cross-Domain-Policies none always;
add_header X-Content-Type-Options “nosniff” always;
add_header X-XSS-Protection “1; mode=block” always;
add_header Referrer-Policy “no-referrer” always;
add_header X-Frame-Options “SAMEORIGIN” always;

Guarda y cierra este archivo y luego crea el archivo adicional vhost optimization.conf:

vim /etc/nginx/optimization.conf

Copia todas las líneas en el archivo:

fastcgi_hide_header X-Powered-By;
fastcgi_read_timeout 3600;
fastcgi_send_timeout 3600;
fastcgi_connect_timeout 3600;
fastcgi_buffers 64 64K;
fastcgi_buffer_size 256k;
fastcgi_busy_buffers_size 3840K;
fastcgi_cache_key $http_cookie$request_method$host$request_uri;
fastcgi_cache_use_stale error timeout invalid_header http_500;
fastcgi_ignore_headers Cache-Control Expires Set-Cookie;
gzip on;
gzip_vary on;
gzip_comp_level 4;
gzip_min_length 256;
gzip_proxied expired no-cache no-store private no_last_modified no_etag auth;
gzip_types application/atom+xml application/javascript application/json application/ld+json application/manifest+json application/rss+xml application/vnd.geo+json application/vnd.ms-fontobject application/x-font-ttf application/x-web-app-manifest+json application/xhtml+xml application/xml font/opentype image/bmp image/svg+xml image/x-icon text/cache-manifest text/css text/plain text/vcard text/vnd.rim.location.xloc text/vtt text/x-component text/x-cross-domain-policy;
gzip_disable “MSIE [1-6]\.”;

Guarda y cierra este archivo y luego crea el archivo vhost adicional php_optimization.conf:

vim /etc/nginx/php_optimization.conf

Copia todas las líneas en el archivo:

fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param PATH_INFO $path_info;
fastcgi_param HTTPS on;
fastcgi_param modHeadersAvailable true;
fastcgi_param front_controller_active true;
fastcgi_pass php-handler;
fastcgi_intercept_errors on;
fastcgi_request_buffering off;
fastcgi_cache_valid 404 1m;
fastcgi_cache_valid any 1h;
fastcgi_cache_methods GET HEAD;

Guarda y cierra este archivo. Ahora amplíe la seguridad del servidor y del sistema permitiendo el intercambio seguro de claves mediante una clave Diffie-Hellman (dhparam.pem):

openssl dhparam -out /etc/ssl/certs/dhparam.pem 4096

Por favor, ten paciencia, la generación puede tardar de unos minutos a una hora dependiendo del rendimiento del sistema. Tan pronto como la generación termine, activaremos el SSL en el servidor web de nginx y lo reiniciaremos:

sed -i s/\#\include/\include/g /etc/nginx/nginx.conf
service nginx restart

Ahora comenzamos la instalación del software Nextcloud y configuramos los certificados SSL de Let’s Encrypt usando acme. Cambiar al directorio de trabajo

cd /usr/local/src

y descargar la actual versión de Nextcloud

wget https://download.nextcloud.com/server/releases/latest.tar.bz2

Descomprime el software de Nextcloud en el directorio web, luego configura los permisos apropiadamente y borra la descarga:

tar -xjf latest.tar.bz2 -C /var/www && chown -R www-data:www-data /var/www/ && rm -f latest.tar.bz2

Por favor, asegúrese de que su servidor es accesible desde el exterior a través del puerto 80/TCP, así como a través del puerto 443/TCP. Para el manejo del certificado ahora creamos un usuario dedicado y lo agregamos al grupo de datos www-data:

adduser acmeuser
usermod -a -G www-data acmeuser

Cambie al shell del nuevo usuario (acmeuser) para instalar el software del certificado y deje este shell después:

su – acmeuser
curl https://get.acme.sh | sh
exit

Crear tres directorios con los permisos apropiados para almacenar los nuevos certificados:

mkdir -p /var/www/letsencrypt/.well-known/acme-challenge /etc/letsencrypt/rsa-certs /etc/letsencrypt/ecc-certs
chmod -R 775 /var/www/letsencrypt /etc/letsencrypt && chown -R www-data:www-data /var/www/ /etc/letsencrypt

Cambiar a la cáscara del nuevo usuario de nuevo

su – acmeuser

y solicitar (solicitar) los certificados SSL. Sustituye tu .dedyn.io por tu dominio :

acme.sh –issue -d your.dedyn.io –keylength 4096 -w /var/www/letsencrypt –key-file /etc/letsencrypt/rsa-certs/privkey.pem –ca-file /etc/letsencrypt/rsa-certs/chain.pem –cert-file /etc/letsencrypt/rsa-certs/cert.pem –fullchain-file /etc/letsencrypt/rsa-certs/fullchain.pem

acme.sh –issue -d your.dedyn.io –keylength ec-384 -w /var/www/letsencrypt –key-file /etc/letsencrypt/ecc-certs/privkey.pem –ca-file /etc/letsencrypt/ecc-certs/chain.pem –cert-file /etc/letsencrypt/ecc-certs/cert.pem –fullchain-file /etc/letsencrypt/ecc-certs/fullchain.pem

Dejar la cáscara del nuevo usuario

exit

y luego crear un guión que compruebe y corrija los permisos en el futuro (permissions.sh)

vim /root/permissions.sh

Copia todas las líneas en el archivo:

#!/bin/bash
find /var/www/ -type f -print0 | xargs -0 chmod 0640
find /var/www/ -type d -print0 | xargs -0 chmod 0750
chmod -R 775 /var/www/letsencrypt /etc/letsencrypt
chown -R www-data:www-data /var/www /etc/letsencrypt
chown -R www-data:www-data /var/nc_data
chmod 0644 /var/www/nextcloud/.htaccess
chmod 0644 /var/www/nextcloud/.user.ini
exit 0

Marque el guión como ejecutable y luego ejecútelo directamente:

chmod +x /root/permissions.sh
/root/permissions.sh

Elimina tus certificados autofirmados usados anteriormente en nginx y activa los nuevos certificados SSL, completamente funcionales y ya válidos, en Let’s Encrypt:

sed -i ‘/ssl-cert-snakeoil/d’ /etc/nginx/ssl.conf
sed -i s/\#\ssl/\ssl/g /etc/nginx/ssl.conf
service nginx restart

Para renovar automáticamente los certificados SSL e iniciar el reinicio del servidor web necesario, creamos el siguiente script de “renovación”:

vim /root/renewal.sh

#!/bin/bash
sudo -u acmeuser “/home/acmeuser/.acme.sh”/acme.sh –cron –home “/home/acmeuser/.acme.sh”
/usr/sbin/service nginx stop
/usr/sbin/service mysql restart
/usr/sbin/service redis-server restart
/usr/sbin/service php7.4-fpm restart
/usr/sbin/service nginx restart
exit 0

Guarda este guión y márcalo como “ejecutable”.

chmod +x /root/renewal.sh

Ahora deshabilitamos el trabajo por defecto de ‘acme’ cronjob

crontab -e -u acmeuser

precediéndolo con un carácter de ‘#’.

# 44 0 * * * “/home/acmeuser/.acme.sh”/acme.sh –cron –home “/home/acmeuser/.acme.sh” > /dev/null

y luego crear un nuevo trabajo de cronómetro

crontab -e

@weekly /root/renewal.sh 2>&1

A partir de ahora, el sistema buscará semanalmente los certificados SSL renovables y en caso de una posible renovación del certificado, los certificados SSL se actualizarán y el servidor web se reiniciará – ¡de forma totalmente automática!

Ahora podemos proceder con la configuración de la Próxima Nube. Para ello, utilice el siguiente comando de instalación “silenciosa”:

sudo -u www-data php /var/www/nextcloud/occ maintenance:install –database “mysql” –database-name “nextcloud” –database-user “nextcloud” –database-pass “nextcloud” –admin-user “YourNextcloudAdmin” –admin-pass “YourNextcloudAdminPasssword” –data-dir “/var/nc_data”

Explicaciones:

nombre de la base de datos “nextcloud” : nombre de la base de datos del capítulo 3

usuario de la base de datos “nextcloud” : usuarios de la base de datos del capítulo 3

paso de base de datos “nextcloud” : contraseña de usuario de la base de datos del capítulo 3

admin-user “YourNextcloudAdmin” : libremente seleccionable por usted

admin-pass “YourNextcloudAdminPasssword” : libremente seleccionable por usted

Espere hasta que la instalación del Nextcloud se complete y luego ajuste el archivo de configuración central del Nextcloud “config.php” como usuario web www-data:

1. Añade tu dominio como dominio de confianza, añadiendo tu.dedyn.io con tu dominio dedicado:

sudo -u www-data php /var/www/nextcloud/occ config:system:set trusted_domains 0 –value=your.dedyn.io

2. Establece tu dominio como overwrite.cli.url, agregando tu.dedyn.io con tu dominio dedicado:

sudo -u www-data php /var/www/nextcloud/occ config:system:set overwrite.cli.url –value=https://your.dedyn.io

Ahora finalmente estamos expandiendo la configuración de Nextcloud. Primero guarda el config.php existente y luego ejecuta las siguientes líneas en un bloque:

sudo -u www-data cp /var/www/nextcloud/config/config.php /var/www/nextcloud/config/config.php.bak

sudo -u www-data sed -i ‘s/^[ ]*//’ /var/www/nextcloud/config/config.php

sudo -u www-data sed -i ‘/);/d’ /var/www/nextcloud/config/config.php

sudo -u www-data cat <<EOF >>/var/www/nextcloud/config/config.php
‘activity_expire_days’ => 14,
‘auth.bruteforce.protection.enabled’ => true,
‘blacklisted_files’ =>
array (
0 => ‘.htaccess’,
1 => ‘Thumbs.db’,
2 => ‘thumbs.db’,
),
‘cron_log’ => true,
‘enable_previews’ => true,
‘enabledPreviewProviders’ =>
array (
0 => ‘OC\Preview\PNG’,
1 => ‘OC\Preview\JPEG’,
2 => ‘OC\Preview\GIF’,
3 => ‘OC\Preview\BMP’,
4 => ‘OC\Preview\XBitmap’,
5 => ‘OC\Preview\Movie’,
6 => ‘OC\Preview\PDF’,
7 => ‘OC\Preview\MP3’,
8 => ‘OC\Preview\TXT’,
9 => ‘OC\Preview\MarkDown’,
),
‘filesystem_check_changes’ => 0,
‘filelocking.enabled’ => ‘true’,
‘htaccess.RewriteBase’ => ‘/’,
‘integrity.check.disabled’ => false,
‘knowledgebaseenabled’ => false,
‘logfile’ => ‘/var/nc_data/nextcloud.log’,
‘loglevel’ => 2,
‘logtimezone’ => ‘Europe/Berlin’,
‘log_rotate_size’ => 104857600,
‘maintenance’ => false,
‘memcache.local’ => ‘\OC\Memcache\APCu’,
‘memcache.locking’ => ‘\OC\Memcache\Redis’,
‘overwriteprotocol’ => ‘https’,
‘preview_max_x’ => 1024,
‘preview_max_y’ => 768,
‘preview_max_scale_factor’ => 1,
‘redis’ =>
array (
‘host’ => ‘/var/run/redis/redis-server.sock’,
‘port’ => 0,
‘timeout’ => 0.0,
),
‘quota_include_external_storage’ => false,
‘share_folder’ => ‘/Shares’,
‘skeletondirectory’ => ”,
‘theme’ => ”,
‘trashbin_retention_obligation’ => ‘auto, 7’,
‘updater.release.channel’ => ‘stable’,
);
EOF

sudo -u www-data sed -i “s/.*dbhost.*/\’dbhost\’ \=\>\ \’localhost\:\/var\/run\/mysqld\/mysqld\.sock\’\,/g” /var/www/nextcloud/config/config.php

Modificar el “.user.ini”

sudo -u www-data sed -i “s/output_buffering=.*/output_buffering=’Off’/” /var/www/nextcloud/.user.ini

y pasar los Nextcloud-Apps como usuario www-data

sudo -u www-data php /var/www/nextcloud/occ app:disable survey_client

sudo -u www-data php /var/www/nextcloud/occ app:disable firstrunwizard

sudo -u www-data php /var/www/nextcloud/occ app:enable admin_audit

sudo -u www-data php /var/www/nextcloud/occ app:enable files_pdfviewer

Nextcloud está ahora completamente operativa, optimizada y asegurada. Reinicie todos los servicios pertinentes:

service nginx stop
service php7.4-fpm stop
service mysql restart
service php7.4-fpm restart
service redis-server restart
service nginx restart

Prepara un trabajo de cronista para Nextcloud como usuario de “www-data”:

crontab -u www-data -e

Inserte esta línea

*/5 * * * * php -f /var/www/nextcloud/cron.php > /dev/null 2>&1

Luego guarda y cierra el archivo y reconfigura el trabajo de Nextcloud de “Ajax” a “Cron” usando el CLI de Nextclouds:

sudo -u www-data php /var/www/nextcloud/occ background:cron

6. endurecimiento (fail2ban y ufw)

Primero instalamos fail2ban para proteger el servidor contra ataques de fuerza bruta e intentos de acceso incorrectos:

apt update && apt install fail2ban -y

Cree un nuevo archivo de filtro y rellénelo como se describe a continuación (alternativa: descargar)

touch /etc/fail2ban/filter.d/nextcloud.conf

Copia todo desde “cat …” a “… EOF” a tu portapapeles y luego pégalo en la cáscara:

cat <<EOF >/etc/fail2ban/filter.d/nextcloud.conf
[Definition]
failregex=^{“reqId”:”.*”,”remoteAddr”:”.*”,”app”:”core”,”message”:”Login failed: ‘.*’ \(Remote IP: ‘<HOST>’\)”,”level”:2,”time”:”.*”}$
^{“reqId”:”.*”,”level”:2,”time”:”.*”,”remoteAddr”:”.*”,”user,:”.*”,”app”:”no app in context”.*”,”method”:”.*”,”message”:”Login failed: ‘.*’ \(Remote IP: ‘<HOST>’\)”.*}$
^{“reqId”:”.*”,”level”:2,”time”:”.*”,”remoteAddr”:”.*”,”user”:”.*”,”app”:”.*”,”method”:”.*”,”url”:”.*”,”message”:”Login failed: .* \(Remote IP: <HOST>\).*}$
EOF

Confirme con <Entrar> para llenar el archivo. El resultado es el siguiente:

cat /etc/fail2ban/filter.d/nextcloud.conf

como instalar nextcloud en

Ahora crea un nuevo archivo de la cárcel (descárgalo aquí):

vim /etc/fail2ban/jail.d/nextcloud.local

Copia todas las líneas subsiguientes en él:

[nextcloud]
backend = auto
enabled = true
port = 80,443
protocol = tcp
filter = nextcloud
maxretry = 10
bantime = 3600
findtime = 36000
logpath = /var/nc_data/nextcloud.log

Con los parámetros mostrados arriba, después de 10 intentos fallidos de acceso (maxretry) dentro de los últimos 36000 segundos (findtime, corresponde a 10h) la IP del atacante potencial se bloquea por un período de 3600 segundos (mientras tanto, corresponde a 1h).

Reinicie fail2ban y compruebe el estado de fail2ban:

service fail2ban restart

fail2ban-client status nextcloud

A partir de ahora, las direcciones IP que hayan tenido más de 10 intentos de acceso fallidos serán bloqueadas por 36000s, protegiendo su servidor de más ataques.

Por último, instalaremos un cortafuegos, el llamado cortafuegos sin complicaciones (ufw):

Si has cambiado el puerto SSH de 22 a otro puerto antes, tienes que reemplazar el 22 en consecuencia!

apt install ufw -y

ufw allow 80/tcp

ufw allow 443/tcp

ufw allow 22/tcp

Ponga el registro del cortafuegos en “medio” y evite las conexiones entrantes indefinidas.

ufw logging medium

ufw default deny incoming

Activar el cortafuegos y reiniciarlo:

ufw enable

service ufw restart

7. Optimizar y actualizar el Nextcloud a través de un script

Crear un guión para actualizar y optimizar el Nextcloud y las aplicaciones activadas:

cd /root

vim upgrade.sh

#!/bin/bash
/usr/sbin/service nginx stop
sudo -u www-data php /var/www/nextcloud/updater/updater.phar
sudo -u www-data php /var/www/nextcloud/occ status
sudo -u www-data php /var/www/nextcloud/occ -V
sudo -u www-data php /var/www/nextcloud/occ db:add-missing-indices
sudo -u www-data php /var/www/nextcloud/occ db:convert-filecache-bigint
sed -i “s/output_buffering=.*/output_buffering=’Off’/” /var/www/nextcloud/.user.ini
chown -R www-data:www-data /var/www/nextcloud
redis-cli -s /var/run/redis/redis-server.sock <<EOF
FLUSHALL
quit
EOF
sudo -u www-data php /var/www/nextcloud/occ files:scan –all
sudo -u www-data php /var/www/nextcloud/occ files:scan-app-data
sudo -u www-data php /var/www/nextcloud/occ update:check
sudo -u www-data php /var/www/nextcloud/occ app:update –all
/usr/sbin/service php7.4-fpm restart
/usr/sbin/service nginx restart
exit 0

Marque el guión como ejecutable y ejecútelo regularmente como un usuario privilegiado.

chmod +x /root/upgrade.sh

/root/upgrade.sh

La instalación y protección de su Nextcloudserver se completó con éxito y por eso le deseo mucha diversión con sus datos en su nube privada.

Para la compra de hosting, dominio, o renta de un vps puede visitarnos en https://easyvhost.com

Si quieres probar un servidor construido siguiendo estas misma construciones, puedes registrarte en https://ecv.consultasinformaticas.com

Que es Nextcloud y como instalarlo en un VPS

Que es Nextcloud y como instalarlo en un VPS?

Nextcloud es un paquete de software cliente-servidor para crear y utilizar servicios de alojamiento de archivos. Nextcloud es libre y de código abierto, lo que significa que cualquiera puede instalarlo y operarlo en sus propios dispositivos de servidor privado.

La aplicación Nextcloud es funcionalmente similar a Dropbox, Office 365 o Google Drive, pero se puede utilizar en ordenadores locales o para el alojamiento de almacenamiento de archivos fuera de las instalaciones. La funcionalidad de Office está limitada a servidores basados en x86/x64 ya que OnlyOffice no soporta procesadores ARM. A diferencia de los servicios propietarios, la arquitectura abierta permite a los usuarios tener un control total de sus datos.

Características

Los archivos de Nextcloud se almacenan en estructuras de directorios convencionales, accesibles a través de WebDAV si es necesario. Los archivos de usuario se cifran durante el tránsito y opcionalmente en reposo. Nextcloud puede sincronizarse con clientes locales que ejecuten Windows (Windows XP, Vista, 7, 8 y 10), MacOS (10.6 o posterior), o varias distribuciones de Linux.

Nextcloud permite la administración de usuarios y grupos (a través de OpenID o LDAP). El contenido puede ser compartido definiendo permisos de lectura/escritura granulares entre usuarios y grupos. Alternativamente, los usuarios de Nextcloud pueden crear URLs públicas al compartir archivos. El registro de las acciones relacionadas con los archivos, así como el rechazo de acceso basado en las reglas de acceso a los archivos también está disponible.[8]

Nextcloud ha planeado nuevas características como capacidades de monitoreo, búsqueda de texto completo y autenticación Kerberos, así como conferencias de audio/video, federación ampliada y mejoras más pequeñas en la interfaz de usuario.[9]

Dado que el software es modular, puede ser ampliado con plugins para implementar funcionalidad extra. Los desarrolladores pueden ofrecer sus extensiones a otros usuarios para su instalación a través de una plataforma operada por el fabricante. Esta plataforma se comunica con las instancias de Nextcloud a través de un protocolo abierto. La App Store[10] contiene más de 200 extensiones. Con la ayuda de estas extensiones, se pueden añadir muchas funcionalidades, entre ellas:

calendarios (CalDAV)
contactos (CardDAV)
medios de transmisión (Ampache)
editor de texto basado en el navegador
servicio de marcadores
Suite de acortamiento de URL
galería
Lector de feeds RSS
herramientas de visualización de documentos desde dentro de Nextcloud
conexión a Dropbox, Google Drive y Amazon S3
Analítica web (Uso de Matomo (software))
Integración de sistemas de gestión de contenidos, por ejemplo, Pico CMS
Visor para el pronóstico del tiempo
Visor para DICOM
Visor de Mapas

Arquitectura

Para que las máquinas de escritorio puedan sincronizar archivos con su servidor Nextcloud, los clientes de escritorio están disponibles para PCs con Windows, macOS, FreeBSD o Linux. Los clientes móviles existen para dispositivos iOS y Android. Los archivos y otros datos (como calendarios, contactos o marcadores) también pueden ser accedidos, administrados y cargados usando un navegador web sin ningún software adicional. Cualquier actualización del sistema de archivos se envía a todas las computadoras y dispositivos móviles conectados a la cuenta del usuario.

El servidor de Nextcloud está escrito en los lenguajes de scripts PHP y JavaScript. Para el acceso remoto, emplea sabre/dav, un servidor WebDAV de código abierto.[11] Nextcloud está diseñado para trabajar con varios sistemas de gestión de bases de datos, incluyendo SQLite, MariaDB, MySQL, Oracle Database, y PostgreSQL.[12]

Con Nextcloud 12, se desarrolló una nueva arquitectura con el nombre de Global Scale, con el objetivo de escalar a cientos de millones de usuarios. Divide a los usuarios en nodos separados e introduce componentes para gestionar la interacción entre ellos.

que es nextcloud y

Para una muestra gratis registrate aquí.

Si lo quieres instalar en tu propio servidor o rentar uno de los nuestros te podemos ayudar, visítanos en https://easyvhost.com/servicios-de-servidores-virtuales/.

Ahora para la instalación de Nextcloud en un servidor virtual (VPS), síguenos aquí.