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

Factura Ninja en CentOS 7 | Cómo instalar

servicios de servidores virtuales

Este tutorial cubre la instalación de factura Ninja en Centos 7 VPS con Nginx, PHP y MariaDB. Invoice Ninja es una plataforma gratuita y auto-alojada para la gestión de facturación y pagos basada en Laravel. Es muy fácil de usar y se puede integrar con la mayoría de las pasarelas de pago más populares, incluyendo PayPal, 2CheckOut, Stripe, WePay, y muchas más… lo que la convierte en una solución perfecta para autónomos y pequeñas o medianas empresas.

  • Crea facturas y presupuestos en poco tiempo
  • Fácil seguimiento del tiempo y creación de tareas.
  • Enviar facturas y aceptar pagos en línea
  • Se integra con más de 30 puertas de enlace, incluyendo: Stripe, PayPal, Authorize y Dwolla
  • Crear fácilmente presupuestos y facturas en línea
  • URL de la factura personalizada de Company.InvoiceNinja.com
  • Aplicaciones iOS y Android

Requisitos previos

  • CentOS 7 VPS with 2GB de RAM
  • SSH acceso con privilegios de raíz
  • PHP version 5.5.9 o más reciente
  • MySQL/MariaDB servidor de base de datos
  • Apache/Nginx servidor web

Ingresa a través de SSH y actualiza el servidor

Instalaremos la factura Ninja a través de la interfaz de línea de comandos, así que primero tenemos que acceder al CentOS 7 VPS a través de SSH como usuario de raíz.

ssh root@IP_Address -p Port_Number

Una vez que hayas entrado, no olvides actualizar todos los paquetes instalados en el servidor

yum -y update

Instalar el servidor web Nginx

yum -y install nginx

Después de que el administrador de instalación termine la instalación, inicie el servidor web y habilítelo para que se inicie automáticamente después de un reinicio.

systemctl start nginx

systemctl enable nginx

netstat -plntu

blank

Instalar PHP 7

CentOS 7 por defecto viene con PHP 5.4 que ha llegado al final de su vida útil y ya no está soportado. Por lo tanto, en este tutorial instalaremos PHP 7 en su lugar. Para ello tenemos que añadir el repositorio Webtatic EL yum.

yum -y install epel-release

rpm -Uvh https://mirror.webtatic.com/yum/el7/webtatic-release.rpm

Una vez añadido el repositorio, podemos proceder a instalar PHP y varios módulos de PHP

yum -y install php70w-fpm php70w-cli php70w-pear php70w-gd php70w-xml php70w-mysql php70w-zip php70w-mbstring php70w-mcrypt php70w-curl php70w-gmp php70w-pdo-cli php70w

verificar que PHP 7 está instalado

php -v
PHP 7.0.31 (cli) (construido: Jul 20 2018 08:55:22) ( NTS )
Copyright (c) 1997-2017 El Grupo PHP

Cuando termine la instalación, edite el archivo de configuración php.ini con vim.

vim /etc/php.ini
Descomente la línea cgi.fix_pathinfo de abajo y cambie el valor a 0.
cgi.fix_pathinfo=0
Guarda el archivo y sal de Vim.

Entonces edita el archivo de configuración PHP-FPM.

vim /etc/php-fpm.d/www.conf

Cambie el usuario y el grupo de la línea 8 y 10 al grupo ‘nginx’.

usuario = nginx
grupo = nginx

En lugar de un puerto, usaremos un archivo de socorro para php-fpm. Cambie la línea de listen a ‘/var/run/php/php-fpm.sock‘.

listen = /var/run/php/php-fpm.sock

Descomente la configuración del archivo del socket, el propietario, el grupo y el permiso.

listen.owner = nginx
listen.group = nginx
listen.mode = 0660

Descomente las variables de entorno php-fpm en la línea 366-370.

env[HOSTNAME] = $HOSTNAME
env[PATH] = /usr/local/bin:/usr/bin:/bin
env[TMP] = /tmp
env[TMPDIR] = /tmp
env[TEMP] = /tmp

Guarde el archivo y salga del editor.

Ahora necesitamos crear un nuevo directorio de sesión de PHP y cambiar el propietario al usuario y grupo nginx.

mkdir -p /var/lib/php/session
chown -R nginx:nginx /var/lib/php/session/

Crear un nuevo directorio para el archivo de sockets y cambiar el permiso para el usuario y el grupo de nginx.

mkdir -p /var/run/php/
chown -R nginx:nginx /var/run/php/

A continuación, inicie PHP7.0-FPM y añádalo para que se inicie en el momento del arranque.

systemctl start php-fpm
systemctl enable php-fpm

blank

PHP-FPM ha comenzado. Ahora puedes comprobarlo con el comando de abajo y verás el archivo de sockets PHP.

netstat -pl

PHP7.0-FPM y todas las extensiones necesarias para el Ninja de la Factura están instaladas.

Instalar el servidor de la base de datos de MariaDB

El Ninja Factura almacena su información en una base de datos. Por lo tanto, instalaremos el servidor de la base de datos MariaDB y crearemos una nueva base de datos junto con un usuario que pueda acceder a ella. Ejecute el siguiente comando para instalar el servidor de MariaDB.

yum install -y mod_ssl mariadb mariadb-server

Inicie el servidor y habilítelo para que se inicie al reiniciar.

systemctl start mariadb

systemctl enable mariadb

En el siguiente paso, ejecute el siguiente comando ‘mysql_secure_installation‘ para asegurar la base de datos de MariaDB. El siguiente extracto ilustra cómo asegurar la base de datos. Principalmente, responda con un sí a todas las preguntas del guión.

Set root password? [Y/n] Y
New password:
Re-enter new password:

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

A continuación, tenemos que crear una nueva base de datos y un nuevo usuario para Invoice Ninja en el shell de MySQL que hemos abierto. Crearemos una nueva base de datos llamada ‘ninjadb’, un nuevo usuario ‘ninja’ con la contraseña ‘aqwe123’. Por favor, elija una contraseña segura diferente para su instalación.

Crea todo con las consultas de MySQL a continuación: crear una nueva base de datos, crear un nuevo usuario y contraseña, conceder el acceso a la base de datos al nuevo usuario con contraseña.

A continuación, inicia sesión en el servidor de la base de datos como usuario de raíz.

mysql -u root -p

create database ninjadb;
create user ninja@localhost identified by ‘aqwe123’;
grant all privileges on ninjadb.* to ninja@localhost identified by ‘aqwe123’;
flush privileges;

Reemplaza la “CONTRASEÑA” por una contraseña sólida.

blank

Instalar y configurar la factura Ninja

En este paso, descargaremos y configuraremos la Factura Ninja. Instalaremos unzip, wget, curl en tu sistema.

yum -y install unzip wget curl

Crear un nuevo directorio para los archivos de la webroot del Ninja de la Factura.

mkdir -p /var/www/
cd /var/www/

Descargue el último establo del Ninja de la Factura a su servidor. En el momento de escribir este artículo es la versión 4.5.18

curl -L https://download.invoiceninja.com/ -o invoiceninja.zip

Descomprima el archivo ZIP descargado en el documento raíz del directorio de su servidor. El archivo ZIP incluye todas las bibliotecas de terceros necesarias.

unzip ninja-v4.5.18.zip

El contenido de la Factura Ninja se almacenará en un nuevo directorio ‘ninja’.

cd ninja/

Para el proyecto Laravel, necesitamos instalar un compositor, un Administrador de Dependencias para PHP.

curl -sS https://getcomposer.org/installer | sudo php — –install-dir=/usr/bin –filename=composer

blank

Ahora puedes usar el comando de composer.

A continuación, instale las dependencias del Ninja de la Factura con el comando de composer de abajo.

composer install –no-dev -o

  • –no-dev: Desactiva la instalaci¢n de los paquetes require-dev.
  • -o: Optimiza el autocargador durante el volcado del autocargador.

Cuando la instalación de la dependencia esté hecha, copie el archivo .env y edítelo con vim.

cp .env.example .env
vim .env

Cambie el valor de los ajustes de la base de datos a continuación.

DB_DATABASE=ninjadb
DB_USERNAME=ninja
DB_PASSWORD=aqwe123

blank

Salvar y salir.

A continuación, edite la configuración de la base de datos en el directorio de configuración.

vim config/database.php

Estamos usando la base de datos MariaDB/MySQL, ve a la configuración de MySQL en la línea 55.

‘database’ => env(‘DB_DATABASE’, ‘ninjadb’),
‘username’ => env(‘DB_USERNAME’, ‘ninja’),
‘password’ => env(‘DB_PASSWORD’, ‘aqwe123’),

blank

Salvar y salir.

Todos los archivos de configuración están editados, a continuación prepare la base de datos con el comando de abajo.

php artisan migrate

Se le pedirá que ejecute el comando, escriba “yes” y presione Enter.

blank

A continuación, sembrar la base de datos con todos los registros.

php artisan db:seed

Escriba “yes” y presione Enter para confirmar.

blank

Generar la clave de aplicación.

php artisan key:generate

Verá la clave de la aplicación.

Edita el archivo app.php con vim.

vim config/app.php

Ve a la línea 85 de APP_KEY y pega la clave generada (la clave de abajo es un ejemplo, usa en su lugar la clave que obtuviste del comando de arriba).

‘key’ => env(‘APP_KEY’, ‘base64:0o5QLWbNeDCNer064+600Hl8oJ20OPCIymadKJQ1RGo=’),

Salvar y salir.

Finalmente, cambia el propietario del directorio ‘/var/www/ninja’ por el usuario y el grupo ‘nginx’.

cd /var/www/
chown -R nginx:nginx ninja/

blank

El Ninja de la Factura ha sido configurado y está listo para la instalación.

Configurar el SSL y el Host Virtual

En este paso, generaremos un archivo de certificado SSL con el comando openssl y crearemos una nueva configuración de host virtual para Invoice Ninja. Si estás en un servidor activo, también puedes usar un SSL gratuito de Let’s Encrypt.

Crea un nuevo directorio “cert” para los archivos SSL.

mkdir -p /etc/nginx/cert/

Ejecute el comando OpenSSL a continuación para generar los archivos del certificado.

openssl req -new -x509 -days 365 -nodes -out /etc/nginx/cert/ninja.crt -keyout /etc/nginx/cert/ninja.key

Cambie el permiso de los archivos del certificado a ‘600’.

chmod 600 /etc/nginx/cert/*

blank

A continuación, ve al directorio Nginx y crea un nuevo archivo de configuración de host virtual llamado ‘ninja.conf’.

cd /etc/nginx/
vim conf.d/ninja.conf

Pegue la configuración del host virtual abajo.

server { # Your Domain Name – hakase-labs.co listen 80; server_name ninja.co www.ninja.co; # Rewrite redirect to https add_header Strict-Transport-Security max-age=2592000; rewrite ^ https://$server_name$request_uri? permanent; } server { # Your Domain Name – hakase-labs.co listen 443 default; server_name ninja.co www.ninja.co; # Enable SSL for Invoice Ninja ssl on; ssl_certificate /etc/nginx/cert/ninja.crt; ssl_certificate_key /etc/nginx/cert/ninja.key; ssl_session_timeout 5m; ssl_ciphers ‘AES128+EECDH:AES128+EDH:!aNULL’; ssl_protocols TLSv1 TLSv1.1 TLSv1.2; ssl_prefer_server_ciphers on; # Invoice Ninja web root files root /var/www/ninja/public; index index.html index.htm index.php; charset utf-8; location / { try_files $uri $uri/ /index.php?$query_string; } location = /favicon.ico { access_log off; log_not_found off; } location = /robots.txt { access_log off; log_not_found off; } # Access and Error Log for Invoice Ninja access_log /var/log/nginx/ininja.access.log; error_log /var/log/nginx/ininja.error.log; sendfile off; # Handle PHP Applications location ~ \.php$ { fastcgi_split_path_info ^(.+\.php)(/.+)$; fastcgi_pass unix:/var/run/php/php-fpm.sock; fastcgi_index index.php; include fastcgi_params; fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name; fastcgi_intercept_errors off; fastcgi_buffer_size 16k; fastcgi_buffers 4 16k; } location ~ /\.ht { deny all; } }

Salvar y salir.

Ahora prueba la configuración de Nginx y asegúrate de que no haya errores.

nginx -t

Reinicie el servidor web de Nginx.

systemctl restart nginx

blank

Se ha creado la configuración del host virtual del Ninja Factura.

Abre tu navegador y escribe el URL de la Factura Ninja, en mi caso: ninja.co.

Serás redirigido a una conexión https y a la página de configuración.

factura Ninja en Centos

Introduzca los detalles de configuración solicitados, Configuración de la aplicación, Conexión a la base de datos, Configuración del correo electrónico, Detalles del usuario y compruebe el TOS del Ninja de la factura.

factura Ninja en Centos

Haz clic en “Submit” y serás redirigido a la página de acceso de Invoice Ninja.

factura Ninja en Centos

Escriba su correo electrónico y su contraseña, luego presione ‘LOGIN’.

factura Ninja en Centos

Verás el Tablero Ninja de Facturas.

factura Ninja en Centos

Página de configuración del ninja de la factura.

factura Ninja en Centos

Ninja Factura ha sido instalado con Nginx y MariaDB en CentOS 7.

Para mas información sobre precios y renta de un servidor virtual, ir a mi pagina web https://easyvhost.com