Hvordan dockerisere en Node.js REST API

Prosessen med å distribuere og kjøre applikasjoner i forskjellige miljøer kan være en problemfri siden det er en rekke faktorer å vurdere for eksempel å sette opp miljøvariablene for å konfigurere de nødvendige avhengighetene og spesifikke versjoner av forskjellige programvarepakker.

Ved å bruke Dockers containeriseringsteknologi kan du imidlertid distribuere applikasjoner i forskjellige miljøer med minimal innsats med alle nødvendige avhengigheter i docker-bildet. Det betyr at du ikke trenger å bekymre deg for å gjøre noen konfigurasjon. Dette gjør prosessen med å distribuere og kjøre applikasjoner i forskjellige miljøer til en lek.

Hva er Docker?

Docker er en utviklingsplattform som gir verktøy og miljø for å pakke applikasjoner som bærbare bilder som kan kjøres som selvstendige kjørbare komponenter i containere.

Disse beholderne utgjør applikasjonens kode og de nødvendige avhengighetene for at applikasjonen skal kunne kjøres på forskjellige kjøretidsmiljøer uten problemer.

Før du begynner, installer Docker på din lokale maskin. Sjekk de plattformspesifikke forutsetningene og installasjonsinstruksjonene fra den offisielle dokumentasjonen.

Opprett en Node.js REST API

For å komme i gang, opprette en Node.js-webserver.

Du finner denne applikasjonens kode i dens GitHub-depot.

Installer deretter de nødvendige pakkene for dette prosjektet.

npm installer morgan pg knex

De s pakken brukes til å etablere en forbindelse med en PostgreSQL-database. knex, derimot, gir en enkel API for samhandling med PostgreSQL - du vil bruke den til å skrive SQL-spørringer.

Til slutt vil du bruke Morgan, en mellomvare som logger HTTP-forespørsler og svar på konsollen, for å feilsøke og overvåke applikasjonen din som kjører i en Docker-beholder.

Til slutt åpner du index.js fil, og legg til koden under den implementerer et enkelt REST API med tre ruter.

konst uttrykke = krever("uttrykke")
konst Morgan = krever("Morgan")
konst app = express()
konst db = krever('./db')
konst PORT = prosess.env. PORT || 5000
app.use (morgan('dev'))
app.use (express.json())
app.use (express.urlencoded({ forlenget: ekte }))
app.get('/', (req, res) => res.send('Hei Verden!' ))
app.get('/brukere', asynkron (req, res) => {
konst brukere = avvente db.select().from('brukere')
 res.json (brukere)
})
app.post('/brukere', asynkron (req, res) => {
konst bruker = avvente db('brukere').sett inn({ Navn: req.body.name }).returning('*')
 res.json (bruker)
})
app.listen (PORT, () => konsoll.Logg(`Server oppe ved PORT:${PORT}`))

Konfigurer databasetilkoblingen

REST API vil samhandle med Dockers PostgreSQL-forekomst, men du må først konfigurere databasetilkoblingen i applikasjonen din. Opprett en i rotkatalogen til prosjektmappen din db.js fil og legg til koden nedenfor.

konst knex = krever('knex')
modul.exports = knex({
 klient: 'postgres',
 forbindelse: {
 vert: 'db',
 bruker: 'testbruker',
 passord: 'mitt passord123',
 database: 'testbruker',

 },
})

Sett opp migrate.js- og seed.js-filene

Disse to filene vil gjøre det mulig å lage en tabell i databasen og fylle den med testdata via API. Lag en ny mappe, skript, i rotkatalogen til prosjektet og legg til to filer: migrate.js og frø.js.

I migrate.js fil, legg til koden nedenfor:

konst db = krever('../db');
(asynkron () => {
prøve {
avvente db.schema.dropTableIfExists('brukere')
avvente db.schema.withSchema('offentlig').createTable('brukere', (tabell) => {
 table.increments()
 table.string('Navn')
 })
konsoll.Logg('Opprettet brukertabell!')
 process.exit(0)
 } å fange (feil) {
konsoll.log (feil)
 process.exit(1)
 }
})()

Denne koden vil lage en brukere tabell med en automatisk økende id-kolonne og en Navn kolonne i databasen.

Neste, i frø.js fil, legg til koden nedenfor:

konst db = krever('../db');
(asynkron () => {
prøve {
avvente db('brukere').sett inn({ Navn: 'Testbruker1' })
avvente db('brukere').sett inn({ Navn: 'Testbruker2' })
konsoll.Logg('Lagt til dummy-brukere!')
 process.exit(0)
 } å fange (feil) {
konsoll.log (feil)
 process.exit(1)
 }
})()

Denne koden implementerer en asynkron funksjon som vil sette inn to brukere i PostgreSQL-databasen.

Til slutt, legg til disse kommandoene til din package.json fil.

"skript": {
"start": "node index.js",
"migre": "node scripts/migrate.js",
"frø": "node scripts/seed.js"
 },

Siden du ikke har en klient konfigurert, for å teste API-en, må du kjøre de to filene som skript ved siden av npm løp kommando.

Sett opp en Dockerfile

En Dockerfil definerer instruksjonene som kreves av Docker-motoren for å bygge et Docker-bilde. I rotkatalogen til prosjektet, lag en ny fil og navngi den, Dockerfil. Deretter legger du til følgende instruksjoner for å bygge et Docker-bilde for Node.js-applikasjonen.

FRA node:16.3.0-alpint 3.13
WORKDIR /app
KOPIERE pakke*.json ./
LØPE npm installere
KOPIERE. .
AVDEKKE8000
CMD [ "node", "index.js" ]

La oss bryte det ned:

• FRA - Denne instruksjonen setter basisbildet for applikasjonen, som er Node.js Alpine-bildet, en lett versjon av Node.js-bildet som finnes i Docker-registeret.
• WORKDIR - settene /app katalog som arbeidskatalog.
• KOPIERE pakke*.json./ - instruerer Docker å kopiere alle filer med det filnavnet format fra gjeldende katalog til /app mappe.
• LØPE - utfører og bygger opp bildet.
• KOPIERE.. - kopierer kildefilene til /app mappe.
• AVDEKKE - Dette instruerer Docker om å eksponere en port i beholderen for det eksterne miljøet, for dette tilfellet vertsmaskinen.
• CMD - spesifiserer kommandoen som skal utføres når Docker-beholderen opprettes fra bildet.

Opprett Docker Compose-filen

For at Node.js-applikasjonen skal samhandle med Dockers PostgreSQL-forekomst, må de to applikasjonene kjøre i Docker-beholdere innenfor samme nettverksmiljø.

Av denne grunn må du definere og bygge både programmets bilde og PostgreSQL-forekomsten ved hjelp av Docker Compose — et verktøy som lar deg bygge og administrere flere Docker-containere.

Enkelt sagt, ved å bruke en Docker Compose, kan du definere tjenestene som utgjør applikasjonen din som en enkelt enhet, for dette tilfellet, Node.js REST API og PostgreSQL-databasen.

Opprett en ny fil, docker-compose.yml, i rotkatalogen og legg til koden nedenfor:

versjon:'3.9'
tjenester:
server:
bygge:.
porter:
-'5000:5000'
kommer an på:
-db
db:
bilde:'postgres'
porter:
-'4321:5432'
miljø:
POSTGRES_PASSWORD:'mitt passord123'
POSTGRES_USER:'testbruker'
volumer:
-data:/var/lib/postgresql/data
volumer:
data:

Denne koden vil opprette og kjøre to Docker-beholdere. Den første beholderen, server, Docker Compose bruker Dockerfilen til å bygge bildet for denne beholderen.

Den spesifiserer også at serverbeholderen avhenger av db container. Det betyr at server beholderen må startes etter db beholder for å koble til den.

Den andre beholderen er en PostgreSQL-databasebeholder. Du trenger ikke spesifisere en Dockerfil for denne beholderen siden den vil bli opprettet fra PostgreSQL-bildet i Dockers bilderegister.

Bygg Docker-bildene

Bruk kommandoen Docker Compose til å bygge bildene og starte de to beholderne.

docker-komponere opp -d

Du bør se et lignende svar etter at prosessen er fullført.

Test REST API

Kjør kommandoen nedenfor for å teste REST API som kjører i Docker-beholderen. Det skal lage en tabell i PostgreSQL-databasen.

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

Du bør se et lignende svar.

Deling av Docker-bildene

Det siste trinnet er å skyve Docker-bildet for Node.js-applikasjonen til Docker Hub. Dette ligner på å skyve prosjektene dine til GitHub.

• Gå over til Docker Hub og registrer deg for en konto og logg inn på brukerdashbordet.
• Klikk deretter på Opprett et depot. Oppgi navnet på depotet ditt og sett dets synlighet til enten Offentlig eller Privat og klikk deretter Skape.
• For å sende programmets Docker-bilde til Docker Hub, må du først logge på kontoen din via terminalen og deretter oppgi brukernavn og passord.

docker-pålogging

• Deretter oppdaterer du navnet på Docker-bildet ditt for å matche dette formatet: /. Kjør kommandoen nedenfor for å gjøre denne endringen:

 docker tag /

• Til slutt, skyv Docker-bildet ditt.

 docker push /< reponavn>

Bruke Docker i utvikling

Denne guiden berørte bare en brøkdel av potensialet Docker kan tilby. Imidlertid kan du nå bruke Dockers containeriseringsteknologi til å pakke enhver applikasjon og alle dens avhengigheter som bilder som kan distribueres i forskjellig utvikling, samt produksjonsmiljøer som skyen uten noen hikke.