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.com verwenden.
  • 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.

Sails.js Demo App 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 [email protected] -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.

Sails App Konto erstellen Seite

Gib deine Kontodaten ein und klicke zum Abschluss auf die Schaltfläche “ Konto erstellen „.

Du wirst sofort zum Willkommensbildschirm weitergeleitet.

Sails Application Account Willkommensseite

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.

Das könnte dich auch interessieren …