Ricerca nel sito web

Come installare Standard Notes Server su Ubuntu 22.04

Su questa pagina

  1. Prerequisiti
  2. Passaggio 1: configurazione del firewall
  3. Passaggio 2 - Installa Docker e Docker Compose
  4. Passaggio 3 - Installa Nginx
  5. Passaggio 4 - Installa SSL
  6. Passaggio 5 - Scarica e configura le note standard
  7. Passaggio 6 - Avviare Standard Notes Server
  8. Passaggio 7 - Configura Nginx
  9. Passaggio 8 - Usa le note standard
  10. Passaggio 9 - Attiva le funzionalità a pagamento
  11. Passaggio 10 - Configura il server per il caricamento dei file
  12. Passaggio 11: verifica dei caricamenti di file
  13. Conclusione

Standard Notes è un'app per appunti open source e completamente crittografata. Offre sia piani gratuiti che a pagamento e offre sia il cloud hosting che l'opzione per ospitarlo sul tuo server. Puoi utilizzare il tuo server per sincronizzare le note memorizzate tra diversi dispositivi. Standard Notes offre app per tutti i sistemi operativi desktop e piattaforme mobili.

In questo tutorial imparerai come ospitare autonomamente il tuo server di note standard su una macchina Ubuntu 22.04. Imparerai anche come attivare le funzionalità del piano a pagamento e i caricamenti di file sulla tua istanza self-hosted.

Prerequisiti

  • A server running Ubuntu 22.04 with a minimum of 2 GB of RAM.

  • A non-root user with sudo privileges.

  • The Uncomplicated Firewall(UFW) is enabled and running.

  • A Fully Qualified domain name pointed to the server. For our tutorial, we will be using the domain standardnotes.example.com. You will need another domain name for your file server. We will be using the domain snotes-files.example.com.

  • Everything is updated. 

    $ sudo apt update && sudo apt upgrade

Passaggio 1: configurare il firewall

Il primo passo prima di installare qualsiasi pacchetto è configurare il firewall per consentire le connessioni HTTP e HTTPS.

Controlla lo stato del firewall.

$ sudo ufw status

Dovresti vedere qualcosa di simile al seguente.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)

Consenti porte HTTP e HTTPs.

$ sudo ufw allow http
$ sudo ufw allow https

Controlla di nuovo lo stato per confermare.

$ sudo ufw status
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443/tcp                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443/tcp (v6)               ALLOW       Anywhere (v6)

Passaggio 2: installa Docker e Docker Compose

Aggiungi la chiave GPG ufficiale di Dockers.

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg

Eseguire il comando seguente per aggiungere il repository Docker.

$ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Aggiorna il sistema per includere il repository Docker.

$ sudo apt update

Installa Docker.

$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Questo tutorial utilizzerà il plug-in Docker Compose v2 invece del vecchio binario legacy. Pertanto, il comando per eseguirlo è cambiato da docker-compose a docker compose e questo si riflette qui.

Docker viene eseguito con privilegi elevati, quindi dovrai utilizzare sudo frequentemente per eseguire i comandi. L'opzione migliore è aggiungere il tuo account utente Linux al gruppo utenti docker.

$ sudo usermod -aG docker ${USER}

La variabile $ {USER} preleva l'account di sistema attualmente connesso. Se non hai effettuato l'accesso con l'utente a cui desideri concedere i privilegi, sostituisci $ {USER} con il nome utente.

Per richiedere la nuova appartenenza al gruppo, disconnettersi dal server e riconnettersi oppure utilizzare il seguente comando. Verrà richiesta la password dell'utente.

$ su - $(USER)

Passaggio 3: installa Nginx

Ubuntu 22.04 viene fornito con una versione precedente di Nginx. Per installare l'ultima versione, devi scaricare il repository Nginx ufficiale.

Importa la chiave di firma Nginxs.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Aggiungi il repository per la versione stabile di Nginxs.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list

Aggiorna i repository di sistema.

$ sudo apt update

Installa Nginx.

$ sudo apt install nginx

Verificare l'installazione.

$ nginx -v
nginx version: nginx/1.22.0

Passaggio 4: installa SSL

Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot usando il repository Ubuntus o prendere l'ultima versione usando lo strumento Snapd. Useremo la versione Snapd.

Ubuntu 22.04 viene fornito con Snapd installato per impostazione predefinita. Esegui i seguenti comandi per assicurarti che la tua versione di Snapd sia aggiornata.

$ sudo snap install core

Installa Cerbot.

$ sudo snap install --classic certbot

Utilizzare il seguente comando per assicurarsi che il comando Certbot possa essere eseguito creando un collegamento simbolico alla directory /usr/bin.

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

Eseguire il seguente comando per generare un certificato SSL.

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

Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/standardnotes.example.com sul tuo server.

Dobbiamo fare lo stesso per il sottodominio File.

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

Genera un certificato di gruppo Diffie-Hellman.

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

Apri il file /etc/letsencrypt/renewal/standardnotes.example.com.conf per la modifica.

$ sudo nano /etc/letsencrypt/renewal/standardnotes.example.com.conf

Incolla il seguente codice in fondo.

pre_hook = systemctl stop nginx
post_hook = systemctl start nginx

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Ripeti lo stesso passaggio per il sottodominio dei file modificando il file /etc/letsencrypt/renewal/snotes-files.example.com.conf.

Abbiamo generato il certificato SSL utilizzando l'opzione standalone di Certbot. Esegue il suo server Web per creare il certificato, il che significa che Nginx dovrebbe essere spento durante il rinnovo. I comandi pre_hook e post_hook vengono eseguiti prima e dopo il rinnovo per arrestare e riavviare automaticamente il server Nginx, quindi non richiedono alcun intervento manuale.

Per verificare se il rinnovo SSL funziona correttamente, eseguire un'esecuzione a secco del processo.

$ sudo certbot renew --dry-run

Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.

Passaggio 5: scarica e configura le note standard

Assicurati di essere nella home directory del tuo sistema.

$ cd ~

Clona il repository Standard Notes Standalone.

$ git clone --single-branch --branch main https://github.com/standardnotes/standalone.git

Passa alla directory scaricata.

$ cd standalone

Creare i file di configurazione predefiniti per il server.

$ ./server.sh setup

Questo creerà i file di ambiente predefiniti che dobbiamo configurare. Devi generare sei diverse chiavi segrete. Utilizzare i seguenti comandi per generarli.

$ openssl rand -hex 32

Per prima cosa, dobbiamo modificare il file .env nella cartella principale. Aprilo per la modifica.

$ nano .env

Modificare i valori delle seguenti variabili.

NODE_ENV=production
..
AUTH_JWT_SECRET=c0f5bcf6f0f0dcca5b9078c3095e4255a055dfd6376b376733af0e50483cc629
..
DB_USERNAME=std_notes_user
DB_PASSWORD=changeme123
..
VALET_TOKEN_SECRET=977c978ca1d5ea22fe2fda65058905b191f724e33db6e47d0a41e034a082cb3b
..
FILES_SERVER_URL=https://snotes-files.example.com

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Successivamente, apri il file docker/auth.env.

$ nano  docker/auth.env

Modificare i valori delle seguenti variabili.

JWT_SECRET=54deb1b0b2499e8d875b0d5266dabef9003e13c1787a959a94e339363c10e56e
LEGACY_JWT_SECRET=c36aae01803a616213f22422b6d3f998a2beb2cb53af8b95bf578a8a3d046cec
..
PSEUDO_KEY_PARAMS_KEY=ea09d3f9122b49c653524cd2285a45fee88beb94f9b76d4d25420b521b080fcd
..
ENCRYPTION_SERVER_KEY=04decf379fbe3bb48cf95dbb5997031418b308e724a25d88cb0b2ed6da725efe

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Passaggio 6: avviare il server Notes standard

Eseguire il seguente comando per avviare il server.

$ ./server.sh start

Questo comando richiederà alcuni minuti per essere completato. Durante questo periodo, il processo estrarrà tutte le immagini Docker pertinenti e creerà contenitori per tutti i servizi. Popolerà anche il database ed eseguirà le migrazioni appropriate.

È possibile controllare i log per il processo utilizzando il seguente comando.

$ ./server.sh logs

Premi Ctrl + C per uscire dai registri. Puoi controllare lo stato dei contenitori in esecuzione utilizzando il seguente comando.

$ ./server.sh status

Riceverai un output simile.

Services State:
NAME                                  COMMAND                  SERVICE                    STATUS              PORTS
api-gateway-standalone                "./wait-for.sh auth …"   api-gateway                running             0.0.0.0:3000->3000/tcp, :::3000->3000/tcp
auth-standalone                       "./wait-for.sh db 33…"   auth                       running
auth-worker-standalone                "./wait-for.sh db 33…"   auth-worker                running
cache-standalone                      "docker-entrypoint.s…"   cache                      running             6379/tcp
db-standalone                         "docker-entrypoint.s…"   db                         running             3306/tcp
files-standalone                      "./wait-for.sh db 33…"   files                      running             0.0.0.0:3125->3000/tcp, :::3125->3000/tcp
syncing-server-js-standalone          "./wait-for.sh db 33…"   syncing-server-js          running
syncing-server-js-worker-standalone   "./wait-for.sh db 33…"   syncing-server-js-worker   running

Puoi controllare lo stato del server usando il seguente comando.

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

Standard Notes utilizza la porta 3000 per impostazione predefinita. Se hai configurato una porta diversa nel file .env, dovresti aggiornarla nel comando precedente.

Passaggio 7: configurare Nginx

Apri il file /etc/nginx/nginx.conf per la modifica.

$ sudo nano /etc/nginx/nginx.conf

Aggiungere la riga seguente prima della riga include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Crea e apri il file /etc/nginx/conf.d/standardnotes.conf per la modifica.

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

Incolla il seguente codice al suo interno. Sostituisci standardnotes.example.com con il tuo nome di dominio. Abbiamo impostato il valore di client_max_body_size su 50 MB. Puoi cambiarlo secondo le tue esigenze.

server {

    listen 443 ssl http2;
    listen [::]:443 ssl http2;

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

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Il file sopra è per l'applicazione principale di Standard Notes. Successivamente, dobbiamo configurare un altro file per il sottodominio File.

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

Incolla il seguente codice al suo interno. Sostituisci snotes-files.example.com con il tuo nome di dominio. Abbiamo impostato il valore della variabile client_max_body_size su 50 MB. Puoi cambiarlo secondo le tue esigenze.

server {

    listen 443 ssl http2;
    listen [::]:443 ssl http2;

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

Verifica la configurazione di Nginx.

$ sudo nginx -t

Riavvia il server Nginx per abilitare i file di configurazione.

$ sudo systemctl restart nginx

Passaggio 8: utilizzare le note standard

Se apri l'URL https://standardnotes.example.com nel tuo browser, dovresti vedere il seguente output.

Ciò significa che il tuo server è attivo e funzionante. Per utilizzare Standard Notes, dovrai utilizzare le app ufficiali. Per il nostro tutorial, utilizzeremo la loro app Web, ma il metodo rimarrà lo stesso per le app desktop e mobili.

Apri l'URL https://app.standardnotes.com per accedere all'app web. Fai clic sul link Crea account gratuito in basso a sinistra nella pagina e inserisci il tuo indirizzo e-mail e la password. Fai clic sul pulsante Funzionalità avanzate e deseleziona l'opzione Server di sincronizzazione personalizzato e inserisci l'URL https://standardnotes.example.com nella casella.

Una volta effettuato l'accesso, puoi iniziare a creare note e utilizzare l'applicazione.

Passaggio 9: abilita le funzionalità a pagamento

Finora, abbiamo abilitato le funzionalità di base per l'applicazione Standard Notes. L'applicazione offre alcune funzionalità avanzate come più formati di note, archiviazione cloud crittografata, cronologia delle revisioni più lunga e altro ancora.

Per l'applicazione ospitata nel cloud, puoi pagare direttamente per abilitare le funzionalità avanzate. Ma per l'applicazione self-hosted, non puoi pagare per le funzionalità avanzate poiché l'applicazione di pagamento non funziona. Puoi donarli però. Tuttavia, per abilitare le funzionalità a pagamento in un'applicazione self-hosted, è necessario eseguire il seguente comando dalla directory Standard Notes.

$ cd ~/standardnotes
$ bash ./server.sh create-subscription

Ricarica l'applicazione web e le funzionalità a pagamento dovrebbero essere attivate per il tuo account.

Passaggio 10: configurare il server per il caricamento dei file

Il caricamento di file è una funzione a pagamento di Standard Notes. Abbiamo abilitato l'URL API personalizzato per i caricamenti di file. Ma continueranno a non funzionare. Per farli funzionare, dobbiamo dare le autorizzazioni appropriate alla directory dei caricamenti. Gli upload vengono archiviati nella directory ~/standardnotes/data/uploads. Eseguire i seguenti comandi per modificare le autorizzazioni.

$ chmod -R 775 data
$ mkdir -p data/uploads
$ sudo chmod -R 755 data/uploads
$ sudo chown -R 1001.1001 data/uploads

Ora, Standard Notes imposta zero come limite di caricamento per ogni utente. Significa che nessun utente può caricare file a meno che non venga assegnata manualmente una quota. Pertanto, il passaggio finale per far funzionare i caricamenti di file è abilitare la quota di file per l'account utente a pagamento. Possiamo farlo eseguendo una query SQL all'interno del contenitore del database.

Accedi alla shell MySQL all'interno del contenitore del database.

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

Una volta all'interno della shell MySQL, controlliamo l'elenco dei database.

mysql > show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| standard_notes_db  |
+--------------------+
2 rows in set (0.00 sec)

Passa al database Standard Notes.

mysql > use standard_notes_db;

Esegui il seguente comando SQL per aggiungere una quota di file di 10 GB al pagamento attivato dall'utente sopra.

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

Qui 10737418240 si riferisce ai byte totali che si traducono in 10 GB. Puoi modificare questo numero in qualsiasi cosa ti serva.

Uscire dalla shell MySQL e dal contenitore del database.

mysql > exit

Passaggio 11: test dei caricamenti di file

Accedi all'app Web Standard Notes e fai clic sull'icona dell'allegato nella riga superiore.

Fare clic sul pulsante Carica file e selezionare il file che si desidera caricare. Il file verrà caricato correttamente e puoi vederlo elencato facendo nuovamente clic sull'icona.

Fare clic sui tre punti accanto al nome del file per visualizzare ulteriori opzioni relative al file.

Fare clic sul collegamento Allega alla nota per aggiungere l'immagine alla nota. Le restanti opzioni sono autoesplicative.

Conclusione

Questo conclude il nostro tutorial sull'installazione e la configurazione del server Standard Notes su una macchina Ubuntu 22.04. Se hai domande, pubblicale nei commenti qui sotto.