Come installare Sails.js Framework con Nginx su Ubuntu 22.04
Su questa pagina
- Prerequisiti
- Passaggio 1: configurazione del firewall
- Passaggio 2 - Installa Node Version Manager (NVM)
- Passaggio 3 - Installa Node.js
- Passaggio 4 - Installa Sails.js
- Passaggio 5: crea un'applicazione demo
- Passaggio 6 - Crea un file di servizio systemd
- Passaggio 7 - Installa Nginx
- Passaggio 8 - Installa SSL
- Passaggio 9 - Configura Nginx
- Passaggio 10 - Accedi all'app Sails.js
- Conclusione
Sails.js è un framework JavaScript MVC full-stack per Node.js. Viene utilizzato per lo sviluppo di applicazioni Web in tempo reale. È ispirato a Ruby on Rails, ma con supporto per API basate sui dati e architettura scalabile e orientata ai servizi. Utilizza un potente Object-Relational Mapping (ORM) chiamato Waterline che ne consente l'utilizzo con database come MySQL, PostgreSQL, MongoDB, Redis, ecc.
In questo tutorial imparerai come installare il framework Sails.js per creare un'app di test e distribuirla utilizzando il server Nginx insieme a Lets Encrypt SSL su un server Ubuntu 22.04.
Prerequisiti
-
A server running Ubuntu 22.04.
-
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
sails.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 ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) 80/tcp (v6) ALLOW Anywhere (v6) 443 (v6) ALLOW Anywhere (v6)
Passaggio 2: installare Node Version Manager (NVM)
Installeremo Node utilizzando l'applicazione Node Version Manager (nvm). Puoi utilizzare NVM per installare più versioni di Node e passare da una all'altra con facilità. Eseguire il seguente comando per scaricare e installare NVM.
Controlla l'ultima versione di NVM dalla pagina delle versioni di Github. Al momento della stesura di questo tutorial, v0.39.1 è l'ultima versione disponibile.
$ NVMVERSION=0.39.1 $ curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/$NVMVERSION/install.sh | bash
Aggiorna il terminale.
$ source ~/.bashrc
Verificare che NVM sia installato.
$ command -v nvm
Dovresti vedere il seguente output in caso di installazione riuscita.
nvm
Passaggio 3: installa Node.js
Installeremo l'ultima versione della versione LTS (supporto a lungo termine) di Node.js. Esegui il seguente comando per farlo.
$ nvm install --lts
Verifica che Node.js sia installato.
$ node --version v16.17.0
Passo 4 - Installa Sails.js
Ora che Node.js è installato, è il momento di installare il framework Sails.js. Eseguire il seguente comando per installarlo a livello globale.
$ npm -g install sails
Verificare che il framework Sails.js sia installato.
$ sails --version 1.5.3
Puoi controllare altri comandi disponibili con l'applicazione a riga di comando sails usando il flag --help.
$ sails --help
Riceverai il seguente output.
Usage: sails [command]
Options:
-v, --version output the version number
-h, --help output usage information
Commands:
version
lift|l [options]
new [options] [path_to_new_app]
generate
upgrade
migrate
console|c [options]
www
debug (for Node v5 and below)
inspect (for Node v6 and above)
run
test
lint
deploy
debug-console|dc
help [command]
Passaggio 5: creare un'applicazione demo
Eseguire il comando seguente per generare un'applicazione demo.
$ sails new howtoforge-app
Otterrai le seguenti due opzioni.
Choose a template for your new Sails app: 1. Web App · Extensible project with auth, login, & password recovery 2. Empty · An empty Sails app, yours to configure (type "?" for help, or <CTRL+C> to cancel)
Puoi digitare 1 per andare con un modello predefinito per un'applicazione completa con autenticazione, una pagina di accesso e una funzione di recupero della password. Se vuoi iniziare con una tabula rasa, vai con l'opzione 2.
Andremo con l'opzione 1. Dovrai attendere alcuni minuti per il completamento del processo.
? 1 info: Installing dependencies... Press CTRL+C to cancel. (to skip this step in the future, use --fast) info: Created a new Sails app `howtoforge-app`!
Passare alla directory di lavoro dell'applicazione appena creata. Il nome della directory è lo stesso dell'applicazione.
$ cd howtoforge-app
Controlla l'elenco delle cartelle. La cartella conterrà tutti i file e i pacchetti essenziali installati per iniziare con l'applicazione.
$ ls total 944 drwxrwxr-x 9 navjot navjot 4096 Aug 23 07:14 . drwxr-x--- 8 navjot navjot 4096 Aug 23 07:13 .. drwxrwxr-x 8 navjot navjot 4096 Aug 23 07:13 api -rw-rw-r-- 1 navjot navjot 1841 Aug 23 07:13 app.js drwxrwxr-x 8 navjot navjot 4096 Aug 23 07:13 assets drwxrwxr-x 4 navjot navjot 4096 Aug 23 07:13 config -rw-rw-r-- 1 navjot navjot 1046 Aug 23 07:13 .editorconfig -rw-rw-r-- 1 navjot navjot 44 Aug 23 07:13 .eslintignore -rw-rw-r-- 1 navjot navjot 4228 Aug 23 07:13 .eslintrc -rw-rw-r-- 1 navjot navjot 3531 Aug 23 07:13 .gitignore -rw-rw-r-- 1 navjot navjot 669 Aug 23 07:13 Gruntfile.js -rw-rw-r-- 1 navjot navjot 709 Aug 23 07:13 .htmlhintrc -rw-rw-r-- 1 navjot navjot 2162 Aug 23 07:13 .lesshintrc drwxrwxr-x 510 navjot navjot 20480 Aug 23 07:14 node_modules -rw-rw-r-- 1 navjot navjot 369 Aug 23 07:13 .npmrc -rw-rw-r-- 1 navjot navjot 6151 Aug 23 07:13 package.json -rw-rw-r-- 1 navjot navjot 854958 Aug 23 07:14 package-lock.json -rw-rw-r-- 1 navjot navjot 1732 Aug 23 07:13 README.md -rw-rw-r-- 1 navjot navjot 123 Aug 23 07:13 .sailsrc drwxrwxr-x 2 navjot navjot 4096 Aug 23 07:13 scripts drwxrwxr-x 4 navjot navjot 4096 Aug 23 07:13 tasks drwxrwxr-x 5 navjot navjot 4096 Aug 23 07:13 views
Eseguire l'applicazione Sails. Il seguente comando avvierà l'applicazione in modalità di sviluppo. Sails.js utilizza lo strumento Grunt per monitorare la cartella /assets. Se modifichi qualcosa in quella cartella, si rifletterà automaticamente nel browser. Puoi anche modificare i tuoi file di visualizzazione senza riavviare Sails perché i modelli non sono memorizzati nella cache.
$ sails lift
Otterrai il seguente output al corretto avvio dell'applicazione.
info: Starting app... info: Initializing project hook... (`api/hooks/custom/`) info: Initializing `apianalytics` hook... (requests to monitored routes will be logged!) info: ·• Auto-migrating... (alter) info: Hold tight, this could take a moment. info: ? Auto-migration complete. debug: Running v0 bootstrap script... (looks like this is the first time the bootstrap has run on this computer) info: info: .-..-. info: info: Sails <| .-..-. info: v1.5.3 |\ info: /|.\ info: / || \ info: ,' |' \ info: .-'.-==|/_--' info: `--'-------' info: __---___--___---___--___---___--___ info: ____---___--___---___--___---___--___-__ info: info: Server lifted in `/home/navjot/howtoforge-app` info: To shut down Sails, press <CTRL> + C at any time. info: Read more at https://sailsjs.com/support. debug: ------------------------------------------------------- debug: :: Tue Aug 23 2022 09:01:32 GMT+0000 (Coordinated Universal Time) debug: Environment : development debug: Port : 1337 debug: -------------------------------------------------------
Sails.js espone la tua app alla porta 1337. Dovrai aprire la porta per accedere all'applicazione. Avvia un altro terminale sul tuo server ed esegui il seguente comando per aprire la porta.
$ sudo ufw allow 1337
Avvia l'URL http:// nel tuo browser. Otterrai la pagina seguente.
Premi Ctrl + C sul terminale per chiudere l'applicazione Sails.
Passaggio 6: creare un file di servizio systemd
In questo momento, l'app Sails funziona solo se il terminale è attivo. Per mantenerlo persistente durante i riavvii, dobbiamo creare un file di servizio systemd per Sails.
Crea e apri il file howtoforge-app.service per la modifica.
$ sudo nano /etc/systemd/system/howtoforge-app.service
Incolla il seguente codice al suo interno.
[Unit] After=network.target [Service] Type=simple User=navjot WorkingDirectory=/home/navjot/howtoforge-app ExecStart=/home/navjot/.nvm/versions/node/v16.17.0/bin/node app.js Restart=on-failure [Install] WantedBy=multi-user.target
Sostituire i valori per le variabili User, WorkingDirectory e ExecStart con il nome utente del sistema, il percorso dell'applicazione e il percorso dell'applicazione del nodo. Per individuare il percorso di Node.js, puoi utilizzare il seguente comando.
$ which node /home/navjot/.nvm/versions/node/v16.17.0/bin/node
Utilizziamo Node.js invece dell'applicazione Sails CLI perché è più semplice configurarla ed eseguirla tramite uno script di sistema. Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Ricarica il demone di sistema per applicare le modifiche.
$ sudo systemctl daemon-reload
Avvia il servizio Sails.js e abilitalo per l'avvio all'avvio del sistema.
$ sudo systemctl enable howtoforge-app --now
Controlla lo stato del servizio.
$ sudo systemctl status howtoforge-app
? howtoforge-app.service - Sails.js Howtoforge App
Loaded: loaded (/etc/systemd/system/howtoforge-app.service; enabled; vendor preset: enabled)
Active: active (running) since Tue 2022-08-23 11:52:58 UTC; 5s ago
Main PID: 15385 (node)
Tasks: 22 (limit: 2237)
Memory: 123.8M
CPU: 3.894s
CGroup: /system.slice/howtoforge-app.service
??15385 /home/navjot/.nvm/versions/node/v16.17.0/bin/node app.js
??15392 grunt "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ">
Aug 23 11:53:01 sails node[15385]: info: ____---___--___---___--___---___--___-__
Aug 23 11:53:01 sails node[15385]: info:
Aug 23 11:53:01 sails node[15385]: info: Server lifted in `/home/navjot/howtoforge-app`
Aug 23 11:53:01 sails node[15385]: info: To shut down Sails, press <CTRL> + C at any time.
Aug 23 11:53:01 sails node[15385]: info: Read more at https://sailsjs.com/support.
Aug 23 11:53:01 sails node[15385]: debug: -------------------------------------------------------
Aug 23 11:53:01 sails node[15385]: debug: :: Tue Aug 23 2022 11:53:01 GMT+0000 (Coordinated Universal Time)
Aug 23 11:53:01 sails node[15385]: debug: Environment : development
Aug 23 11:53:01 sails node[15385]: debug: Port : 1337
Aug 23 11:53:01 sails node[15385]: debug: -------------------------------------------------------
Puoi verificare il servizio aprendo l'URL http:// nel tuo browser.
Passaggio 7: 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 8: 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 $ sudo snap refresh 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 sails.example.com
Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/sails.example.com sul tuo server.
Genera un certificato di gruppo Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Apri il file /etc/letsencrypt/renewal/sails.example.com.conf per la modifica.
$ sudo nano /etc/letsencrypt/renewal/sails.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 immettendo Y quando richiesto.
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 9: 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 immettendo Y quando richiesto.
Crea e apri il file /etc/nginx/conf.d/sails.conf per la modifica.
$ sudo nano /etc/nginx/conf.d/sails.conf
Incolla il seguente codice al suo interno. Sostituisci sails.example.com con il tuo nome di dominio. Assicurati che il valore di client_max_body_size sia impostato su 10 MB. Cambialo in base alle tue esigenze.
upstream backend {
server 127.0.0.1:1337;
keepalive 32;
}
server {
listen 80 default_server;
server_name sails.example.com;
return 301 https://$server_name$request_uri;
}
server {
listen 443 ssl http2;
server_name sails.example.com;
http2_push_preload on; # Enable HTTP/2 Server Push
ssl_certificate /etc/letsencrypt/live/sails.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/sails.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/sails.example.com/chain.pem;
ssl_session_timeout 1d;
# Enable TLS versions (TLSv1.3 is required upcoming HTTP/3 QUIC).
ssl_protocols TLSv1.2 TLSv1.3;
# Enable TLSv1.3's 0-RTT. Use $ssl_early_data when reverse proxying to
# prevent replay attacks.
#
# @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
ssl_early_data on;
ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
ssl_prefer_server_ciphers on;
ssl_session_cache shared:SSL:50m;
# OCSP Stapling ---
# fetch OCSP records from URL in ssl_certificate and cache them
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
add_header X-Early-Data $tls1_3_early_data;
access_log /var/log/nginx/sails.access.log main;
error_log /var/log/nginx/sails.error.log;
location / {
client_max_body_size 10M;
proxy_set_header Host $http_host;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header X-Frame-Options SAMEORIGIN;
proxy_buffering off;
proxy_http_version 1.1;
proxy_pass http://backend;
}
}
# This block is useful for debugging TLS v1.3. Please feel free to remove this
# and use the `$ssl_early_data` variable exposed by NGINX directly should you
# wish to do so.
map $ssl_early_data $tls1_3_early_data {
"~." $ssl_early_data;
default "";
}
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Verifica la configurazione di Nginx.
$ sudo nginx -t
Riavvia il server Nginx.
$ sudo systemctl restart nginx
Passaggio 10: accedi all'app Sails.js
Avvia l'URL https://sails.example.com nel tuo browser e verrai accolto con la home page di Sails.
Fare clic sul pulsante Iscriviti in alto a destra per creare un nuovo account.
Inserisci i dettagli del tuo account e fai clic sul pulsante Crea account per terminare.
Verrai immediatamente portato alla schermata di benvenuto.
Ora puoi iniziare a utilizzare l'applicazione per creare un'applicazione dinamica con autenticazione utente, supporto database e un gateway di pagamento integrato basato su Stripe.
Conclusione
Questo completa il tutorial in cui hai imparato come installare il framework Sails.js e creato un'applicazione demo. Hai anche imparato come configurare un servizio systemd per esso e utilizzare il server proxy Nginx con Lets Encrypt per avviare un'applicazione Web sicura. Se hai domande, pubblicale nei commenti qui sotto.