Come dockerizzare un'API REST Node.js

Il processo di distribuzione ed esecuzione delle applicazioni in ambienti diversi può essere una seccatura poiché è necessario considerare una serie di fattori come l'impostazione delle variabili di ambiente per configurare le dipendenze necessarie e versioni specifiche di diversi pacchetti software.

Tuttavia, utilizzando la tecnologia di containerizzazione di Docker, puoi distribuire applicazioni in ambienti diversi con il minimo sforzo con tutte le dipendenze necessarie nell'immagine docker. Ciò significa che non devi preoccuparti di effettuare alcuna configurazione. Ciò rende il processo di distribuzione ed esecuzione delle applicazioni in ambienti diversi un gioco da ragazzi.

Cos'è Docker?

Docker è una piattaforma di sviluppo che fornisce gli strumenti e l'ambiente per impacchettare le applicazioni come immagini portatili che possono essere eseguite come componenti eseguibili autonomi in contenitori.

Questi contenitori costituiscono il codice dell'applicazione e le dipendenze necessarie affinché l'applicazione venga eseguita correttamente in diversi ambienti di runtime senza problemi.

Prima di iniziare, installa Docker sul tuo computer locale. Controlla i prerequisiti specifici della piattaforma e le istruzioni di installazione dalla documentazione ufficiale.

Crea un'API REST Node.js

Per iniziare, creare un server Web Node.js.

Puoi trovare il codice di questa applicazione nel suo file Deposito GitHub.

Successivamente, installa i pacchetti richiesti per questo progetto.

npm installa morgan pg knex

IL pag package viene utilizzato per stabilire una connessione con un database PostgreSQL. knex, d'altra parte, fornisce una semplice API per interagire con PostgreSQL: la utilizzerai per scrivere query SQL.

Infine, userai morgan, un middleware che registra le richieste e le risposte HTTP sulla console, per eseguire il debug e monitorare l'applicazione in esecuzione in un contenitore Docker.

Infine, apri il file index.js file e aggiungi il codice sottostante implementa una semplice API REST con tre percorsi.

cost espresso = richiedere("esprimere")
cost morgan = richiedere("Morgan")
cost app = espresso()
cost db = richiedere('./db')
cost PORTA = process.env. PORTO || 5000
app.use (morgan('sviluppatore'))
app.use (express.json())
app.use (express.urlencoded({ esteso: VERO }))
app.get('/', (req, res) => res.send('Ciao mondo!' ))
app.get('/utenti', asincrono (req, res) => {
cost utenti = aspetta db.select().from('utenti')
 res.json (utenti)
})
app.post('/utenti', asincrono (req, res) => {
cost utente = aspetta db('utenti').inserire({ nome: req.body.name }).returning('*')
 res.json (utente)
})
app.listen (PORTA, () => consolare.tronco d'albero(`Server attivo su PORT:${PORTA}`))

Configurare la connessione al database

L'API REST interagirà con l'istanza PostgreSQL di Docker, tuttavia, devi prima configurare la connessione al database nella tua applicazione. Nella directory principale della cartella del progetto, crea un file db.js file e aggiungere il codice qui sotto.

cost knex = richiedere('knox')
modulo.exports = knex({
 cliente: 'postgres',
 connessione: {
 ospite: 'db',
 utente: 'utenteprova',
 parola d'ordine: 'miapassword123',
 Banca dati: 'utenteprova',

 },
})

Configura i file migrate.js e seed.js

Questi due file consentiranno di creare una tabella nel database e di popolarla con i dati di test tramite l'API. Crea una nuova cartella, script, nella directory principale del tuo progetto e aggiungi due file: migrate.js E seme.js.

Nel migrate.js file, aggiungi il codice qui sotto:

cost db = richiedere('../db');
(asincrono () => {
Tentativo {
aspetta db.schema.dropTableIfExists('utenti')
aspetta db.schema.withSchema('pubblico').crea tabella('utenti', (tabella) => {
 tabella.incrementi()
 tabella.stringa('nome')
 })
consolare.tronco d'albero('Tabella utenti creata!')
 processo.exit(0)
 } presa (errare) {
consolare.log (errore)
 processo.exit(1)
 }
})()

Questo codice creerà un file utenti tabella con una colonna id a incremento automatico e a nome colonna nel database.

Successivamente, nel seme.js file, aggiungi il codice qui sotto:

cost db = richiedere('../db');
(asincrono () => {
Tentativo {
aspetta db('utenti').inserire({ nome: 'Prova Utente1' })
aspetta db('utenti').inserire({ nome: 'Prova Utente2' })
consolare.tronco d'albero('Aggiunti utenti fittizi!')
 processo.exit(0)
 } presa (errare) {
consolare.log (errore)
 processo.exit(1)
 }
})()

Questo codice implementa una funzione asincrona che inserirà due utenti nel database PostgreSQL.

Infine, aggiungi questi comandi al tuo file pacchetto.json file.

"copioni": {
"inizio": "nodo index.js",
"migrare": "script nodo/migrate.js",
"seme": "nodo script/seed.js"
 },

Poiché non hai configurato un client, per testare l'API dovrai eseguire i due file come script insieme a corsa npm comando.

Imposta un file Docker

Un Dockerfile definisce le istruzioni richieste dal motore Docker per creare un'immagine Docker. Nella directory principale del tuo progetto, crea un nuovo file e assegnagli un nome, Dockerfile. Quindi, aggiungi le seguenti istruzioni per creare un'immagine Docker per l'applicazione Node.js.

DA nodo:16.3.0-alpino3.13
WORKDIR /app
COPIA pacchetto*.json ./
CORRERE installazione npm
COPIA. .
ESPORRE8000
cmd [ "nodo", "indice.js" ]

Analizziamolo:

• DA - Questa istruzione imposta l'immagine di base per l'applicazione, che è l'immagine Node.js Alpine, una versione leggera dell'immagine Node.js che si trova nel registro Docker.
• WORKDIR - imposta /app directory come directory di lavoro.
• COPIA pacchetto*.json./ - indica a Docker di copiare tutti i file con quel formato di nome file dalla directory corrente al file /app cartella.
• CORRERE - esegue e costruisce l'immagine.
• COPIA.. - copia i file di origine nel file /app cartella.
• ESPORRE - indica a Docker di esporre una porta all'interno del contenitore all'ambiente esterno, in questo caso il computer host.
• cmd - specifica il comando da eseguire quando il contenitore Docker viene creato dall'immagine.

Crea il file di composizione Docker

Affinché l'applicazione Node.js possa interagire con l'istanza PostgreSQL di Docker, le due applicazioni devono essere eseguite nei container Docker all'interno dello stesso ambiente di rete.

Per questo motivo, è necessario definire e creare sia l'immagine dell'applicazione che l'istanza PostgreSQL utilizzando Docker Componi — uno strumento che consente di creare e gestire più container Docker.

In poche parole, utilizzando un Docker Compose, puoi definire i servizi che compongono la tua applicazione come una singola unità, in questo caso, l'API REST Node.js e il database PostgreSQL.

Crea un nuovo file, docker-compose.yml, nella directory principale e aggiungi il codice seguente:

versione:'3.9'
Servizi:
server:
costruire:.
porti:
-'5000:5000'
dipende da:
-db
DB:
Immagine:'postgres'
porti:
-'4321:5432'
ambiente:
POSTGRES_PASSWORD:'miapassword123'
POSTGRES_USER:'utenteprova'
volumi:
-data:/var/lib/postgresql/data
volumi:
dati:

Questo codice creerà ed eseguirà due contenitori Docker. Il primo contenitore, server, Docker Compose utilizza Dockerfile per creare l'immagine per questo contenitore.

Specifica inoltre che il contenitore del server dipende da db contenitore. Significato, il server contenitore deve essere avviato dopo il db contenitore per connettersi con esso.

Il secondo contenitore è un contenitore di database PostgreSQL. Non è necessario specificare un Dockerfile per questo contenitore poiché verrà creato dall'immagine PostgreSQL nel registro delle immagini di Docker.

Crea le immagini Docker

Utilizzare il comando Docker Compose per creare le immagini e avviare i due contenitori.

docker-componi -d

Dovresti vedere una risposta simile dopo che il processo è stato completato con successo.

Testare l'API REST

Eseguire il comando seguente per testare l'API REST in esecuzione nel contenitore Docker. Dovrebbe creare una tabella nel database PostgreSQL.

docker exec docker_node-server-1 npm eseguire la migrazione

Dovresti vedere una risposta simile.

Condivisione delle immagini Docker

Il passaggio finale è il push dell'immagine Docker per la tua applicazione Node.js su Docker Hub. Questo è simile al push dei tuoi progetti su GitHub.

• Vai a Hub mobile e registrati per un account e accedi alla dashboard dell'utente.
• Successivamente, fai clic su Crea un deposito. Fornisci il nome del tuo repository e impostane la visibilità su entrambi Pubblico O Privato e quindi fare clic Creare.
• Per eseguire il push dell'immagine Docker della tua applicazione su Docker Hub, devi prima accedere al tuo account tramite il terminale e quindi fornire nome utente e password.

accesso alla finestra mobile

• Successivamente, aggiorna il nome dell'immagine Docker in modo che corrisponda a questo formato: /. Eseguire il comando seguente per apportare questa modifica:

 etichetta docker /

• Infine, spingi la tua immagine Docker.

 spinta del docker /

Utilizzo di Docker in fase di sviluppo

Questa guida ha toccato solo una frazione del potenziale che Docker può offrire. Tuttavia, ora puoi utilizzare la tecnologia di containerizzazione di Docker per impacchettare qualsiasi applicazione e tutte le sue dipendenze come immagini che possono essere distribuite in diversi ambienti di sviluppo e produzione come il cloud senza alcuno singhiozzo.