Recherche de site Web

Comment installer le serveur Notes standard sur Rocky Linux 9

Sur cette page

  1. Conditions préalables
  2. Étape 1 - Configurer le pare-feu
  3. Étape 2 - Installer Docker et Docker Compose
  4. Étape 3 - Installer Nginx
  5. Étape 4 - Installer SSL
  6. Étape 5 - Téléchargez et configurez les notes standard
  7. Étape 6 - Démarrez le serveur Notes standard

  8. Étape 7 - Installer l'application Web Notes standard

    1. Installer Git
    2. Installer NodeJS
    3. Installer le fil
    4. Installez le gestionnaire de packages PM2.
    5. Installez l'application Web
  9. Étape 8 - Configurer Nginx
  10. Étape 9 - Configurer SELinux
  11. Étape 10 - Utiliser les notes standard
  12. Étape 11 - Activer les fonctionnalités payantes
  13. Étape 12 - Configurer le serveur pour le téléchargement de fichiers
  14. Étape 13 - Mettre à niveau le serveur Notes standard et l'application Web
  15. Conclusion

Standard Notes est une application de notes open source et entièrement cryptée. Il propose des forfaits gratuits et payants et offre à la fois un hébergement cloud et la possibilité de l'héberger sur votre serveur. Vous pouvez utiliser votre serveur pour synchroniser les notes stockées entre différents appareils. Standard Notes propose des applications pour tous les systèmes d'exploitation de bureau et plates-formes mobiles.

Ce didacticiel vous apprend à auto-héberger votre serveur de notes standard sur une machine Rocky Linux 9. Vous apprendrez également comment activer gratuitement les forfaits payants sur le serveur et comment activer le téléchargement de fichiers.

Conditions préalables

    Un serveur exécutant Rocky Linux 9 avec au moins 2 Go de RAM.

    Un utilisateur non root avec les privilèges sudo.

    Un nom de domaine complet pointait vers le serveur. Pour notre tutoriel, nous utiliserons le domaine standardnotes.example.com. Vous aurez besoin de deux noms de domaine supplémentaires, un pour le serveur de fichiers et le second pour l'application Web. Nous utiliserons le domaine snotes-files.example.com pour le serveur de fichiers et snotes-web.example.com pour l'application Web.

    Tout est mis à jour.

    $ sudo dnf update

    Peu de packages dont votre système a besoin.

    $ sudo dnf install -y wget nano unzip yum-utils policycoreutils-python-utils

    Certains de ces packages sont peut-être déjà installés sur votre système.

Étape 1 - Configurer le pare-feu

Avant d'installer des packages, la première étape consiste à configurer le pare-feu pour ouvrir les ports pour HTTP et HTTPS. Rocky Linux utilise le pare-feu Firewalld. Vérifiez l'état du pare-feu.

$ sudo firewall-cmd --state
running

Le pare-feu fonctionne avec différentes zones et la zone publique est celle par défaut que nous utiliserons. Listez tous les services et ports actifs sur le pare-feu.

$ sudo firewall-cmd --zone=public --list-all

Il devrait afficher la sortie suivante.

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:

Ouvrez les ports HTTP et HTTPS dans le pare-feu.

$ sudo firewall-cmd --zone=public --add-service=http
$ sudo firewall-cmd --zone=public --add-service=https

Revérifiez l'état du pare-feu.

$ sudo firewall-cmd --zone=public --list-all

Vous devriez voir une sortie similaire.

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:

Rendez toutes les modifications permanentes et rechargez le pare-feu pour activer les modifications.

$ sudo firewall-cmd --runtime-to-permanent
$ sudo firewall-cmd --reload

Étape 2 - Installer Docker et Docker Compose

Installez le référentiel Docker officiel.

$ sudo dnf config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

Installez Docker.

$ sudo dnf install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Activez et exécutez le démon Docker.

$ sudo systemctl enable docker --now

Vérifiez l'état du service 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.

Ajoutez votre utilisateur système au groupe Docker pour éviter d'utiliser sudo pour exécuter des commandes Docker.

$ sudo usermod -aG docker $(whoami)

Connectez-vous à nouveau à votre serveur après vous être déconnecté pour activer la modification.

Vérifiez le changement.

$ groups
navjot wheel docker

Étape 3 - Installer Nginx

Rocky Linux 9 est livré avec une ancienne version de Nginx. Vous devez utiliser le référentiel officiel Nginx pour installer la dernière version.

Créez et ouvrez le fichier /etc/yum.repos.d/nginx.repo pour le modifier.

$ sudo nano /etc/yum.repos.d/nginx.repo

Collez-y le code suivant.

[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

Une fois que vous avez terminé, enregistrez le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque vous y êtes invité. Nous utiliserons la version principale de Nginx et avons donc activé le dépôt mainline dans le fichier ci-dessus en utilisant enabled=1 sous la section mainline au lieu de la version stable. Vous pouvez choisir l'un ou l'autre.

Installez Nginx.

$ sudo dnf install nginx -y

Vérifiez l'installation.

$ nginx -v
nginx version: nginx/1.25.5

Activez et démarrez le service du serveur Nginx.

$ sudo systemctl enable nginx --now

Vérifiez l'état du service.

$ 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.

Étape 4 - Installer SSL

Nous devons installer Certbot pour générer le certificat SSL. Nous utiliserons le programme d'installation du package Snapd pour cela. Étant donné que Rocky Linux n'est pas livré avec, installez le programme d'installation Snapd. Il nécessite le référentiel EPEL (Extra Packages for Enterprise Linux) pour fonctionner.

Installez le référentiel EPEL.

$ sudo dnf install epel-release -y

Installez le package Snapd.

$ sudo dnf install snapd -y

Activez et démarrez le service Snap.

$ sudo systemctl enable snapd --now

Installez le package principal Snap et assurez-vous que votre version de Snapd est à jour.

$ sudo snap install core && sudo snap refresh core

Créez les liens nécessaires au fonctionnement de Snapd.

$ 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

Installez Certbot.

$ sudo snap install --classic certbot

Utilisez la commande suivante pour vous assurer que la commande Certbot peut être exécutée en créant un lien symbolique vers le répertoire /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Vérifiez la version de Certbot.

$ certbot --version
certbot 2.10.0

Exécutez la commande suivante pour générer un certificat SSL.

$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email  -d standardnotes.example.com

La commande ci-dessus téléchargera un certificat dans le répertoire /etc/letsencrypt/live/standardnotes.example.com sur votre serveur.

Nous devons faire de même pour le sous-domaine Files.

$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email  -d snotes-files.example.com

Et enfin, encore une fois pour l’application Web.

$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email  -d snotes-web.example.com

Générez un certificat de groupe Diffie-Hellman.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Vérifiez le service de planification de renouvellement Certbot.

$ systemctl list-timers

Vous trouverez snap.certbot.renew.service comme l'un des services dont l'exécution est planifiée.

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

Effectuez un essai à sec du processus pour vérifier si le renouvellement SSL fonctionne correctement.

$ sudo certbot renew --dry-run

Si vous ne voyez aucune erreur, vous êtes prêt. Votre certificat se renouvellera automatiquement.

Étape 5 - Téléchargez et configurez les notes standard

Assurez-vous que vous êtes dans le répertoire personnel de votre système.

$ cd ~

Créez un répertoire de travail pour Standard Notes Server et accédez-y.

$ mkdir standardnotes
$ cd ~/standardnotes

Téléchargez le fichier d'exemple d'environnement à partir du référentiel GitHub Standard Notes.

$ wget https://raw.githubusercontent.com/standardnotes/server/main/.env.sample

Créez le fichier d'environnement de travail à partir du fichier d'exemple téléchargé.

$ cp .env.sample .env

Vous aurez besoin de trois clés d'authentification et de chiffrement pour configurer le fichier .env. Exécutez la commande suivante pour générer trois clés distinctes et copier leur sortie.

$ openssl rand -hex 32

Vous aurez également besoin d'un mot de passe de base de données fort. Vous pouvez exécuter la commande suivante pour générer un mot de passe de base de données sécurisé.

$ openssl rand -hex 12

Ouvrez le fichier d'environnement pour le modifier.

$ nano .env

Choisissez un mot de passe de base de données fort et ajoutez-le à 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=

Ajoutez les clés générées auparavant et comparez-les aux trois variables dans la section KEYS.

Par défaut, l'enregistrement des utilisateurs est activé. Si vous souhaitez désactiver l'enregistrement des utilisateurs publics sur votre serveur Standard Notes, ajoutez la variable suivante dans le fichier d'environnement. Cependant, ne faites cela qu'après avoir créé votre premier compte sur celui-ci. Si vous utilisez le paramètre au tout début, vous ne pourrez pas utiliser l'application vous-même.

AUTH_SERVER_DISABLE_USER_REGISTRATION=true

Ajoutez la variable suivante pour définir l'URL de vos fichiers Notes standard.

PUBLIC_FILES_SERVER_URL=https://snotes-files.example.com

Le fichier .env complet devrait ressembler à ceci.

######
# 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

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité une fois terminé.

Téléchargez le script d'amorçage Localstack à partir du référentiel GitHub.

$ wget https://raw.githubusercontent.com/standardnotes/server/main/docker/localstack_bootstrap.sh

Donnez au script les autorisations exécutables.

$ chmod +x localstack_bootstrap.sh

Téléchargez le fichier Docker Compose pour le serveur Standard Notes à partir du référentiel GitHub.

$ wget https://raw.githubusercontent.com/standardnotes/server/main/docker-compose.example.yml

Créez un fichier de composition Docker fonctionnel à partir de l'exemple de fichier de composition téléchargé.

$ cp docker-compose.example.yml docker-compose.yml

Ouvrez-le pour le modifier.

$ nano docker-compose.yml

Remplacez la valeur de MYSQL_ROOT_PASSWORD et de MYSQL_PASSWORD par le mot de passe de la base de données que vous avez sélectionné dans le fichier .env précédemment. Votre fichier Docker Compose devrait ressembler à ce qui suit.

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

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité une fois terminé. Ceci conclut le téléchargement et la configuration de la configuration du serveur Notes standard.

Étape 6 - Démarrez le serveur Notes standard

Exécutez la commande suivante pour démarrer le serveur.

$ docker compose up -d

Cette commande prendra quelques minutes. Pendant ce temps, le processus extraira toutes les images Docker pertinentes et créera des conteneurs pour tous les services. Il remplira également la base de données et effectuera les migrations appropriées. L'utilisation du processeur peut augmenter pendant quelques minutes, mais elle devrait bientôt diminuer.

Vous pouvez trouver les journaux du serveur Standard Notes dans le répertoire logs. Vous pouvez vérifier les journaux de processus à l'aide de la commande suivante.

$ tail -f logs/*.log

Appuyez sur Ctrl + C pour quitter les journaux. Vous pouvez vérifier l'état des conteneurs en cours d'exécution à l'aide de l'une des commandes suivantes.

$ docker compose ps
OR
$ docker ps

Vous recevrez un résultat similaire.

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

Vous pouvez vérifier la santé du serveur à l'aide de la commande suivante.

$ curl http://localhost:3000/healthcheck
OK

Standard Notes utilise le port 3000 par défaut. Si vous avez configuré un port différent dans le fichier .env, vous devez le mettre à jour dans la commande ci-dessus.

Étape 7 - Installer l'application Web Notes standard

Vous pouvez soit utiliser l’application Web Standard Notes existante, soit héberger la vôtre. Pour notre didacticiel, nous hébergerons automatiquement l’application Web Standard Notes.

Installer Git

Avant d'aller de l'avant, nous devons installer quelques éléments nécessaires, dont Git. Installez Git.

$ sudo dnf install git -y

Installer NodeJS

L'étape suivante consiste à installer NodeJS. Nous installerons la version Node 18.x LTS pour cela. Exécutez les commandes suivantes pour installer NodeJS.

$ curl -fsSL https://rpm.nodesource.com/setup_18.x | sudo bash -
$ sudo dnf install -y nodejs

Confirmez l'installation.

$ node --version
v18.20.2

Installer le fil

Nous avons également besoin du gestionnaire de packages Yarn. Installez-le à l'aide de Node.

$ sudo npm install --global yarn

Installez le gestionnaire de packages PM2.

Nous avons besoin de PM2 pour nous aider à exécuter l'application Web Standard Notes en tant que service d'arrière-plan.

$ sudo npm install --global pm2

Installez l'application Web

Créez un répertoire pour l'application Web et accédez-y.

$ cd ~
$ mkdir snotes-app
$ cd ~/snotes-app

Téléchargez l'application Notes standard depuis GitHub.

$ git clone https://github.com/standardnotes/app.git .

Utilisez Yarn pour installer les dépendances. Ignorez tous les avertissements.

$ yarn install

Créez les packages pour l'application Web.

$ yarn build:web

Basculez vers le répertoire Web.

$ cd packages/web

Démarrez l'application Web à l'aide de PM2.

$ pm2 start "yarn start" --name api

Vous pouvez vérifier l'état du service à l'aide de la commande suivante.

$ 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 ?
????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????

L'application sera démarrée et est accessible via le port 3001. Nous utiliserons ces informations pour créer une configuration Nginx pour l'application Web.

PM2 ne redémarre pas l'application au redémarrage. Pour ce faire, nous devons générer un script de démarrage.

$ pm2 startup

Vous devriez obtenir un résultat similaire.

[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

Exécutez la commande fournie dans le résultat.

$ sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u navjot --hp /home/navjot

Cela générera et activera un fichier de service systemd.

Enregistrez le processus pour qu'il soit démarré automatiquement au redémarrage.

$ pm2 save

Étape 8 - Configurer Nginx

Ouvrez le fichier /etc/nginx/nginx.conf pour le modifier.

$ sudo nano /etc/nginx/nginx.conf

Ajoutez la ligne suivante avant la ligne include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size 64;

Enregistrez le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque vous y êtes invité.

Créez et ouvrez le fichier /etc/nginx/conf.d/standardnotes.conf pour le modifier.

$ sudo nano /etc/nginx/conf.d/standardnotes.conf

Collez-y le code suivant. Remplacez standardnotes.example.com par votre nom de domaine. Nous avons défini la valeur du client_max_body_size sur 50 Mo. Vous pouvez le modifier selon vos besoins.

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;
}

Enregistrez le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque vous y êtes invité.

Le fichier ci-dessus concerne l’application principale Standard Notes. Ensuite, nous devons configurer un autre fichier pour le sous-domaine Files.

$ sudo nano /etc/nginx/conf.d/files-standardnotes.conf

Collez-y le code suivant. Remplacez snotes-files.example.com par votre nom de domaine. Nous avons fixé la valeur de la variable client_max_body_size à 50 Mo. Vous pouvez le modifier selon vos besoins.

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;
}

Et enfin, nous devons créer un fichier de configuration pour l'application Web.

$ sudo nano /etc/nginx/conf.d/web-standardnotes.conf

Collez-y le code suivant.

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;
}

Vérifiez votre configuration Nginx.

$ sudo nginx -t

Redémarrez le serveur Nginx pour activer les fichiers de configuration.

$ sudo systemctl restart nginx

Étape 9 - Configurer SELinux

Appliquez la stratégie pour autoriser les connexions à des hôtes externes.

$ sudo setsebool -P httpd_can_network_connect 1

Appliquez la stratégie pour autoriser Nginx à donner accès à PostgreSQL.

$ sudo setsebool -P httpd_can_network_connect_db 1

Étape 10 - Utiliser les notes standard

Si vous ouvrez l'URL https://standardnotes.example.com dans votre navigateur, vous devriez voir le résultat suivant.

Cela signifie que votre serveur est opérationnel. Pour utiliser Standard Notes, vous devrez utiliser les applications officielles. Pour notre tutoriel, nous utiliserons leur application web mais la méthode restera la même pour les applications de bureau et mobiles.

Ouvrez l'URL https://snotes-web.example.com pour accéder à l'application Web. Cliquez sur le lien Créer un compte gratuit en bas à gauche de la page et saisissez votre adresse e-mail et votre mot de passe. Cliquez sur le bouton Fonctionnalités avancées, décochez l'option Serveur de synchronisation personnalisé,  et renseignez l'URL https://standardnotes.example.com. la boîte.

Cliquez sur le bouton Suivant pour continuer. Votre mot de passe vous sera à nouveau demandé.

Une fois connecté, vous pouvez commencer à créer des notes et à utiliser l'application.

Étape 11 - Activer les fonctionnalités payantes

Jusqu'à présent, nous avons activé les fonctionnalités de base pour l'application Standard Notes. Cependant, vous pouvez activer certaines fonctionnalités payantes côté serveur, et Standard Notes vous permet de les faire gratuitement. Cela n'activera pas les fonctionnalités premium côté client telles que Super Notes et les balises imbriquées. Vous pouvez acheter un abonnement à prix très réduit via le plan Standard Notes Offline pour les activer.

Vous devez exécuter la commande suivante à partir du répertoire Standard Notes pour activer les fonctionnalités premium côté serveur dans l'application auto-hébergée.

$ 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\";' \
    "

Rechargez l'application Web et les fonctionnalités payantes devraient être activées pour votre compte. Pour activer les fonctionnalités côté client, ouvrez les préférences de votre application, choisissez le menu Général >> Activation hors ligne et saisissez le code d'activation que vous avez obtenu en achetant le forfait hors ligne.

Étape 12 - Configurer le serveur pour le téléchargement de fichiers

Le téléchargement de fichiers est une fonctionnalité payante de Standard Notes et ne fonctionnera pas sans l'achat du forfait hors ligne. Nous avons activé l'URL de l'API personnalisée pour les téléchargements de fichiers. Mais ils ne fonctionneront toujours pas. Pour les faire fonctionner, nous devons accorder les autorisations appropriées au répertoire de téléchargement. Les téléchargements sont stockés dans le répertoire ~/standardnotes/uploads. Exécutez les commandes suivantes pour modifier les autorisations.

$ sudo chmod -R 775 data
$ sudo chmod -R 755 uploads
$ sudo chown -R 1001.1001 uploads

Désormais, Standard Notes fixe zéro comme limite de téléchargement pour chaque utilisateur. Cela signifie qu'aucun utilisateur ne peut télécharger des fichiers à moins de recevoir un quota manuellement. Par conséquent, la dernière étape pour que les téléchargements de fichiers fonctionnent consiste à activer le quota de fichiers pour le compte utilisateur payant. Nous pouvons le faire en effectuant une requête SQL dans le conteneur de base de données.

Connectez-vous au shell MySQL dans le conteneur de base de données.

$ docker exec -it db-standalone mysql -u std_notes_user -p
Enter password:

Une fois dans le shell MySQL, vérifions la liste des bases de données.

mysql > show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| performance_schema |
| standard_notes_db  |
+--------------------+
3 rows in set (0.01 sec)

Basculez vers la base de données Standard Notes.

mysql > use standard_notes_db;

Exécutez la commande SQL suivante pour ajouter un quota de fichiers de 10 Go à l'utilisateur payant activé ci-dessus.

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 "));

Ici, 10737418240 fait référence au nombre total d'octets, ce qui correspond à 10 Go. Vous pouvez modifier ce numéro selon vos besoins.

Quittez le shell MySQL et le conteneur de base de données.

mysql > exit

Étape 13 - Mettre à niveau le serveur Notes standard et l'application Web

La première étape de la mise à niveau du serveur Notes standard consiste à arrêter et à supprimer les conteneurs existants.

$ cd ~/standardnotes
$ docker compose stop
$ docker compose remove --orphans

Récupérez les derniers fichiers .env, localstack_bootstrap.sh et Docker à partir du référentiel GitHub. Apportez les modifications requises et remplacez vos fichiers existants par ceux mis à jour.

Redémarrez les conteneurs du serveur.

$ docker compose up -d

Votre serveur de synchronisation mis à jour est en cours d'exécution.

Basculez vers le répertoire de l'application Web.

$ cd ~/snotes-app

Basculez vers le répertoire racine de l’application Web.

$ cd packages/web

Arrêtez le processus existant.

$ pm2 stop api

Revenez au répertoire principal de l'application.

$ cd ~/snotes-app

Extrayez les dernières modifications du référentiel GitHub.

$ git pull

Revenez dans le répertoire Web.

$ cd packages/web

Démarrez le processus.

$ pm2 start api

Votre application Web doit être mise à jour.

Conclusion

Ceci conclut notre didacticiel sur l'installation et la configuration du serveur Standard Notes sur une machine Rocky Linux 9. Si vous avez des questions, postez-les dans les commentaires ci-dessous.

Articles connexes: