Sådan dockeriseres en Node.js REST API

Processen med at implementere og køre applikationer i forskellige miljøer kan være besværligt, da der er en række faktorer at overveje såsom opsætning af miljøvariabler til at konfigurere de nødvendige afhængigheder og specifikke versioner af forskellige softwarepakker.

Men ved at bruge Dockers containeriseringsteknologi kan du implementere applikationer i forskellige miljøer med minimal indsats med alle de nødvendige afhængigheder i docker-billedet. Det betyder, at du ikke behøver at bekymre dig om at lave nogen konfiguration. Dette gør processen med at implementere og køre applikationer i forskellige miljøer til en leg.

Hvad er Docker?

Docker er en udviklingsplatform, der giver værktøjerne og miljøet til at pakke applikationer som bærbare billeder, der kan køres som selvstændige eksekverbare komponenter i containere.

Disse containere udgør applikationens kode og de nødvendige afhængigheder for, at applikationen kan køre med succes på forskellige runtime-miljøer uden problemer.

Inden du går i gang, skal du installere Docker på din lokale maskine. Tjek de platformspecifikke forudsætninger og installationsinstruktioner fra den officielle dokumentation.

Opret en Node.js REST API

For at komme i gang, oprette en Node.js-webserver.

Du kan finde denne applikations kode i dens GitHub-depot.

Installer derefter de nødvendige pakker til dette projekt.

npm installer morgan pg knex

Det pg pakke bruges til at etablere en forbindelse med en PostgreSQL-database. knex, på den anden side, giver en simpel API til at interagere med PostgreSQL - du vil bruge den til at skrive SQL-forespørgsler.

Til sidst vil du bruge morgan, en middleware, der logger HTTP-anmodninger og -svar på konsollen, for at fejlsøge og overvåge din applikation, der kører i en Docker-container.

Åbn endelig index.js fil, og tilføj koden nedenfor implementerer en simpel REST API med tre ruter.

konst udtrykke = kræve("udtrykke")
konst morgan = kræve("morgan")
konst app = express()
konst db = kræve('./db')
konst PORT = proces.env. PORT || 5000
app.use (morgan('dev'))
app.use (express.json())
app.use (express.urlencoded({ udvidet: rigtigt }))
app.get('/', (req, res) => res.send('Hej Verden!' ))
app.get('/brugere', asynkron (req, res) => {
konst brugere = vente db.select().fra('brugere')
 res.json (brugere)
})
app.post('/brugere', asynkron (req, res) => {
konst bruger = vente db('brugere').insert({ navn: req.body.name }).returning('*')
 res.json (bruger)
})
app.lyt (PORT, () => konsol.log(`Server oppe ved PORT:${PORT}`))

Konfigurer databaseforbindelsen

REST API'en vil interagere med Dockers PostgreSQL-instans, men du skal først konfigurere databaseforbindelsen i din applikation. I rodmappen i din projektmappe skal du oprette en db.js fil og tilføj koden nedenfor.

konst knex = kræve('knex')
modul.exports = knex({
 klient: 'postgres',
 forbindelse: {
 vært: 'db',
 bruger: 'testbruger',
 adgangskode: 'mypassword123',
 database: 'testbruger',

 },
})

Konfigurer migrate.js- og seed.js-filerne

Disse to filer vil gøre det muligt at oprette en tabel i databasen og udfylde den med testdata via API'en. Opret en ny mappe, scripts, i dit projekts rodbibliotek og tilføj to filer: migrate.js og frø.js.

I den migrate.js fil, tilføj koden nedenfor:

konst db = kræve('../db');
(asynkron () => {
prøve {
vente db.schema.dropTableIfExists('brugere')
vente db.schema.withSchema('offentlig').createTable('brugere', (tabel) => {
 table.increments()
 table.string('navn')
 })
konsol.log('Oprettet brugertabel!')
 process.exit(0)
 } fangst (fejl) {
konsol.log (fejl)
 process.exit(1)
 }
})()

Denne kode vil skabe en brugere tabel med en automatisk stigende id-kolonne og en navn kolonne i databasen.

Dernæst i frø.js fil, tilføj koden nedenfor:

konst db = kræve('../db');
(asynkron () => {
prøve {
vente db('brugere').insert({ navn: 'Testbruger1' })
vente db('brugere').insert({ navn: 'Testbruger2' })
konsol.log('Tilføjet dummy-brugere!')
 process.exit(0)
 } fangst (fejl) {
konsol.log (fejl)
 process.exit(1)
 }
})()

Denne kode implementerer en asynkron funktion, der vil indsætte to brugere i PostgreSQL-databasen.

Tilføj endelig disse kommandoer til din package.json fil.

"scripts": {
"Start": "node index.js",
"migrere": "node scripts/migrate.js",
"frø": "node scripts/seed.js"
 },

Da du ikke har en klient konfigureret, for at teste API'en, skal du køre de to filer som scripts sammen med npm løb kommando.

Konfigurer en Dockerfile

En Dockerfil definerer instruktionerne, der kræves af Docker-motoren for at bygge et Docker-billede. I dit projekts rodmappen skal du oprette en ny fil og navngive den, Dockerfil. Tilføj derefter følgende instruktioner for at bygge et Docker-image til Node.js-applikationen.

FRA node:16.3.0-alpint 3.13
WORKDIR /app
KOPI pakke*.json ./
LØB npm installere
KOPI. .
UDSÆTTE8000
CMD [ "node", "index.js" ]

Lad os opdele det:

• FRA - Denne instruktion angiver basisbilledet for applikationen, som er Node.js Alpine-billedet, en letvægtsversion af Node.js-billedet, der kan findes i Docker-registret.
• WORKDIR - sæt /app bibliotek som arbejdsbibliotek.
• KOPI pakke*.json./ - instruerer Docker om at kopiere alle filer med det filnavnsformat fra den aktuelle mappe til /app folder.
• LØB - eksekverer og bygger billedet op.
• KOPI.. - kopierer kildefilerne til /app folder.
• UDSÆTTE - dette instruerer Docker om at udsætte en port i containeren for det eksterne miljø, i dette tilfælde værtsmaskinen.
• CMD - angiver den kommando, der skal udføres, når Docker-beholderen oprettes fra billedet.

Opret Docker Compose-filen

For at Node.js-applikationen kan interagere med Dockers PostgreSQL-instans, skal de to applikationer køre i Docker-containere i det samme netværksmiljø.

Af denne grund skal du definere og bygge både applikationens image og PostgreSQL-instansen vha Docker Compose — et værktøj, der giver dig mulighed for at bygge og administrere flere Docker-containere.

Kort sagt, ved hjælp af en Docker Compose kan du definere de tjenester, der udgør din applikation, som en enkelt enhed, i dette tilfælde Node.js REST API og PostgreSQL-databasen.

Opret en ny fil, docker-compose.yml, i rodmappen og tilføj koden nedenfor:

version:'3.9'
tjenester:
server:
bygge:.
havne:
-'5000:5000'
afhænger af:
-db
db:
billede:'postgres'
havne:
-'4321:5432'
miljø:
POSTGRES_PASSWORD:'mypassword123'
POSTGRES_USER:'testbruger'
mængder:
-data:/var/lib/postgresql/data
mængder:
data:

Denne kode vil oprette og køre to Docker-containere. Den første container, server, Docker Compose bruger Dockerfilen til at bygge billedet til denne container.

Det specificerer også, at servercontaineren afhænger af db beholder. Det vil sige server container skal startes efter db beholder for at forbinde med den.

Den anden container er en PostgreSQL-databasecontainer. Du behøver ikke at angive en Dockerfil for denne container, da den vil blive oprettet fra PostgreSQL-billedet på Dockers billedregistrering.

Byg Docker-billederne

Brug kommandoen Docker Compose til at bygge billederne og starte de to containere.

docker-komponere op -d

Du bør se et lignende svar, efter at processen er gennemført.

Test REST API

Kør kommandoen nedenfor for at teste REST API, der kører i Docker-beholderen. Det skal oprette en tabel i PostgreSQL-databasen.

docker exec docker_node-server-1 npm køre migrere

Du bør se et lignende svar.

Deling af Docker-billederne

Det sidste trin er at skubbe Docker-billedet til din Node.js-applikation til Docker Hub. Dette svarer til at skubbe dine projekter til GitHub.

• Gå over til Docker Hub og tilmeld dig en konto og log ind på brugerdashboardet.
• Klik derefter på Opret et lager. Angiv navnet på dit lager, og indstil dets synlighed til enten Offentlig eller Privat og klik derefter skab.
• For at skubbe din applikations Docker-billede til Docker Hub skal du først logge ind på din konto via terminalen og derefter angive dit brugernavn og din adgangskode.

docker login

• Opdater derefter navnet på dit Docker-billede, så det matcher dette format: /. Kør kommandoen nedenfor for at foretage denne ændring:

 docker tag /

• Skub endelig dit Docker-billede.

 docker-skub /< reponavn>

Brug af Docker i udvikling

Denne guide berørte kun en brøkdel af det potentiale, Docker kan tilbyde. Du kan dog nu bruge Dockers containeriseringsteknologi til at pakke enhver applikation og alle dens afhængigheder som billeder, der kan implementeres i forskellig udvikling, såvel som produktionsmiljøer som skyen uden nogen hikke.