Cum să dockerizezi un API REST Node.js

Procesul de implementare și rulare a aplicațiilor în diferite medii poate fi o bătaie de cap, deoarece există o serie de factori de luat în considerare cum ar fi configurarea variabilelor de mediu pentru a configura dependențele necesare și versiuni specifice ale diferitelor pachete software.

Cu toate acestea, utilizând tehnologia de containerizare Docker, puteți implementa aplicații în diferite medii cu efort minim, cu toate dependențele necesare în imaginea docker. Adică, nu trebuie să vă faceți griji cu privire la realizarea vreunei configurații. Acest lucru face ca procesul de implementare și rulare a aplicațiilor în diferite medii să fie ușor.

Ce este Docker?

Docher este o platformă de dezvoltare care oferă instrumentele și mediul pentru ambalarea aplicațiilor ca imagini portabile care pot fi rulate ca componente executabile autonome în containere.

Aceste containere constituie codul aplicației și dependențele necesare pentru ca aplicația să ruleze cu succes în diferite medii de rulare fără probleme.

Înainte de a începe, instalați Docker pe mașina dvs. locală. Verificați cerințele preliminare specifice platformei și instrucțiunile de instalare din documentația oficială.

Creați un API REST Node.js

Pentru a incepe, creați un server web Node.js.

Puteți găsi codul acestei aplicații în documentul său Depozitul GitHub.

Apoi, instalați pachetele necesare pentru acest proiect.

npm instalează morgan pg knex

The pg pachetul este utilizat pentru a stabili o conexiune cu o bază de date PostgreSQL. knex, pe de altă parte, oferă un API simplu pentru interacțiunea cu PostgreSQL - îl veți folosi pentru a scrie interogări SQL.

În cele din urmă, vei folosi morgan, un middleware care înregistrează cererile și răspunsurile HTTP pe consolă, pentru a depana și a monitoriza aplicația care rulează într-un container Docker.

În cele din urmă, deschideți index.js fișier și adăugați codul mai jos implementează un API REST simplu cu trei trasee.

const expres = cere("expres")
const morgan = cere("morgan")
const aplicație = expres()
const db = cere('./db')
const PORT = proces.env. PORT || 5000
app.use (morgan(„dev”))
app.use (express.json())
app.use (express.urlencoded({ extins: Adevărat }))
app.get('/', (req, res) => res.send('Salut Lume!' ))
app.get(„/utilizatori”, asincron (req, res) => {
const utilizatori = așteaptă db.select().from(„utilizatori”)
 res.json (utilizatori)
})
app.post(„/utilizatori”, asincron (req, res) => {
const utilizator = așteaptă db(„utilizatori”).introduce({ Nume: req.body.name }).returning('*')
 res.json (utilizator)
})
app.ascultă (PORT, () => consolă.Buturuga(`Server la PORT:${PORT}`))

Configurați conexiunea la baza de date

API-ul REST va interacționa cu instanța PostgreSQL a Docker, cu toate acestea, mai întâi trebuie să configurați conexiunea la baza de date în aplicația dvs. În directorul rădăcină al folderului de proiect, creați un db.js fișier și adăugați codul de mai jos.

const knex = cere('knex')
modul.exports = knex({
 client: "postgres",
 conexiune: {
 gazdă: 'db',
 utilizator: 'testUser',
 parola: „parola mea123”,
 Bază de date: 'testUser',

 },
})

Configurați fișierele migrate.js și seed.js

Aceste două fișiere vor face posibilă crearea unui tabel în baza de date și completarea acestuia cu date de testare prin intermediul API-ului. Creați un folder nou, scenarii, în directorul rădăcină al proiectului și adăugați două fișiere: migrate.js și sămânță.js.

În migrate.js fișier, adăugați codul de mai jos:

const db = cere('../db');
(asincron () => {
încerca {
așteaptă db.schema.dropTableIfExists(„utilizatori”)
așteaptă db.schema.withSchema('public').createTable(„utilizatori”, (tabel) => {
 table.increments()
 table.string('Nume')
 })
consolă.Buturuga(„Tabelul utilizatorilor creat!”)
 proces.ieșire(0)
 } captură (eroare) {
consolă.log (eroare)
 proces.ieșire(1)
 }
})()

Acest cod va crea un utilizatorii tabel cu o coloană ID cu incrementare automată și a Nume coloana din baza de date.

În continuare, în sămânță.js fișier, adăugați codul de mai jos:

const db = cere('../db');
(asincron () => {
încerca {
așteaptă db(„utilizatori”).introduce({ Nume: „Test User1” })
așteaptă db(„utilizatori”).introduce({ Nume: „Test User2” })
consolă.Buturuga(„S-au adăugat utilizatori falși!”)
 proces.ieșire(0)
 } captură (eroare) {
consolă.log (eroare)
 proces.ieșire(1)
 }
})()

Acest cod implementează o funcție asincronă care va insera doi utilizatori în baza de date PostgreSQL.

În cele din urmă, adăugați aceste comenzi la dvs pachet.json fişier.

"scripte": {
"start": „node index.js”,
"migra": „node scripts/migrate.js”,
"samanta": „node scripts/seed.js”
 },

Deoarece nu aveți un client configurat, pentru a testa API-ul, va trebui să rulați cele două fișiere ca scripturi alături de rulare npm comanda.

Configurați un fișier Docker

Un fișier Docker definește instrucțiunile cerute de motorul Docker pentru a construi o imagine Docker. În directorul rădăcină al proiectului, creați un fișier nou și denumiți-l, Dockerfile. Apoi, adăugați următoarele instrucțiuni pentru a crea o imagine Docker pentru aplicația Node.js.

DIN nodul:16.3.0-alpin3.13
WORKDIR /app
COPIE pachet*.json ./
ALERGA instalare npm
COPIE. .
EXPUNE8000
CMD [ "nodul", „index.js” ]

Să o descompunem:

• DIN - Această instrucțiune setează imaginea de bază pentru aplicație, care este imaginea Node.js Alpine, o versiune ușoară a imaginii Node.js care poate fi găsită în registrul Docker.
• WORKDIR - seturi /app director ca director de lucru.
• COPIE pachet*.json./ - instruiește Docker să copieze toate fișierele cu acel format de nume de fișier din directorul curent în /app pliant.
• ALERGA - execută și construiește imaginea.
• COPIE.. - copiează fișierele sursă în fișierul /app pliant.
• EXPUNE - aceasta îi indică lui Docker să expună un port din container la mediul extern, în acest caz, mașina gazdă.
• CMD - specifică comanda care trebuie executată atunci când containerul Docker este creat din imagine.

Creați fișierul Docker Compose

Pentru ca aplicația Node.js să interacționeze cu instanța PostgreSQL a Docker, cele două aplicații trebuie să ruleze în containere Docker în același mediu de rețea.

Din acest motiv, trebuie să definiți și să construiți atât imaginea aplicației, cât și instanța PostgreSQL folosind Docker Compose — un instrument care vă permite să construiți și să gestionați mai multe containere Docker.

Mai simplu spus, folosind un Docker Compose, puteți defini serviciile care alcătuiesc aplicația dvs. ca o singură unitate, pentru acest caz, API-ul REST Node.js și baza de date PostgreSQL.

Creați un fișier nou, docker-compose.yml, în directorul rădăcină și adăugați codul de mai jos:

versiune:'3.9'
Servicii:
Server:
construi:.
porturi:
-'5000:5000'
depinde de:
-db
db:
imagine:"postgres"
porturi:
-'4321:5432'
mediu inconjurator:
POSTGRES_PASSWORD:„parola mea123”
POSTGRES_USER:'testUser'
volume:
-data:/var/lib/postgresql/data
volume:
date:

Acest cod va crea și rula două containere Docker. Primul recipient, Server, Docker Compose folosește fișierul Docker pentru a construi imaginea pentru acest container.

De asemenea, specifică că containerul serverului depinde de db recipient. Adică, cel Server containerul trebuie pornit după db container pentru a se conecta cu acesta.

Al doilea container este un container de bază de date PostgreSQL. Nu trebuie să specificați un fișier Docker pentru acest container, deoarece acesta va fi creat din imaginea PostgreSQL din registrul de imagini Docker.

Construiți imaginile Docker

Utilizați comanda Docker Compose pentru a construi imaginile și a porni cele două containere.

docker-compune până -d

Ar trebui să vedeți un răspuns similar după finalizarea cu succes a procesului.

Testați API-ul REST

Rulați comanda de mai jos pentru a testa API-ul REST care rulează în containerul Docker. Ar trebui să creeze un tabel în baza de date PostgreSQL.

docker exec docker_node-server-1 npm run migrate

Ar trebui să vedeți un răspuns similar.

Partajarea imaginilor Docker

Pasul final este împingerea imaginii Docker pentru aplicația dvs. Node.js în Docker Hub. Acest lucru este similar cu împingerea proiectelor dvs. în GitHub.

• Du-te la Docker Hub și creați un cont și conectați-vă la tabloul de bord al utilizatorului.
• Apoi, faceți clic pe Creați un depozit. Furnizați numele depozitului dvs. și setați vizibilitatea acestuia la oricare Public sau Privat și apoi faceți clic Crea.
• Pentru a împinge imaginea Docker a aplicației dvs. în Docker Hub, mai întâi trebuie să vă conectați la contul dvs. prin intermediul terminalului și apoi să furnizați numele de utilizator și parola.

conectare la docker

• Apoi, actualizați numele imaginii dvs. Docker pentru a se potrivi cu acest format: /. Rulați comanda de mai jos pentru a face această modificare:

 eticheta docker /

• În cele din urmă, împingeți-vă imaginea Docker.

 docker push /

Utilizarea Docker în dezvoltare

Acest ghid a atins doar o fracțiune din potențialul pe care îl poate oferi Docker. Cu toate acestea, acum puteți utiliza tehnologia de containerizare Docker pentru a împacheta orice aplicație și toate dependențele acesteia ca imagini care pot fi implementate în diferite dezvoltări, precum și în medii de producție precum cloud fără niciuna sughitul.