Come distribuire un’applicazione Node.js?

In questo articolo spiegheremo come distribuire un’applicazione Node JS. Parleremo dei vantaggi e degli svantaggi di Node e delle opzioni di distribuzione, tra cui IaaS, PaaS e BaaS. Infine, distribuiremo un’applicazione Node su Back4app.

Che cos’è Node.js?

Node.js è un runtime JavaScript open-source e multipiattaforma costruito sul motore JavaScript V8 di Chrome. Node mira a consentire agli sviluppatori JavaScript di diventare full-stack, permettendo loro di codificare operazioni lato server. I suoi casi d’uso includono scripting lato server, applicazioni in tempo reale, applicazioni web in streaming, applicazioni a pagina singola (SPA), strumenti di collaborazione e giochi web.

Node ha un’architettura event-driven in grado di eseguire I/O asincrono. È estremamente veloce, grazie alla sua capacità di compilare JavaScript in codice macchina nativo. È in grado di gestire un’enorme quantità di connessioni attive e consente agli sviluppatori di creare facilmente applicazioni scalabili ad alte prestazioni.

La tecnologia è stata presentata per la prima volta nel 2009 dal suo creatore Ryan Dahl in occasione dell’annuale European JSConf. È diventata immediatamente uno dei software più interessanti dell’ecosistema JavaScript.

La popolarità di Node ha raggiunto l’apice nel 2017 e rimane elevata. È uno degli strumenti di sviluppo più popolari, utilizzato da molte aziende multimilionarie come IBM, LinkedIn, Microsoft, Netflix e così via. La sua semplicità e la capacità di scalare lo rendono adatto a tutte le dimensioni delle aziende, comprese le startup.

Nelle prossime due sezioni approfondiremo i vantaggi e gli svantaggi di Node.

Vantaggi di Node.js

Prestazioni elevate

Come accennato nell’introduzione, Node è alimentato dal motore JavaScript ad alte prestazioni di Google. V8 può compilare ed eseguire JavaScript a una velocità fulminea, soprattutto perché compila JavaScript in codice macchina nativo.

Node utilizza anche un ciclo di eventi che gli consente di eseguire operazioni di I/O non bloccanti, nonostante JavaScript sia un linguaggio di programmazione a thread singolo. Questo lo rende una delle opzioni più veloci sul mercato.

Scalabilità

Uno dei vantaggi principali di Node.js è la sua capacità di scalare. Le applicazioni Node possono scalare sia orizzontalmente che verticalmente. La scalabilità orizzontale si ottiene aggiungendo altri nodi a un sistema esistente, mentre la scalabilità verticale significa aggiungere risorse supplementari a un nodo specifico. Le grandi opzioni di scalabilità della piattaforma la rendono adatta sia alle startup che alle grandi aziende con decine di milioni di utenti giornalieri, come LinkedIn, Netflix e PayPal.

Node è anche adatto all’architettura a microservizi, consentendo agli sviluppatori di creare piccoli componenti che si inseriscono in una pipeline di consegna continua e che possono facilmente scalare su richiesta.

Facile da imparare

La base di Node in JavaScript lo rende estremamente facile da imparare per gli sviluppatori che conoscono già le basi di JavaScript. Non ha una curva di apprendimento ripida e può essere padroneggiato in poche settimane. La semplicità di Node lo rende adatto a tutti i tipi di progetti.

Tempi di commercializzazione più rapidi

Il time to market è uno dei punti di riferimento essenziali per molti team di sviluppo. Tutti vogliono portare il proprio prodotto sul mercato il prima possibile e Node permette di farlo.

La semplicità di Node e la grande quantità di pacchetti npm riducono drasticamente i tempi di commercializzazione. Su GitHub e su altre piattaforme esistono numerosi progetti open-sourced che possono essere utilizzati come modelli per rendere il progetto operativo il più rapidamente possibile.

Strumento testato in battaglia

Node è uno strumento maturo e collaudato che esiste dal 2009. La sua stabilità è stata testata da grandi aziende come eBay, Netflix e LinkedIn, che hanno milioni di utenti giornalieri.

Grazie ai suoi fantastici vantaggi, Node è incluso in numerosi stack tecnologici (di solito in combinazione con Express e un database NoSQL). Alcuni degli stack tecnologici con Node includono:

• MERN
• MALE
• DERNA

Grande comunità

Node.js ha una comunità forte e attiva di sviluppatori e appassionati che continuano a contribuire a Node per renderlo sempre migliore. Nel caso in cui si rimanga bloccati su un problema o si abbia una domanda, ci sono diversi luoghi in cui si può cercare aiuto. Data la popolarità di Node, non è difficile trovare soluzioni e codice già pronto su GitHub.

Un’altra grande caratteristica di Node.js è il suo gestore di pacchetti chiamato npm (Node Package Manager). Npm consente agli sviluppatori di spingere e utilizzare pacchetti JavaScript già pronti, invece di reinventare la ruota. I pacchetti possono ridurre significativamente i costi di sviluppo e la complessità delle applicazioni. Al momento in cui scriviamo, ci sono più di 1,3 milioni di pacchetti ospitati su npm.

Limitazioni di Node.js

Diminuzione delle prestazioni in compiti complessi

Il più grande svantaggio di Node.js è la sua incapacità di eseguire compiti che richiedono un’elaborazione pesante. Oggigiorno molti programmi e algoritmi richiedono la parallelizzazione per ottenere risultati ottimali. Come già sapete, Node.js è basato su JavaScript, che è stato progettato per essere un linguaggio di frontend a thread singolo e non supporta thread multipli.

Con l’aggiornamento 10.5, il team di Node.js ha introdotto il supporto al multithreading sotto forma di thread worker. Questo modulo consente agli sviluppatori di sfruttare ulteriori thread da un pool di thread. Anche con i thread worker, Node non è ancora adatto all’elaborazione pesante. Se i requisiti del progetto includono calcoli complessi, elaborazione pesante o parallelizzazione, è meglio scegliere un altro linguaggio di programmazione.

Modello di programmazione asincrono

Node.js utilizza il modello di programmazione asincrona. Per questo motivo si basa molto sull’uso di callback. Le callback sono funzioni che vengono eseguite in background e (a un certo punto) restituiscono un risultato. L’uso delle callback può rendere il codice più complicato e più difficile da debuggare. Inoltre, se si annidano le callback a più livelli, si può finire in un cosiddetto “inferno dellecallback“.

L’inferno delle callback e altri problemi della programmazione asincrona possono essere facilmente evitati seguendo i principi del codice pulito.

API instabile

Un altro grande problema di Node.js è l’instabilità dell’interfaccia di programmazione delle applicazioni (API). L’API di Node cambia frequentemente con modifiche incompatibili all’indietro che possono rompere parti di codice. Di conseguenza, gli sviluppatori di Node devono tenere d’occhio le modifiche e assicurarsi che le loro basi di codice siano compatibili con le ultime versioni dell’API di Node.js.

Mancanza di un forte sistema di supporto bibliotecario

JavaScript non dispone di un buon sistema di librerie rispetto ad altri linguaggi di programmazione. Questo costringe molti sviluppatori a farsi carico del supporto di vari compiti comuni come l’elaborazione delle immagini, il parsing di XML, la mappatura relazionale degli oggetti (ORM), la gestione dei database e altro ancora.

Un registro dei moduli troppo cresciuto e immaturo

Node ha un’enorme comunità di sviluppatori che producono migliaia di moduli open-source pubblicati su npm. Il problema è che npm non implementa alcun controllo per assicurarsi che il codice del modulo funzioni e sia ben scritto.

Molti moduli diventano casualmente non supportati o si rompono con le nuove versioni di Node e gli sviluppatori sono costretti a cercare un’alternativa. In passato, alcuni moduli npm sono stati anche violati e iniettati con virus e crypto miner. Per questo motivo, è difficile trovare moduli che possano essere utilizzati in un ambiente aziendale.

Non fraintendetemi, penso che npm sia ottimo, ma bisogna comunque fare attenzione quando si installano moduli a caso.

Opzioni di distribuzione di Node.js

Esistono diversi modi per distribuire un’applicazione Node.js. In generale, possiamo suddividerli nei seguenti quattro gruppi:

1. Hosting convenzionale
2. Infrastruttura come servizio (IaaS)
3. Piattaforma come servizio (PaaS)
4. Backend come servizio (BaaS)

Possiamo visualizzarli in un grafico piramidale in base al loro livello di astrazione:

Le opzioni di distribuzione si occupano dei seguenti livelli di astrazione:

Diamo un’occhiata a ciascuno dei gruppi. Salteremo l’hosting convenzionale, poiché sono certo che sapete come funziona.

Servizi IaaS come AWS

L’Infrastructure as a Service (IaaS) è un modello di servizio di cloud computing che fornisce risorse informatiche come server, reti, sistemi operativi e storage in un ambiente virtualizzato. Questi server cloud sono tipicamente forniti all’organizzazione attraverso API di alto livello o dashboard avanzate che consentono ai clienti di avere il controllo completo sull’intera infrastruttura.

L’IaaS è altamente scalabile. Consente ai clienti di scalare facilmente sia verticalmente che orizzontalmente in base alla domanda. I fornitori di IaaS seguono in genere un modello pay-as-you-go, il che significa che si paga solo per le risorse consumate.

Lo IaaS è nato nei primi anni 2010 e da allora è diventato il modello di astrazione standard per molti tipi di carichi di lavoro. Anche con l’avvento di nuove tecnologie come i microservizi e i serverless, lo IaaS rimane l’opzione più popolare.

A differenza di PaaS e BaaS, IaaS fornisce il controllo di livello più basso delle risorse nel cloud. Questo lo rende il modello di cloud computing più flessibile. L’aspetto negativo è che il cliente è completamente responsabile della gestione di aspetti quali applicazioni, sistemi operativi, middleware e dati, che di solito richiede molto tempo.

Alcuni esempi tipici di IaaS sono:

• Servizi Web Amazon (AWS)
• Motore di calcolo di Google (GCE)
• Microsoft Azure
• DigitalOcean
• Linode
• Rackspace

Servizi PaaS come Heroku

Platform as a Service (PaaS) è un modello di servizio di cloud computing che fornisce agli utenti un ambiente cloud in cui sviluppare, gestire e distribuire applicazioni. Oltre a fornire risorse informatiche, il PaaS viene fornito con molti strumenti precostituiti per lo sviluppo, la personalizzazione e il test delle applicazioni. La maggior parte dei fornitori di PaaS consente di rendere operativa la propria applicazione in pochi clic!

Il PaaS consente agli utenti di concentrarsi sulla propria applicazione invece di gestire l’infrastruttura sottostante. I fornitori di PaaS si occupano di molte attività pesanti, come la gestione dei server, dei sistemi operativi, del software del server, dei backup e altro ancora.

Alcuni dei vantaggi del PaaS sono:

• Maggiore velocità di immissione sul mercato
• Maggiore sicurezza
• Costo-efficacia
• Scalabilità
• Alta disponibilità
• Meno codice richiesto

Gli aspetti negativi del PaaS sono che molto probabilmente dipenderete dalle capacità del fornitore, c’è il rischio di lock-in e una mancanza di flessibilità e controllo. Tuttavia, il PaaS permette agli utenti di creare applicazioni più velocemente ed è meno oneroso da gestire.

I servizi PaaS includono:

• Heroku
• AWS Elastic Beanstalk
• Piattaforma app DigitalOcean
• Servizio app di Microsoft Azure
• La piattaforma Fly (Fly.io)
• Render

Servizi BaaS come Back4app

Backend as a Service (BaaS) è una piattaforma che automatizza il lato backend dello sviluppo e si occupa dell’infrastruttura cloud. Inoltre, fornisce funzionalità come la gestione degli utenti, le notifiche e-mail, le notifiche push, le funzioni di codice cloud, le integrazioni con i social media, l’archiviazione dei file e i pagamenti.

Questo permette agli sviluppatori di concentrarsi sul core business e sulla costruzione del frontend senza preoccuparsi del backend e dell’infrastruttura sottostante. Il frontend viene solitamente sviluppato tramite API e SDK specializzati offerti dal fornitore di BaaS. Questo rende le applicazioni meno complesse e più facili da mantenere.

Il BaaS offre tutti i vantaggi dell’IaaS e del PaaS, ma include l’astrazione del backend. I team che utilizzano BaaS riducono notevolmente il time-to-market, i costi di progettazione e il numero di ingegneri necessari.

BaaS può essere utilizzato per molti tipi di progetti, tra cui la realizzazione di un MVP (Minimum Viable Product), applicazioni stand-alone o che richiedono un numero ridotto di integrazioni e applicazioni aziendali non mission-critical.

Gli aspetti negativi del BaaS sono la minore flessibilità rispetto a IaaS e PaaS, un minor livello di controllo e personalizzazione e la possibilità di lock-in per le piattaforme non open-source.

Alcuni esempi di BaaS:

• Back4app
• AWS Amplify
• Base di fuoco
• Parse
• Cloudkit
• Senza schienale

Processo di distribuzione di Node.js

In questa parte dell’articolo, esamineremo Back4app e impareremo come costruire e distribuire un’applicazione Node JS.

Che cos’è Back4app?

Back4app è una delle migliori soluzioni open-source di Backend as a Service (BaaS) presenti sul mercato. Offre una vasta gamma di funzionalità e vantaggi ai suoi utenti, consentendo agli sviluppatori di creare rapidamente applicazioni web e mobili. Utilizzando Back4app potrete concentrarvi sul core business invece di preoccuparvi del backend o dell’infrastruttura sottostante.

La soluzione è dotata di una dashboard ricca di funzionalità e facile da usare e di un’interfaccia a riga di comando (CLI). Fornisce inoltre SDK per tutti i vostri strumenti preferiti come Flutter, React Native, Node.js, Angular, Android, iOS e altri ancora!

Le caratteristiche principali di Back4app includono:

• Database simile a un foglio di calcolo
• API REST e GraphQL
• Quesiti in diretta
• Autenticazione (compresa l’autenticazione sociale)
• Hosting scalabile
• Notifiche push e via e-mail

Per ulteriori informazioni sulle loro caratteristiche, consultate le Caratteristiche di Back4app.

Back4app segue un modello di prezzo semplice e diretto che può adattarsi a un’app di qualsiasi dimensione. Offre un generoso piano gratuito (non è richiesta la carta di credito), ottimo per la prototipazione e il test della piattaforma. Include:

• 25k richieste
• 250 MB di memoria dati
• 1 GB di trasferimento
• 1 GB di memoria per i file

Per ulteriori informazioni sui prezzi di Back4app, consultate la pagina Prezzi.

Introduzione al progetto

Stiamo per codificare e distribuire una semplice applicazione web TODO. L’applicazione web supporterà le operazioni CRUD di base: creazione, recupero, aggiornamento e cancellazione. La codificheremo in Node.js utilizzando il framework web Express, la memorizzazione dei dati sarà gestita da Parse e utilizzeremo Twig come motore di template.

Cliccate qui per vedere l’applicazione distribuita in azione!

Prerequisiti:

• Conoscenza di base di Node.js
• Conoscenza di base di Express
• Esperienza con un motore di template
• Conoscenza di base dei database e di ParseJS

Back4app CLI

Per eseguire i passaggi seguenti è necessario disporre di un account Back4app. Se lo avete già , accedete, altrimenti procedete con la registrazione dell’account gratuito.

Back4app CLI è un’interfaccia a riga di comando che consente di interagire con la piattaforma Back4app.

Per installarlo su Mac/Linux eseguire:

$ curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash

Il comando scaricherà l’ultimo binario della CLI e lo memorizzerà in /usr/local/bin/b4a.

Per altri sistemi operativi, consultare la documentazione ufficiale.

Per utilizzare la CLI è necessario autenticarsi con il proprio account. Per farlo, è necessario generare una chiave dell’account. Accedere alla dashboard di Back4app e fare clic sul proprio nome utente (in alto a destra dello schermo), quindi su “Chiavi account”:

Per aggiungere una nuova chiave dell’account, inserire il nome di una chiave personalizzata e premere “+”. Prendere nota della chiave, poiché ne avremo bisogno nella fase successiva:

Dopo aver creato con successo la chiave, tornate al terminale ed eseguite:

$ b4a configure accountkey

Input your account key or press ENTER to generate a new one.       
NOTE: on pressing ENTER we'll try to open the url:                 
        "http://dashboard.back4app.com/classic#/wizard/account-key"
in default browser.
Account Key: <YOUR_GENERATED_ACCOUNT_KEY>
Successfully stored account key for: "<YOUR_EMAIL>".

Per verificare che l’autenticazione abbia funzionato, provate a elencare le vostre applicazioni:

$ b4a list

These are the apps you currently have access to:

Se l’account è nuovo, come il mio, non viene elencata alcuna applicazione.

Creare un’applicazione

Procediamo con la creazione di un’applicazione Back4app.

Correre:

$ b4a new

Would you like to create a new app, or add Cloud Code to an existing app?
Type "(n)ew" or "(e)xisting": n
Please choose a name for your Parse app.
Note that this name will appear on the Back4App website,
but it does not have to be the same as your mobile app's public name.
Name: nodejs-back4app
Awesome! Now it's time to set up some Cloud Code for the app: "nodejs-back4app",
Next we will create a directory to hold your Cloud Code.
Please enter the name to use for this directory,
or hit ENTER to use "nodejs-back4app" as the directory name.

Directory Name:
You can either set up a blank project or create a sample Cloud Code project
Please type "(b)lank" if you wish to setup a blank project, otherwise press ENTER: 
Successfully configured email for current project to: "<YOUR_EMAIL>"
Your Cloud Code has been created at /dev/nodejs-back4app.

1. Creare un’applicazione nuova o esistente: nuova
2. Scegliere un nome per l’app: scegliere un nome personalizzato
3. Nome della directory: premere ENTER
4. Progetto Cloud Code vuoto o di esempio: premere ENTER

Il comando creerà una directory con la seguente struttura:

nodejs-back4app/
├── cloud/
│   └── main.js
├── public/
│   └── index.html
├── .parse.local
└── .parse.project

1. cloud è una directory per tutto il codice e le funzioni della nuvola.
2. public è una cartella per i file pubblici, come immagini, fogli di stile e altro.
3. .parse.local e .parse.project sono utilizzati per memorizzare la configurazione di Parse.

Eliminare i file main.js e index.html, poiché non sono necessari.

Hosting web

Poiché stiamo creando un’applicazione Node.js, dobbiamo abilitare l’hosting web di Back4app per ospitare la nostra applicazione e renderla pubblicamente accessibile a Internet.

Per abilitare la funzione di web hosting, visitate la dashboard di Back4app, selezionate la vostra applicazione, fate clic su “Impostazioni dell’applicazione” sul lato sinistro dello schermo, quindi su “Impostazioni del server”. Cercare “Webhosting e domini personalizzati” e cliccare nuovamente su “Impostazioni”.

Fare clic su “Attiva l’hosting Back4app” e scegliere un nome di sottodominio. Io userò nodejsback4app:

Infine, fare clic su “Salva”.

La vostra applicazione sarà quindi accessibile a:

https://<your_subdomain>.b4a.app/

Sentitevi liberi di collegare anche un dominio personalizzato alla vostra web app!

Express con le funzioni di Cloud Code

Quindi, iniziamo a lavorare sul codice vero e proprio.

Cambiare la cartella in cloud e creare il file package.json al suo interno:

Back4app usa questo file per scaricare i moduli tramite npm. Abbiamo aggiunto body-parser, perché ci servirà in seguito per analizzare le richieste.

Quindi, creare un altro file nella cartella clouds, denominato app.js:

Questo file viene utilizzato per inizializzare e configurare Express. Abbiamo anche definito un endpoint che sarà usato come controllo di correttezza nel prossimo passo. Come si può vedere, non è stato necessario definire l’app o richiedere alcuna dipendenza, poiché Back4app lo fa automaticamente.

Quindi, distribuire l’applicazione:

$ b4a deploy

Uploading source files
Uploading recent changes to scripts...
Finished uploading files
New release is named v1 (using Parse JavaScript SDK v2.2.25)

Il comando caricherà i file sorgente su Back4app, configurerà tutto e renderà disponibile l’applicazione sul sottodominio scelto nella sezione precedente.

Per verificare che funzioni, aprite il vostro browser web preferito e navigate verso la vostra applicazione:

https://<your_subdomain>.b4a.app/

# Example
https://nodejsback4app.b4a.app/

Si dovrebbe ottenere la seguente risposta:

Ottimo lavoro!

Nelle prossime sezioni inizieremo a lavorare sull’applicazione TODO vera e propria.

Database con ParseJS

Definiamo i modelli di database per l’applicazione TODO.

Accedere alla dashboard di Back4app e selezionare “Database” sul lato sinistro dello schermo. Quindi fare clic su “Crea una nuova classe”, denominarla Task e assicurarsi di spuntare la voce “Lettura e scrittura pubbliche abilitate”:

Quindi, aggiungere le seguenti colonne:

+-----------+-------------+---------------+----------+
| Data type | Name        | Default value | Required |
+-----------+-------------+---------------+----------+
| String    | name        | <leave blank> | yes      |
+-----------+-------------+---------------+----------+
| String    | description | <leave blank> | no       |
+-----------+-------------+---------------+----------+
| Boolean   | isDone      | false         | yes      |
+-----------+-------------+---------------+----------+

Logica dell’applicazione

L’applicazione avrà i seguenti endpoint:

1. / visualizzare l’elenco dei compiti
2. /create crea un compito
3. /<ID> visualizza i dettagli dell’attività
4. /<ID>/cancella canc ella un’attività
5. /<ID>/toggle alterna lo stato dell’attività — fatto/disfatto

Creiamoli.

Per rendere il nostro codice cloud più manutenibile, lo divideremo in due file.

1. app.js — inizializza e configura il server Express
2. routes.js — definisce gli endpoint e la loro logica

Un approccio ancora migliore per costruire applicazioni web moderne è quello di utilizzare un pattern architetturale Model-View-Controller (MVC). Un buon inizio con Express è l’uso di express-generator.

Sostituire il contenuto di app.js con il seguente:

1. Abbiamo impostato Twig come motore di visualizzazione predefinito.
2. Le rotte non sono più definite in questo file, ma in routes.js.

Quindi, creare routes.js e inserire il seguente codice:

Abbiamo definito tutte le rotte menzionate in precedenza e usato Parse per manipolare e memorizzare i dati. Come si può vedere, tutte le rotte sono asincrone, poiché dobbiamo aspettare che Parse risponda. Inoltre, la maggior parte del codice è racchiusa in blocchi try-catch, nel caso in cui qualcosa vada storto.

Per ulteriori informazioni su ParseJS, consultare la Guida JavaScript.

Quindi, accompagniamo gli endpoint con i modelli di vista.

Creare una cartella views all’interno della cartella clouds, scaricare i file del template dal repo GitHub e inserirli nella cartella views.

La struttura finale della directory dovrebbe essere la seguente:

nodejs-back4app/
├── cloud/
│   ├── views/
│   │   ├── base.twig
│   │   ├── create.twig
│   │   ├── error.twig
│   │   ├── index.twig
│   │   └── task.twig
│   ├── app.js
│   ├── routes.js
│   └── package.json
├── public
├── parse.local
└── parse.project

Infine, aggiungere twing a package.json per abilitare il supporto a Twig:

Distribuire l’applicazione:

$ b4a deploy

Uploading source files
Uploading recent changes to scripts...
Finished uploading files
New release is named v2 (using Parse JavaScript SDK v2.2.25)

E il gioco è fatto. Aspettate qualche minuto e poi visitate l’applicazione web per verificare che tutto funzioni.

File pubblici

Come indicato nella sezione precedente, Back4app serve automaticamente i file che si trovano nella cartella pubblica. Per utilizzarli nei vostri modelli, dovrete modificare leggermente le impostazioni di Express.

Andare in app.js e aggiungere le seguenti righe:

È quindi possibile fare riferimento ai file pubblici nei modelli tramite il percorso relativo:

<img src="/back4app.png" alt="Back4app Logo">

Visualizza l’immagine situata in public/back4app.png.

Conclusione

Node è cresciuto e migliorato costantemente dal suo rilascio nel 2009. È uno dei migliori strumenti che consentono agli sviluppatori di creare facilmente applicazioni scalabili e ad alte prestazioni.

Le applicazioni Node possono essere distribuite su diverse soluzioni come IaaS, PaaS e SaaS. Ognuna di esse presenta vantaggi e svantaggi che devono essere presi in considerazione quando si sceglie l’opzione di distribuzione.

Uno dei modi più semplici per distribuire applicazioni Node è l’utilizzo di Back4app, una soluzione BaaS open-source dotata di numerose funzionalità. Back4app è ottimo perché permette di concentrarsi su ciò che è importante, esternalizzando il backend e la sua distribuzione.

Ottenere il codice sorgente finale dal repo back4app-nodejs.

Per saperne di più sulle opzioni di hosting Node.js, si veda Come ospitare un’applicazione Node.JS usando i container.