HowtoForge

Tutoriales de Linux

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 dominio snotes-files.example.com para el servidor de archivos y snotes-web.example.com para 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.

Standard Notes URL home

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.

Notas estándar Crear cuenta

Haz clic en el botón Siguiente para continuar. Se te pedirá de nuevo tu contraseña.

Aplicación Web de Notas Estándar Confirmar 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.

También te podría gustar...