Hur man dockeriserar ett Node.js REST API

Processen att distribuera och köra applikationer i olika miljöer kan vara besvärligt eftersom det finns ett antal faktorer att ta hänsyn till som att ställa in miljövariablerna för att konfigurera nödvändiga beroenden och specifika versioner av olika programvarupaket.

Men genom att använda Dockers containeriseringsteknik kan du distribuera applikationer i olika miljöer med minimal ansträngning med alla nödvändiga beroenden i docker-bilden. Det betyder att du inte behöver oroa dig för att göra någon konfiguration. Detta gör processen att distribuera och köra applikationer i olika miljöer till en lek.

Vad är Docker?

Hamnarbetare är en utvecklingsplattform som tillhandahåller verktyg och miljö för att paketera applikationer som bärbara bilder som kan köras som fristående körbara komponenter i behållare.

Dessa behållare utgör applikationens kod och de beroenden som krävs för att applikationen ska kunna köras framgångsrikt i olika körningsmiljöer utan problem.

Innan du börjar installera Docker på din lokala dator. Kontrollera de plattformsspecifika förutsättningarna och installationsinstruktionerna från den officiella dokumentationen.

Skapa ett Node.js REST API

För att starta, skapa en Node.js webbserver.

Du kan hitta denna applikations kod i dess GitHub-förråd.

Installera sedan de paket som krävs för detta projekt.

npm installera morgan pg knex

De sid paketet används för att upprätta en anslutning till en PostgreSQL-databas. knex, å andra sidan, tillhandahåller ett enkelt API för att interagera med PostgreSQL — du kommer att använda det för att skriva SQL-frågor.

Slutligen kommer du att använda morgan, en mellanprogramvara som loggar HTTP-förfrågningar och svar på konsolen, för att felsöka och övervaka din applikation som körs i en Docker-behållare.

Öppna slutligen index.js fil och lägg till koden nedanför implementerar ett enkelt REST API med tre rutter.

konst uttrycka = behöva("uttrycka")
konst morgan = behöva("morgan")
konst app = express()
konst db = behöva('./db')
konst PORT = process.env. PORT || 5000
app.use (morgan('dev'))
app.use (express.json())
app.use (express.urlencoded({ förlängt: Sann }))
app.get('/', (req, res) => res.send('Hej världen!' ))
app.get('/användare', asynkron (req, res) => {
konst användare = vänta db.select().from("användare")
 res.json (användare)
})
app.post('/användare', asynkron (req, res) => {
konst användare = vänta db("användare").Föra in({ namn: req.body.name }).returning('*')
 res.json (användare)
})
app.lyssna (PORT, () => trösta.logga(`Server uppe vid PORT:${PORT}`))

Konfigurera databasanslutningen

REST API kommer att interagera med Dockers PostgreSQL-instans, men du måste först konfigurera databasanslutningen i din applikation. I rotkatalogen i din projektmapp skapar du en db.js fil och lägg till koden nedan.

konst knex = behöva("knex")
modul.exports = knex({
 klient: "postgres",
 anslutning: {
 värd: 'db',
 användare: "testanvändare",
 Lösenord: "mitt lösenord123",
 databas: "testanvändare",

 },
})

Konfigurera filerna migrate.js och seed.js

Dessa två filer kommer att göra det möjligt att skapa en tabell i databasen och fylla den med testdata via API: et. Skapa en ny mapp, skript, i rotkatalogen för ditt projekt och lägg till två filer: migrate.js och seed.js.

I den migrate.js fil, lägg till koden nedan:

konst db = behöva('../db');
(asynkron () => {
Prova {
vänta db.schema.dropTableIfExists("användare")
vänta db.schema.withSchema('offentlig').skapa bord("användare", (tabell) => {
 table.increments()
 table.string('namn')
 })
trösta.logga('Skapade användartabell!')
 process.exit(0)
 } fånga (fel) {
trösta.log (fel)
 process.exit(1)
 }
})()

Denna kod kommer att skapa en användare tabell med en automatiskt ökande id-kolumn och en namn kolumn i databasen.

Nästa, i seed.js fil, lägg till koden nedan:

konst db = behöva('../db');
(asynkron () => {
Prova {
vänta db("användare").Föra in({ namn: "Testa användare1" })
vänta db("användare").Föra in({ namn: "Testa användare2" })
trösta.logga("Lade till dummy-användare!")
 process.exit(0)
 } fånga (fel) {
trösta.log (fel)
 process.exit(1)
 }
})()

Denna kod implementerar en asynkron funktion som kommer att infoga två användare i PostgreSQL-databasen.

Lägg slutligen till dessa kommandon till din package.json fil.

"skript": {
"Start": "node index.js",
"flytta": "nodskript/migrate.js",
"utsäde": "nodskript/seed.js"
 },

Eftersom du inte har en klient konfigurerad, för att testa API: t, måste du köra de två filerna som skript tillsammans med npm köra kommando.

Konfigurera en dockerfil

En Dockerfil definierar instruktionerna som krävs av Docker-motorn för att bygga en Docker-avbildning. Skapa en ny fil i ditt projekts rotkatalog och namnge den, Dockerfil. Lägg sedan till följande instruktioner för att bygga en Docker-avbildning för Node.js-applikationen.

FRÅN nod:16.3.0-alpint 3.13
WORKDIR /app
KOPIERA paket*.json ./
SPRINGA npm installera
KOPIERA. .
ÖVERSIKT8000
CMD [ "nod", "index.js" ]

Låt oss bryta ner det:

• FRÅN - Den här instruktionen ställer in basbilden för applikationen, vilket är Node.js Alpine-avbildningen, en lättviktsversion av Node.js-bilden som finns i Docker-registret.
• WORKDIR - set /app katalog som arbetskatalog.
• KOPIERA paket*.json./ - instruerar Docker att kopiera alla filer med det filnamnsformatet från den aktuella katalogen till /app mapp.
• SPRINGA - exekverar och bygger upp bilden.
• KOPIERA.. - kopierar källfilerna till /app mapp.
• ÖVERSIKT - Detta instruerar Docker att exponera en port i behållaren för den externa miljön, i detta fall värddatorn.
• CMD - anger kommandot som ska köras när Docker-behållaren skapas från bilden.

Skapa Docker Compose-filen

För att Node.js-applikationen ska kunna interagera med Dockers PostgreSQL-instans måste de två applikationerna köras i Docker-behållare inom samma nätverksmiljö.

Av denna anledning måste du definiera och bygga både programmets bild och PostgreSQL-instansen med hjälp av Docker Compose — ett verktyg som låter dig bygga och hantera flera Docker-containrar.

Enkelt uttryckt, med hjälp av en Docker Compose kan du definiera tjänsterna som utgör din applikation som en enda enhet, för det här fallet, Node.js REST API och PostgreSQL-databasen.

Skapa en ny fil, docker-compose.yml, i rotkatalogen och lägg till koden nedan:

version:'3.9'
tjänster:
server:
bygga:.
hamnar:
-'5000:5000'
beror på:
-db
db:
bild:"postgres"
hamnar:
-'4321:5432'
miljö:
POSTGRES_PASSWORD:"mitt lösenord123"
POSTGRES_USER:"testanvändare"
volymer:
-data:/var/lib/postgresql/data
volymer:
data:

Denna kod kommer att skapa och köra två Docker-behållare. Den första behållaren, server, Docker Compose använder Dockerfilen för att bygga bilden för den här behållaren.

Den specificerar också att serverbehållaren beror på db behållare. Det betyder att server behållaren måste startas efter db behållare för att ansluta till den.

Den andra behållaren är en PostgreSQL-databasbehållare. Du behöver inte ange en Dockerfil för den här behållaren eftersom den kommer att skapas från PostgreSQL-avbildningen i Dockers bildregister.

Bygg Docker-bilderna

Använd kommandot Docker Compose för att bygga bilderna och starta de två behållarna.

docker-compose up -d

Du bör se ett liknande svar efter att processen har slutförts.

Testa REST API

Kör kommandot nedan för att testa REST API som körs i Docker-behållaren. Det bör skapa en tabell i PostgreSQL-databasen.

docker exec docker_node-server-1 npm kör migrera

Du borde se ett liknande svar.

Dela Docker-bilderna

Det sista steget är att skicka Docker-bilden för din Node.js-applikation till Docker Hub. Detta liknar att skjuta dina projekt till GitHub.

• Gå över till Docker Hub och registrera dig för ett konto och logga in på användarpanelen.
• Klicka sedan på Skapa ett arkiv. Ange namnet på ditt arkiv och ställ in dess synlighet till antingen offentlig eller Privat och klicka sedan Skapa.
• För att skicka din applikations Docker-bild till Docker Hub måste du först logga in på ditt konto via terminalen och sedan ange ditt användarnamn och lösenord.

docker login

• Uppdatera sedan namnet på din Docker-bild för att matcha detta format: /. Kör kommandot nedan för att göra denna ändring:

 docker tag /

• Till sist, tryck på din Docker-bild.

 hamnarbetare /< reponamn>

Använder Docker i utveckling

Den här guiden berörde bara en bråkdel av den potential som Docker kan erbjuda. Men du kan nu använda Dockers containeriseringsteknik för att paketera vilken applikation som helst och alla dess beroenden som bilder som kan distribueras i olika utvecklingar, såväl som produktionsmiljöer som molnet utan några hicka.