So installierst du das Sails.js Framework mit Nginx auf Ubuntu 22.04
Sails.js ist ein Full-Stack MVC JavaScript Framework für Node.js. Es wird für die Entwicklung von Echtzeit-Webanwendungen verwendet. Es ist von Ruby on Rails inspiriert, unterstützt aber datengesteuerte APIs und eine skalierbare, serviceorientierte Architektur. Es nutzt ein leistungsfähiges Object-Relational Mapping (ORM) namens Waterline, das die Verwendung mit Datenbanken wie MySQL, PostgreSQL, MongoDB, Redis usw. ermöglicht.
In diesem Lernprogramm lernst du, wie du das Sails.js-Framework installierst, um eine Testapplikation zu erstellen und sie mit dem Nginx-Server und Let’s Encrypt SSL auf einem Ubuntu 22.04-Server einzusetzen.
Voraussetzungen
- Ein Server mit Ubuntu 22.04.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Die Uncomplicated Firewall (UFW) ist aktiviert und läuft.
- Ein Fully Qualified Domain Name, der auf den Server zeigt. Für unser Tutorial werden wir die Domain
sails.example.comverwenden. - Alles ist auf dem neuesten Stand.
$ sudo apt update && sudo apt upgrade
Schritt 1 – Firewall konfigurieren
Der erste Schritt vor der Installation der Pakete besteht darin, die Firewall so zu konfigurieren, dass HTTP- und HTTPS-Verbindungen zugelassen werden.
Überprüfe den Status der Firewall.
$ sudo ufw status
Du solltest etwas wie das Folgende sehen.
Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6)
Erlaube HTTP- und HTTPs-Ports.
$ sudo ufw allow http $ sudo ufw allow https
Überprüfe den Status zur Bestätigung noch einmal.
$ 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)
Schritt 2 – Node Version Manager (NVM) installieren
Wir werden Node mit der Anwendung Node Version Manager (nvm) installieren. Mit dem NVM kannst du mehrere Versionen von Node installieren und ganz einfach zwischen ihnen wechseln. Führe den folgenden Befehl aus, um NVM herunterzuladen und zu installieren.
Die neueste Version von NVM findest du auf der Github-Releaseseite. Zum Zeitpunkt der Erstellung dieses Tutorials ist v0.39.1 die neueste verfügbare Version.
$ NVMVERSION=0.39.1 $ curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/$NVMVERSION/install.sh | bash
Aktualisiere das Terminal.
$ source ~/.bashrc
Überprüfe, ob NVM installiert ist.
$ command -v nvm
Bei erfolgreicher Installation solltest du die folgende Ausgabe sehen.
nvm
Schritt 3 – Node.js installieren
Wir werden die neueste Version der LTS (Long Term Support) Version von Node.js installieren. Führe dazu den folgenden Befehl aus.
$ nvm install --lts
Überprüfe, ob Node.js installiert ist.
$ node --version v16.17.0
Schritt 4 – Sails.js installieren
Jetzt, da Node.js installiert ist, ist es an der Zeit, das Sails.js-Framework zu installieren. Führe den folgenden Befehl aus, um es global zu installieren.
$ npm -g install sails
Überprüfe, ob das Sails.js-Framework installiert ist.
$ sails --version 1.5.3
Du kannst auch andere Befehle überprüfen, die in der Kommandozeilenanwendung sails verfügbar sind, indem du das Flag --help verwendest.
$ sails --help
Du wirst die folgende Ausgabe erhalten.
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]
Schritt 5 – Erstellen einer Demo-Anwendung
Führe den folgenden Befehl aus, um eine Demo-Anwendung zu erstellen.
$ sails new howtoforge-app
Du erhältst die folgenden zwei Optionen.
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)
Du kannst 1 eingeben, um eine vordefinierte Vorlage für eine vollwertige Anwendung mit Authentifizierung, einer Anmeldeseite und einer Funktion zur Passwortwiederherstellung zu verwenden. Wenn du mit einem leeren Blatt Papier beginnen möchtest, wähle Option 2.
Wir entscheiden uns für Option 1. Du musst ein paar Minuten warten, bis der Prozess abgeschlossen ist.
? 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`!
Wechsle in das Arbeitsverzeichnis der neu erstellten Anwendung. Der Name des Verzeichnisses ist derselbe wie der deiner Anwendung.
$ cd howtoforge-app
Sieh dir die Ordnerliste an. In dem Ordner sind alle wichtigen Dateien und Pakete installiert, damit du mit der Anwendung loslegen kannst.
$ 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
Führe die Sails-Anwendung aus. Mit dem folgenden Befehl startest du die Anwendung im Entwicklungsmodus. Sails.js verwendet das Tool Grunt, um den Ordner /assets zu überwachen. Wenn du in diesem Ordner etwas änderst, wird dies automatisch im Browser angezeigt. Du kannst auch deine View-Dateien ändern, ohne Sails neu zu starten, da die Vorlagen nicht im Speicher zwischengespeichert werden.
$ sails lift
Nach dem erfolgreichen Start der Anwendung erhältst du die folgende Ausgabe.
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 stellt deine Anwendung auf Port 1337 zur Verfügung. Du musst den Port öffnen, um auf die Anwendung zugreifen zu können. Starte ein weiteres Terminal auf deinem Server und führe den folgenden Befehl aus, um den Port zu öffnen.
$ sudo ufw allow 1337
Rufe die URL http://<serverIP>:1337 in deinem Browser auf. Du erhältst die folgende Seite.
Drücke Strg + C auf dem Terminal, um die Sails-Anwendung zu beenden.
Schritt 6 – Erstelle eine systemd-Dienstdatei
Im Moment funktioniert die Sails-Anwendung nur, wenn das Terminal aktiv ist. Damit sie auch nach einem Neustart weiterläuft, müssen wir eine systemd-Dienstdatei für Sails erstellen.
Erstelle und öffne die Datei howtoforge-app.service zum Bearbeiten.
$ sudo nano /etc/systemd/system/howtoforge-app.service
Füge den folgenden Code in die Datei ein.
[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
Ersetze die Werte für die Variablen User, WorkingDirectory und ExecStart durch den Benutzernamen deines Systems, den Anwendungspfad und den Pfad zu deiner Node-Anwendung. Um den Pfad zu Node.js zu ermitteln, kannst du den folgenden Befehl verwenden.
$ which node /home/navjot/.nvm/versions/node/v16.17.0/bin/node
Wir verwenden Node.js anstelle der Sails CLI-Anwendung, weil es einfacher ist, sie über ein System-Skript zu konfigurieren und auszuführen. Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Lade den Systemdaemon neu, um die Änderungen zu übernehmen.
$ sudo systemctl daemon-reload
Starte den Sails.js-Dienst und aktiviere ihn so, dass er beim Systemstart startet.
$ sudo systemctl enable howtoforge-app --now
Überprüfe den Status des Dienstes.
$ 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: -------------------------------------------------------
Du kannst den Dienst überprüfen, indem du die URL http://<serverIP>:1337 in deinem Browser öffnest.
Schritt 7 – Nginx installieren
Ubuntu 22.04 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.
Importiere den Signierschlüssel von Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \ | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Füge das Repository für die stabile Version von Nginx hinzu.
$ 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
Aktualisiere die System-Repositories.
$ sudo apt update
Installiere Nginx.
$ sudo apt install nginx
Überprüfe die Installation.
$ nginx -v nginx version: nginx/1.22.0
Schritt 8 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Du kannst Certbot entweder über das Repository von Ubuntu installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.
Bei Ubuntu 22.04 ist Snapd standardmäßig installiert. Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core $ sudo snap refresh core
Installiere Certbot.
$ sudo snap install --classic certbot
Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link zum Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.
$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d sails.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/sails.example.com auf deinem Server heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Öffne die Datei /etc/letsencrypt/renewal/sails.example.com.conf zur Bearbeitung.
$ sudo nano /etc/letsencrypt/renewal/sails.example.com.conf
Füge den folgenden Code am Ende der Datei ein.
pre_hook = systemctl stop nginx post_hook = systemctl start nginx
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Wir haben das SSL-Zertifikat mit der Standalone-Option von Certbot erstellt. Es lässt seinen Webserver laufen, um das Zertifikat zu erstellen, was bedeutet, dass Nginx während der Erneuerung abgeschaltet sein sollte. Die Befehle pre_hook und post_hook werden vor und nach der Erneuerung ausgeführt, um den Nginx-Server automatisch abzuschalten und neu zu starten, sodass kein manuelles Eingreifen erforderlich ist.
Um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert, führe einen Probelauf des Prozesses durch.
$ sudo certbot renew --dry-run
Wenn du keine Fehler siehst, ist alles in Ordnung. Dein Zertifikat wird automatisch erneuert.
Schritt 9 – Nginx konfigurieren
Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.
$ sudo nano /etc/nginx/nginx.conf
Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.
server_names_hash_bucket_size 64;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Erstelle und öffne die Datei /etc/nginx/conf.d/sails.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/sails.conf
Füge den folgenden Code in die Datei ein. Ersetze sails.example.com durch deinen Domainnamen. Vergewissere dich, dass der Wert von client_max_body_size auf 10MB eingestellt ist. Ändere ihn entsprechend deinen Anforderungen.
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 "";
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Überprüfe deine Nginx-Konfiguration.
$ sudo nginx -t
Starte den Nginx-Server neu.
$ sudo systemctl restart nginx
Schritt 10 – Zugriff auf die Sails.js App
Starte die URL https://sails.example.com in deinem Browser und du wirst mit der Sails-Homepage begrüßt.
Klicke oben rechts auf die Schaltfläche Anmelden, um ein neues Konto zu erstellen.
Gib deine Kontodaten ein und klicke zum Abschluss auf die Schaltfläche “ Konto erstellen „.
Du wirst sofort zum Willkommensbildschirm weitergeleitet.
Jetzt kannst du die Anwendung nutzen, um eine dynamische Anwendung mit Benutzerauthentifizierung, Datenbankunterstützung und einem eingebauten Zahlungsgateway von Stripe zu erstellen.
Fazit
Damit ist der Lehrgang abgeschlossen, in dem du gelernt hast, wie du das Sails.js-Framework installierst und eine Demo-Anwendung erstellst. Du hast auch gelernt, wie du einen systemd-Dienst dafür einrichtest und den Nginx-Proxy-Server mit Let’s Encrypt verwendest, um eine sichere Webanwendung zu starten. Wenn du Fragen hast, schreibe sie unten in die Kommentare.