Cómo instalar Standard Notes Server en Rocky Linux 9
Standard Notes es una aplicación de notas de código abierto y completamente encriptada. Ofrece planes gratuitos y de pago y ofrece tanto alojamiento en la nube como la opción de alojarlo en tu servidor. Puedes utilizar tu servidor para sincronizar las notas almacenadas entre distintos dispositivos. Standard Notes ofrece aplicaciones para todos los sistemas operativos de escritorio y plataformas móviles.
Este tutorial te enseña a autoalojar tu servidor de Standard Notes en una máquina Rocky Linux 9. También aprenderás cómo activar planes de pago en el servidor de forma gratuita y cómo habilitar la subida de archivos.
Requisitos previos
- Un servidor que ejecute Rocky Linux 9 con al menos 2 GB de RAM.
- Un usuario no root con privilegios sudo.
- Un nombre de dominio totalmente cualificado apuntando al servidor. Para nuestro tutorial, utilizaremos el dominio
standardnotes.example.com. Necesitarás dos nombres de dominio más, uno para el servidor de archivos y otro para la aplicación web. Utilizaremos el dominiosnotes-files.example.compara el servidor de archivos ysnotes-web.example.compara la aplicación web. - Todo está actualizado.
$ sudo dnf update
- Pocos paquetes necesita tu sistema.
$ sudo dnf install -y wget nano unzip yum-utils policycoreutils-python-utils
Puede que algunos de estos paquetes ya estén instalados en tu sistema.
Paso 1 – Configurar el cortafuegos
Antes de instalar ningún paquete, el primer paso es configurar el cortafuegos para abrir puertos para HTTP, y HTTPS. Rocky Linux utiliza el cortafuegos Firewalld. Comprueba el estado del cortafuegos.
$ sudo firewall-cmd --state running
El cortafuegos funciona con diferentes zonas, y la zona pública es la que utilizaremos por defecto. Enumera todos los servicios y puertos activos en el cortafuegos.
$ sudo firewall-cmd --zone=public --list-all
Debería mostrar la siguiente salida.
public target: default icmp-block-inversion: no interfaces: enp1s0 sources: services: cockpit dhcpv6-client ssh ports: protocols: forward: yes masquerade: no forward-ports: source-ports: icmp-blocks: rich rules:
Abre los puertos HTTP y HTTPS en el cortafuegos.
$ sudo firewall-cmd --zone=public --add-service=http $ sudo firewall-cmd --zone=public --add-service=https
Vuelve a comprobar el estado del cortafuegos.
$ sudo firewall-cmd --zone=public --list-all
Deberías ver un resultado similar.
public target: default icmp-block-inversion: no interfaces: enp1s0 sources: services: cockpit dhcpv6-client http https ssh ports: protocols: forward: yes masquerade: no forward-ports: source-ports: icmp-blocks: rich rules:
Haz permanentes todos los cambios y vuelve a cargar el cortafuegos para activar los cambios.
$ sudo firewall-cmd --runtime-to-permanent $ sudo firewall-cmd --reload
Paso 2 – Instala Docker y Docker Compose
Instala el repositorio oficial de Docker.
$ sudo dnf config-manager \
--add-repo \
https://download.docker.com/linux/centos/docker-ce.repo
Instala Docker.
$ sudo dnf install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
Habilita y ejecuta el demonio Docker.
$ sudo systemctl enable docker --now
Comprueba el estado del servicio Docker.
$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
Loaded: loaded (/usr/lib/systemd/system/docker.service; enabled; preset: disabled)
Active: active (running) since Tue 2024-04-16 23:35:00 UTC; 5s ago
TriggeredBy: ? docker.socket
Docs: https://docs.docker.com
Main PID: 23273 (dockerd)
Tasks: 9
Memory: 34.0M
CPU: 176ms
CGroup: /system.slice/docker.service
??23273 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
Apr 16 23:35:00 standard-notes systemd[1]: Starting Docker Application Container Engine...
Apr 16 23:35:00 standard-notes dockerd[23273]: time="2024-04-16T23:35:00.050964934Z" level=info msg="Starting up"
Apr 16 23:35:00 standard-notes dockerd[23273]: time="2024-04-16T23:35:00.083526973Z" level=info msg="Loading containers: start."
Apr 16 23:35:00 standard-notes dockerd[23273]: time="2024-04-16T23:35:00.654481705Z" level=info msg="Firewalld: interface docker0 already part of docker zone, returning"
Apr 16 23:35:00 standard-notes dockerd[23273]: time="2024-04-16T23:35:00.772647844Z" level=info msg="Loading containers: done."
Apr 16 23:35:00 standard-notes dockerd[23273]: time="2024-04-16T23:35:00.793814339Z" level=info msg="Docker daemon" commit=60b9add containerd-snapshotter=false storage-driver=overlay2 version=26.0.1
Apr 16 23:35:00 standard-notes dockerd[23273]: time="2024-04-16T23:35:00.793962347Z" level=info msg="Daemon has completed initialization"
Apr 16 23:35:00 standard-notes dockerd[23273]: time="2024-04-16T23:35:00.827030005Z" level=info msg="API listen on /run/docker.sock"
Apr 16 23:35:00 standard-notes systemd[1]: Started Docker Application Container Engine.
Añade tu usuario de sistema al grupo Docker para evitar utilizar sudo para ejecutar comandos Docker.
$ sudo usermod -aG docker $(whoami)
Vuelve a conectarte a tu servidor después de cerrar la sesión para activar el cambio.
Verifica el cambio.
$ groups navjot wheel docker
Paso 3 – Instalar Nginx
Rocky Linux 9 viene con una versión antigua de Nginx. Necesitas utilizar el repositorio oficial de Nginx para instalar la última versión.
Crea y abre el archivo /etc/yum.repos.d/nginx.repo para editarlo.
$ sudo nano /etc/yum.repos.d/nginx.repo
Pega en él el siguiente código.
[nginx-stable] name=nginx stable repo baseurl=http://nginx.org/packages/centos/$releasever/$basearch/ gpgcheck=1 enabled=0 gpgkey=https://nginx.org/keys/nginx_signing.key module_hotfixes=true [nginx-mainline] name=nginx mainline repo baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/ gpgcheck=1 enabled=1 gpgkey=https://nginx.org/keys/nginx_signing.key module_hotfixes=true
Cuando hayas terminado, guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida. Utilizaremos la versión mainline de Nginx y, por tanto, hemos habilitado el repositorio mainline en el archivo anterior utilizando enabled=1 en la sección mainline en lugar de la estable. Puedes elegir cualquiera de las dos.
Instala Nginx.
$ sudo dnf install nginx -y
Verifica la instalación.
$ nginx -v nginx version: nginx/1.25.5
Habilita e inicia el servicio del servidor Nginx.
$ sudo systemctl enable nginx --now
Comprueba el estado del servicio.
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; preset: disabled)
Active: active (running) since Tue 2024-04-16 23:41:23 UTC; 6s ago
Docs: http://nginx.org/en/docs/
Process: 4886 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 4887 (nginx)
Tasks: 3 (limit: 10819)
Memory: 3.1M
CPU: 11ms
CGroup: /system.slice/nginx.service
??4887 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??4888 "nginx: worker process"
??4889 "nginx: worker process"
Apr 16 23:41:23 standard-notes systemd[1]: Starting nginx - high performance web server...
Apr 16 23:41:23 standard-notes systemd[1]: Started nginx - high performance web server.
Paso 4 – Instalar SSL
Necesitamos instalar Certbot para generar el certificado SSL. Para ello utilizaremos el instalador de paquetes Snapd. Como Rocky Linux no lo incluye, instala el instalador Snapd. Necesita el repositorio EPEL (Extra Packages for Enterprise Linux) para funcionar.
Instala el repositorio EPEL.
$ sudo dnf install epel-release -y
Instala el paquete Snapd.
$ sudo dnf install snapd -y
Activa e inicia el servicio Snap.
$ sudo systemctl enable snapd --now
Instala el paquete Snap core, y asegúrate de que tu versión de Snapd está actualizada.
$ sudo snap install core && sudo snap refresh core
Crea los enlaces necesarios para que Snapd funcione.
$ sudo ln -s /var/lib/snapd/snap /snap $ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh
Instala Certbot.
$ sudo snap install --classic certbot
Asegúrate de que se puede ejecutar el comando Certbot creando un enlace simbólico al directorio /usr/bin.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Comprueba la versión de Certbot.
$ certbot --version certbot 2.10.0
Ejecuta el siguiente comando para generar un certificado SSL.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d standardnotes.example.com
El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/standardnotes.example.com de tu servidor.
Tenemos que hacer lo mismo para el subdominio Archivos.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d snotes-files.example.com
Y por último, de nuevo para la aplicación web.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d snotes-web.example.com
Genera un certificado de grupo Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Comprueba el servicio programador de renovaciones de Certbot.
$ systemctl list-timers
Encontrarás snap.certbot.renew.service como uno de los servicios programados para ejecutarse.
NEXT LEFT LAST PASSED UNIT ACTIVATES ---------------------------------------------------------------------------------------------------------------------------------- Wed 2024-04-17 00:00:00 UTC 5min left Tue 2024-04-16 23:29:44 UTC 24min ago logrotate.timer logrotate.service Wed 2024-04-17 00:31:26 UTC 36min left - - dnf-makecache.timer dnf-makecache.service Wed 2024-04-17 11:00:00 UTC 11h left - - snap.certbot.renew.timer snap.certbot.renew.service
Realiza una ejecución en seco del proceso para comprobar si la renovación SSL funciona correctamente.
$ sudo certbot renew --dry-run
Si no ves ningún error, ya está todo listo. Tu certificado se renovará automáticamente.
Paso 5 – Descarga y configura Standard Notes
Asegúrate de que estás en el directorio principal de tu sistema.
$ cd ~
Crea un directorio de trabajo para Standard Notes Server y pasa a él.
$ mkdir standardnotes $ cd ~/standardnotes
Descarga el archivo de ejemplo de entorno del repositorio GitHub de Standard Notes.
$ wget https://raw.githubusercontent.com/standardnotes/server/main/.env.sample
Crea el archivo de entorno de trabajo a partir del archivo de ejemplo descargado.
$ cp .env.sample .env
Necesitarás tres claves de autenticación y cifrado para configurar el archivo .env. Ejecuta el siguiente comando para generar tres claves distintas y copia su salida.
$ openssl rand -hex 32
También necesitarás una contraseña segura para la base de datos. Puedes ejecutar el siguiente comando para generar una contraseña segura para la base de datos.
$ openssl rand -hex 12
Abre el archivo de entorno para editarlo.
$ nano .env
Elige una contraseña de base de datos segura y añádela a la variable DB_PASSWORD.
###### # DB # ###### DB_HOST=db DB_PORT=3306 DB_USERNAME=std_notes_user DB_PASSWORD=changeme DB_DATABASE=standard_notes_db DB_TYPE=mysql ######### # CACHE # ######### REDIS_PORT=6379 REDIS_HOST=cache CACHE_TYPE=redis ######## # KEYS # ######## AUTH_JWT_SECRET= AUTH_SERVER_ENCRYPTION_SERVER_KEY= VALET_TOKEN_SECRET=
Añade las claves generadas anteriormente y ponlas en las tres variables de la sección KEYS.
Por defecto, el Registro de Usuarios está activado. Si quieres desactivar el registro público de usuarios en tu servidor Standard Notes, añade la siguiente variable en el archivo de entorno. Sin embargo, hazlo sólo después de haber creado tu primera cuenta en él. Si lo haces al principio, no podrás utilizar la aplicación por ti mismo.
AUTH_SERVER_DISABLE_USER_REGISTRATION=true
Añade la siguiente variable para definir la URL de tus Archivos de Notas Estándar.
PUBLIC_FILES_SERVER_URL=https://snotes-files.example.com
El archivo .env completo debe tener el siguiente aspecto.
###### # DB # ###### DB_HOST=db DB_PORT=3306 DB_USERNAME=std_notes_user DB_PASSWORD=<YourDBPassword> DB_DATABASE=standard_notes_db DB_TYPE=mysql ######### # CACHE # ######### REDIS_PORT=6379 REDIS_HOST=cache CACHE_TYPE=redis ######## # KEYS # ######## AUTH_JWT_SECRET=52b354ad5d8f11c995b4eed33870a1a7afbbc84b8da61e0b583660b075d0390c AUTH_SERVER_ENCRYPTION_SERVER_KEY=fce4fe78972c3407be47127aee57d67e86b84afb628020b7ab6999edb3c905f1 VALET_TOKEN_SECRET=50aad911a283f252713139667b6475ac105280a220e009e05f733cf785630ce5 AUTH_SERVER_DISABLE_USER_REGISTRATION=true PUBLIC_FILES_SERVER_URL=https://snotes-files.example.com
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida una vez hayas terminado.
Descarga el script bootstrap de Localstack desde el repositorio de GitHub.
$ wget https://raw.githubusercontent.com/standardnotes/server/main/docker/localstack_bootstrap.sh
Da permisos de ejecutable al script.
$ chmod +x localstack_bootstrap.sh
Descarga el archivo Docker Compose para el servidor Standard Notes del repositorio de GitHub.
$ wget https://raw.githubusercontent.com/standardnotes/server/main/docker-compose.example.yml
Crea un archivo Docker Compose de trabajo a partir del archivo Docker Compose de ejemplo descargado.
$ cp docker-compose.example.yml docker-compose.yml
Ábrelo para editarlo.
$ nano docker-compose.yml
Cambia el valor de MYSQL_ROOT_PASSWORD y MYSQL_PASSWORD por la contraseña de la base de datos que seleccionaste anteriormente en el archivo .env. Tu archivo Docker Compose debería tener el siguiente aspecto.
services:
server:
image: standardnotes/server
env_file: .env
container_name: server_self_hosted
restart: unless-stopped
ports:
- 3000:3000
- 3125:3104
volumes:
- ./logs:/var/lib/server/logs
- ./uploads:/opt/server/packages/files/dist/uploads
networks:
- standardnotes_self_hosted
localstack:
image: localstack/localstack:3.0
container_name: localstack_self_hosted
expose:
- 4566
restart: unless-stopped
environment:
- SERVICES=sns,sqs
- HOSTNAME_EXTERNAL=localstack
- LS_LOG=warn
volumes:
- ./localstack_bootstrap.sh:/etc/localstack/init/ready.d/localstack_bootstrap.sh
networks:
- standardnotes_self_hosted
db:
image: mysql:8
container_name: db_self_hosted
environment:
- MYSQL_DATABASE=standard_notes_db
- MYSQL_USER=std_notes_user
- MYSQL_ROOT_PASSWORD=<YourDBPassword>
- MYSQL_PASSWORD=<YourDBPassword>
expose:
- 3306
restart: unless-stopped
command: --default-authentication-plugin=mysql_native_password --character-set-server=utf8mb4 --collation-server=utf8mb4_general_ci
volumes:
- ./data/mysql:/var/lib/mysql
- ./data/import:/docker-entrypoint-initdb.d
networks:
- standardnotes_self_hosted
cache:
image: redis:6.0-alpine
container_name: cache_self_hosted
volumes:
- ./data/redis/:/data
expose:
- 6379
restart: unless-stopped
networks:
- standardnotes_self_hosted
networks:
standardnotes_self_hosted:
name: standardnotes_self_hosted
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite una vez hayas terminado. Con esto concluye la descarga y configuración del servidor Standard Notes.
Paso 6 – Iniciar el Servidor Standard Notes
Ejecuta el siguiente comando para iniciar el servidor.
$ docker compose up -d
Este comando tardará unos minutos en completarse. Durante este tiempo, el proceso extraerá todas las imágenes Docker relevantes y creará contenedores para todos los servicios. También rellenará la base de datos y realizará las migraciones pertinentes. El uso de la CPU puede dispararse durante un par de minutos, pero debería bajar pronto.
Puedes encontrar los registros del servidor Standard Notes en el directorio logs. Puedes comprobar los registros del proceso utilizando el siguiente comando.
$ tail -f logs/*.log
Pulsa Ctrl + C para salir de los registros. Puedes comprobar el estado de los contenedores en ejecución utilizando cualquiera de los siguientes comandos.
$ docker compose ps OR $ docker ps
Recibirás una salida similar.
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS cache_self_hosted redis:6.0-alpine "docker-entrypoint.s…" cache 16 minutes ago Up 5 minutes 6379/tcp db_self_hosted mysql:8 "docker-entrypoint.s…" db 16 minutes ago Up 5 minutes 3306/tcp, 33060/tcp localstack_self_hosted localstack/localstack:3.0 "docker-entrypoint.sh" localstack 16 minutes ago Up 5 minutes (healthy) 4510-4559/tcp, 4566/tcp, 5678/tcp server_self_hosted standardnotes/server "docker-entrypoint.sh" server 16 minutes ago Up 5 minutes 0.0.0.0:3000->3000/tcp, :::3000->3000/tcp, 0.0.0.0:3125->3104/tcp, :::3125->3104/tcp
Puedes comprobar la salud del servidor utilizando el siguiente comando.
$ curl http://localhost:3000/healthcheck OK
Standard Notes utiliza el puerto 3000 por defecto. Si configuraste un puerto diferente en el archivo .env, debes actualizarlo en el comando anterior.
Paso 7 – Instalar Standard Notes Web App
Puedes utilizar la aplicación web existente de Standard Notes o alojar la tuya. Para nuestro tutorial, alojaremos nosotros mismos la aplicación web de Standard Notes.
Instalar Git
Antes de seguir adelante, necesitamos instalar algunas cosas, una de las cuales es Git. Instala Git.
$ sudo dnf install git -y
Instalar NodeJS
El siguiente paso es instalar NodeJS. Para ello instalaremos la versión Node 18.x LTS. Ejecuta los siguientes comandos para instalar NodeJS.
$ curl -fsSL https://rpm.nodesource.com/setup_18.x | sudo bash - $ sudo dnf install -y nodejs
Confirma la instalación.
$ node --version v18.20.2
Instalar Yarn
También necesitamos el gestor de paquetes Yarn. Instálalo utilizando Node.
$ sudo npm install --global yarn
Instala el gestor de paquetes PM2.
Necesitamos PM2 para ayudar a ejecutar la aplicación web Standard Notes como un servicio en segundo plano.
$ sudo npm install --global pm2
Instala la aplicación web
Crea un directorio para la aplicación web y accede a él.
$ cd ~ $ mkdir snotes-app $ cd ~/snotes-app
Descarga la aplicación Standard Notes de GitHub.
$ git clone https://github.com/standardnotes/app.git .
Utiliza Yarn para instalar las dependencias. Ignora las advertencias.
$ yarn install
Construye los paquetes para la aplicación web.
$ yarn build:web
Cambia al directorio web.
$ cd packages/web
Inicia la aplicación web con PM2.
$ pm2 start "yarn start" --name api
Puedes comprobar el estado del servicio utilizando el siguiente comando.
$ pm2 status [PM2] Starting /usr/bin/bash in fork_mode (1 instance) [PM2] Done. ???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????? ? id ? name ? namespace ? version ? mode ? pid ? uptime ? ? ? status ? cpu ? mem ? user ? watching ? ???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????? ? 0 ? api ? default ? N/A ? fork ? 15090 ? 0s ? 0 ? online ? 0% ? 26.2mb ? navjot ? disabled ? ????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????
La aplicación se iniciará y será accesible a través del puerto 3001. Utilizaremos esta información para crear una configuración Nginx para la aplicación web.
PM2 no reinicia la aplicación al reiniciar. Para ello, necesitamos generar un script de inicio.
$ pm2 startup
Deberías obtener una salida similar.
[PM2] Init System found: systemd [PM2] To setup the Startup Script, copy/paste the following command: sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u navjot --hp /home/navjot
Ejecuta el comando que aparece en la salida.
$ sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u navjot --hp /home/navjot
Esto generará y habilitará un archivo de servicio systemd.
Guarda el proceso para que se inicie automáticamente al reiniciar.
$ pm2 save
Paso 8 – Configurar Nginx
Abre el archivo /etc/nginx/nginx.conf para editarlo.
$ sudo nano /etc/nginx/nginx.conf
Añade la siguiente línea antes de la línea include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.
Crea y abre el archivo /etc/nginx/conf.d/standardnotes.conf para editarlo.
$ sudo nano /etc/nginx/conf.d/standardnotes.conf
Pega en él el siguiente código. Sustituye standardnotes.example.com por el nombre de tu dominio. Hemos fijado el valor de client_max_body_size en 50MB. Puedes cambiarlo según tus necesidades.
server {
listen 443 ssl;
listen [::]:443 ssl;
http2 on;
http3 on;
quic_retry on;
server_name standardnotes.example.com;
client_max_body_size 50M;
access_log /var/log/nginx/standardnotes.access.log;
error_log /var/log/nginx/standardnotes.error.log;
ssl_certificate /etc/letsencrypt/live/standardnotes.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/standardnotes.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/standardnotes.example.com/chain.pem;
ssl_session_timeout 5m;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers off;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
resolver 8.8.8.8;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
location / {
proxy_pass http://127.0.0.1:3000;
proxy_cache off;
}
}
# enforce HTTPS
server {
listen 80;
listen [::]:80;
server_name standardnotes.example.com;
return 301 https://$host$request_uri;
}
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.
El archivo anterior es para la aplicación principal de Standard Notes. A continuación, tenemos que configurar otro archivo para el subdominio Archivos.
$ sudo nano /etc/nginx/conf.d/files-standardnotes.conf
Pega en él el siguiente código. Sustituye snotes-files.example.com por el nombre de tu dominio. Hemos fijado el valor de la variable client_max_body_size en 50MB. Puedes cambiarlo según tus necesidades.
server {
listen 443 ssl;
listen [::]:443 ssl;
http2 on;
http3 on;
quic_retry on;
server_name snotes-files.example.com;
client_max_body_size 50M;
access_log /var/log/nginx/files-standardnotes.access.log;
error_log /var/log/nginx/files-standardnotes.error.log;
ssl_certificate /etc/letsencrypt/live/snotes-files.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/snotes-files.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/snotes-files.example.com/chain.pem;
ssl_session_timeout 5m;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers off;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
resolver 8.8.8.8;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
location / {
proxy_pass http://127.0.0.1:3125;
proxy_cache off;
}
}
# enforce HTTPS
server {
listen 80;
listen [::]:80;
server_name snotes-files.example.com;
return 301 https://$host$request_uri;
}
Por último, tenemos que crear un archivo de configuración para la aplicación web.
$ sudo nano /etc/nginx/conf.d/web-standardnotes.conf
Pega en él el siguiente código.
server {
listen 443 ssl;
listen [::]:443 ssl;
http2 on;
http3 on;
quic_retry on;
server_name snotes-web.example.com;
client_max_body_size 50M;
access_log /var/log/nginx/standardnotes-web.access.log;
error_log /var/log/nginx/standardnotes-web.error.log;
ssl_certificate /etc/letsencrypt/live/snotes-web.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/snotes-web.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/snotes-web.example.com/chain.pem;
ssl_session_timeout 5m;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers off;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
resolver 8.8.8.8;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
location / {
proxy_pass http://127.0.0.1:3125;
proxy_cache off;
}
}
# enforce HTTPS
server {
listen 80;
listen [::]:80;
server_name snotes-web.example.com;
return 301 https://$host$request_uri;
}
Comprueba la configuración de Nginx.
$ sudo nginx -t
Reinicia el servidor Nginx para habilitar los archivos de configuración.
$ sudo systemctl restart nginx
Paso 9 – Configurar SELinux
Aplica la política para permitir conexiones a hosts externos.
$ sudo setsebool -P httpd_can_network_connect 1
Aplica la política para permitir que Nginx dé acceso a PostgreSQL.
$ sudo setsebool -P httpd_can_network_connect_db 1
Paso 10 – Utilizar Notas Estándar
Si abres la URL https://standardnotes.example.com en tu navegador, deberías ver la siguiente salida.
Esto significa que tu servidor está funcionando. Para utilizar Standard Notes, tendrás que utilizar las aplicaciones oficiales. Para nuestro tutorial, utilizaremos su aplicación web, pero el método será el mismo para las aplicaciones de escritorio y móvil.
Abre la URL https://snotes-web.example.com para acceder a la aplicación web. Haz clic en el enlace Crear cuenta gratuita en la parte inferior izquierda de la página e introduce tu dirección de correo electrónico y contraseña. Haz clic en el botón Funciones avanzadas, desmarca la opción Servidor de sincronización personalizado e introduce la URL https://standardnotes.example.com en la casilla.
Haz clic en el botón Siguiente para continuar. Se te pedirá de nuevo tu contraseña.
Una vez iniciada la sesión, puedes empezar a crear notas y a utilizar la aplicación.
Paso 11 – Habilitar las funciones de pago
Hasta ahora, hemos activado las funciones básicas de la aplicación Notas Estándar. Sin embargo, puedes activar algunas funciones de pago del lado del servidor, y Standard Notes te permite hacerlo de forma gratuita. Esto no activará las funciones premium del lado del cliente, como las Supernotas y las Etiquetas anidadas. Para activarlas, puedes adquirir una suscripción con grandes descuentos a través del plan sin conexión de Standard Notes.
Tienes que ejecutar el siguiente comando desde el directorio de Standard Notes para activar las funciones Premium del lado del servidor en la aplicación autoalojada.
$ cd ~/standardnotes
$ docker compose exec db sh -c "MYSQL_PWD=\$MYSQL_ROOT_PASSWORD mysql \$MYSQL_DATABASE -e \
'INSERT INTO user_roles (role_uuid , user_uuid) VALUES ((SELECT uuid FROM roles WHERE name=\"PRO_USER\" ORDER BY version DESC limit 1) ,(SELECT uuid FROM users WHERE email=\"EMAIL@ADDR\")) ON DUPLICATE KEY UPDATE role_uuid = VALUES(role_uuid);' \
"
$ docker compose exec db sh -c "MYSQL_PWD=\$MYSQL_ROOT_PASSWORD mysql \$MYSQL_DATABASE -e \
'INSERT INTO user_subscriptions SET uuid=UUID(), plan_name=\"PRO_PLAN\", ends_at=8640000000000000, created_at=0, updated_at=0, user_uuid=(SELECT uuid FROM users WHERE email=\"EMAIL@ADDR\"), subscription_id=1, subscription_type=\"regular\";' \
"
Recarga la aplicación web, y las funciones de pago deberían estar activadas para tu cuenta. Para activar las funciones del lado del cliente, abre las preferencias de tu aplicación, elige el menú General >> Activación sin conexión e introduce el código de activación que obtuviste al adquirir el plan sin conexión.
Paso 12 – Configurar el servidor para la subida de archivos
La subida de archivos es una función de pago de Standard Notes y no funcionará sin adquirir el plan sin conexión. Hemos habilitado la URL API personalizada para la subida de archivos. Pero seguirán sin funcionar. Para que funcionen, necesitamos dar los permisos adecuados al directorio de subidas. Las subidas se almacenan en el directorio ~/standardnotes/uploads. Ejecuta los siguientes comandos para cambiar los permisos.
$ sudo chmod -R 775 data $ sudo chmod -R 755 uploads $ sudo chown -R 1001.1001 uploads
Ahora, Standard Notes establece cero como límite de subida para cada usuario. Esto significa que ningún usuario puede subir archivos a menos que se le asigne una cuota manualmente. Por tanto, el último paso para que funcione la subida de archivos es habilitar la cuota de archivos para la cuenta de usuario de pago. Podemos hacerlo realizando una consulta SQL dentro del contenedor de base de datos.
Accede al intérprete de comandos MySQL dentro del contenedor Base de datos.
$ docker exec -it db-standalone mysql -u std_notes_user -p Enter password:
Una vez dentro del intérprete de comandos MySQL, comprobemos la lista de bases de datos.
mysql > show databases; +--------------------+ | Database | +--------------------+ | information_schema | | performance_schema | | standard_notes_db | +--------------------+ 3 rows in set (0.01 sec)
Cambia a la base de datos Notas Estándar.
mysql > use standard_notes_db;
Ejecuta el siguiente comando SQL para añadir una cuota de archivo de 10 GB al usuario de pago activado anteriormente.
mysql> INSERT INTO subscription_settings(uuid, name, value, created_at, updated_at, user_subscription_uuid) VALUES (UUID(), "FILE_UPLOAD_BYTES_LIMIT", 10737418240, FLOOR(UNIX_TIMESTAMP(NOW(6))*1000000), FLOOR(UNIX_TIMESTAMP(NOW(6))*1000000), (SELECT us.uuid FROM user_subscriptions us INNER JOIN users u ON us.user_uuid=u.uuid WHERE u.email="[email protected]"));
Aquí 10737418240 se refiere a bytes totales que se traducen a 10GB. Puedes modificar este número a lo que necesites.
Sal del intérprete de comandos MySQL y del contenedor de base de datos.
mysql > exit
Paso 13 – Actualizar el Servidor Standard Notes y la aplicación web
El primer paso para actualizar el Servidor Standard Notes es detener y eliminar los contenedores existentes.
$ cd ~/standardnotes $ docker compose stop $ docker compose remove --orphans
Obtén la última versión de .env, localstack_bootstrap.sh y los archivos de composición de Docker del repositorio de GitHub. Haz los cambios necesarios y sustituye los archivos existentes por los actualizados.
Inicia de nuevo los contenedores del servidor.
$ docker compose up -d
Tu servidor de sincronización actualizado ya se está ejecutando.
Cambia al directorio de la aplicación web.
$ cd ~/snotes-app
Cambia al directorio raíz de la aplicación web.
$ cd packages/web
Detén el proceso existente.
$ pm2 stop api
Vuelve al directorio principal de la aplicación.
$ cd ~/snotes-app
Extrae los últimos cambios del repositorio de GitHub.
$ git pull
Vuelve al directorio web.
$ cd packages/web
Inicia el proceso.
$ pm2 start api
Tu aplicación web debería estar actualizada.
Conclusión
Con esto concluye nuestro tutorial sobre la instalación y configuración del servidor Standard Notes en una máquina Rocky Linux 9. Si tienes alguna pregunta, publícala en los comentarios a continuación.