Instalación de Nextcloud 18

Antes de empezar la instalación de Nextcloud 18, seria bueno que lo hagas en una nueva instalación de Ubuntu o Debian, un dominio totalmente calificado, si no tienes dominio y deseas adquirir uno, visítanos aquí.

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

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:

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

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.

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 America/New_York

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 = 1024M/" /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.

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

Cómo pasar de MariaDB v. 10.4 a v. 10.5

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): 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

nano /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-COMMITTEDunix_socket=OFFuser = 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.

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.

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, recuerda que tienes que remplazar “tu.dedyn.io” con el numbre de tu dominio:

server {
server_name tu.dedyn.io;
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 tu.dedyn.io;
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;
}
rewrite ^/.well-known/webfinger /public.php?service=webfinger last;
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;
}
}

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" 

usuario de la base de datos "nextcloud" 

paso de base de datos "nextcloud" 

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:

Añade tu dominio como un dominio de confianza, agregando 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

Establece tu dominio como overwrite.cli.url y añade tu dominio dedicado a tu.dedyn.io:

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 y

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

Curación (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 para llenar el archivo. El resultado es el siguiente:

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

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 de acceso fallidos (maxretry) en los últimos 36000 segundos (findtime, corresponde a 10h) la IP del atacante potencial se bloquea durante 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 previamente has cambiado el puerto SSH de 22 a otro puerto, debes 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

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 mas informacion sobre los servicios que ofrecemos nos puede mandar un correo a sales@easyvhost.com o visitarnos en https://easyvhost.com

Leave a Reply

Your email address will not be published. Required fields are marked *