Använd Docker och Docker Compose för att sömlöst distribuera och köra dina Nest.js-applikationer.

"Men det fungerar på min dator..." utvecklarskämt belyser perfekt utmaningen med att distribuera och köra applikationer över olika system.

Det verkliga krånglet ligger i att konfigurera de nödvändiga beroenden och se till att mjukvaruversionerna är kompatibla med din applikation. En bra lösning på det här problemet innebär att använda containeriseringsteknik som Docker.

Det låter dig enkelt distribuera och köra applikationer – med alla nödvändiga beroenden – inom behållaravbildningen; eliminerar behovet av omfattande konfiguration i produktionssystem.

Förstå Docker och Docker Compose

Hamnarbetare är en utvecklingsplattform med öppen källkod som tillhandahåller containeriseringsteknik som används för att bygga och paketera applikationer tillsammans med deras beroenden som bärbara bilder.

Dessa bilder körs sedan som körbara komponenter i isolerade containermiljöer. Att köra applikationer i dessa behållare garanterar konsekvent applikationsprestanda över olika produktionssystem utan några kompatibilitetsproblem.

instagram viewer

Å andra sidan, Docker Compose är ett verktyg som används tillsammans med Docker för att förenkla processen för att definiera och hantera multi-container-applikationer.

Medan Docker främst används för att hantera enskilda behållare, låter Docker Compose dig hantera konfigurationen av flera behållare som måste köras som en enda applikation.

Detta är särskilt användbart när en applikation består av flera tjänster som måste fungera tillsammans, såsom flera beroende API-tjänster och databaser, bland annat.

Innan du dyker in i koden måste du installera Docker Desktop på din lokala dator. Gå igenom de systemspecifika kraven och installationsstegen från den officiella dokumentationen.

Du kan hitta denna applikations kod i dess GitHub förvaret.

Konfigurera ett Nest.js-projekt

Den här guiden leder dig genom processen att skapa två Docker-behållare som sömlöst fungerar som en enda Nest.js-applikation. Den första behållaren kommer att innehålla en instans av Nest.js webbserver Docker-avbildning, medan den andra behållaren kommer att köra Dockers PostgreSQL-databasavbildning.

För att komma igång installerar du kommandoradsverktyget Nest.js:

npm i -g @nestjs/cli

Skapa nu ett nytt Nest.js-projekt genom att köra kommandot nedan i din terminal.

nest new docker-nest-app

Därefter kommer CLI-verktyget att visa flera pakethanterare som du kan välja mellan för att skapa projektet. Välj ditt föredragna alternativ. I det här fallet kommer vi att använda npm, Node Package Manager.

Slutligen kan du navigera till projektkatalogen och snurra upp utvecklingsservern.

cd docker-nest-app
npm run start

Skapa databasmodulen

Installera först dessa beroenden:

npm install pg typeorm @nestjs/typeorm @nestjs/config

Skapa sedan en i ditt projekts rotkatalog .env fil och lägg till följande databasanslutningskonfigurationsvärden:

DATABASE_HOST="db"
DATABASE_PORT=5432
DATABASE_USER="testUser"
DATABASE_PASSWORD="mypassword123"

Slutligen, fortsätt och skapa databasmodulen.

nest g module database

Nu, efter att modulen har skapats, öppna databas/database.modul.ts fil och inkludera följande databaskonfigurationskod:

import { Module } from'@nestjs/common';
import { TypeOrmModule } from'@nestjs/typeorm';
import { ConfigModule, ConfigService } from'@nestjs/config'; 
@Module({
 imports: [
 ConfigModule.forRoot(), 
 TypeOrmModule.forRootAsync({
 imports: [ConfigModule], 
 useFactory: async (configService: ConfigService) => ({
type: 'postgres',
 host: configService.get<string>('DATABASE_HOST'), 
 port: configService.get<number>('DATABASE_PORT'),
 username: configService.get<string>('DATABASE_USER'),
 password: configService.get<string>('DATABASE_PASSWORD'),
 synchronize: true,
 }),
 inject: [ConfigService], 
 }),
 ],
})
exportclass DatabaseModule {}

När du väl har ställt in Docker PostgreSQL-bilden med den här TypeORM-konfigurationen kommer Nest.js-applikationen att upprätta en anslutning till databasen.

Uppdatera filen app.module.ts

Slutligen uppdaterar du huvudapplikationsmodulfilen så att den innehåller konfigurationen för databasmodulen.

import { Module } from'@nestjs/common';
import { ConfigModule } from'@nestjs/config';
import { AppController } from'./app.controller';
import { AppService } from'./app.service';
import { DatabaseModule } from'./database/database.module';
@Module({
 imports: [
 ConfigModule.forRoot({
 envFilePath: '.env', 
 }),
 DatabaseModule,
 ],
 controllers: [AppController],
 providers: [AppService],
})
exportclass AppModule {}

Konfigurera en dockerfil

En Dockerfil fångar den uppsättning instruktioner som krävs av Docker-motorn för att skapa en Docker-bild. Den här bilden omfattar programmets källkod och alla dess beroenden.

Skapa en ny fil i ditt projekts rotkatalog och namnge den Dockerfile. Lägg sedan till följande innehåll:

FROM node:16.3.0-alpine3.13
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY. .
RUN npm run build
CMD [ "npm", "run", "start: dev" ]

Här är vad varje kommando representerar:

  1. FRÅN: Den här instruktionen specificerar basbilden som Docker ska använda för att bygga programmets bild.
  2. WORKDIR: Detta kommando instruerar Docker att ställa in /app katalog som arbetskatalog för appen i behållaren.
  3. KOPIERApaket*.json./: Kopierar alla filer med det filnamnsformatet från den aktuella katalogen i programmet till app mapp.
  4. KÖR npm installation: Detta kommando kommer att installera de nödvändiga paketen och beroenden som krävs av applikationen i Docker-behållaren.
  5. KOPIERA. .: Instruerar Docker att kopiera alla programmets källkodsfiler från den aktuella katalogen till /app mapp.
  6. KÖR npm kör bygg: Kommandot bygger Nest.js-applikationen innan Docker-bilden skapas. Den kompilerar TypeScript-koden till JavaScript och lagrar byggprocessens utdata i en dist katalog.
  7. CMD: Definierar kommandot som ska köras när behållaren startar. I det här fallet kör vi npm körstart: dev kommando, som startar servern i utvecklingsläge.

Denna konfiguration gör det möjligt för applikationen att aktivt övervaka kodändringar. När ändringar upptäcks kommer behållaren automatiskt att byggas om.

Skapa Docker Compose-filen

Skapa en ny i rotkatalogen i din projektmapp docker-compose.yml fil och lägg till följande innehåll:

version:'3.9'
services:
server:
build:.
ports:
-'3000:3000'
depends_on:
-db
db:
image:'postgres'
ports:
-'5432:5432'
environment:
POSTGRES_PASSWORD:'mypassword123'
POSTGRES_USER:'testUser'
volumes:
-data:/var/lib/postgresql/data
volumes:
data:

Docker Compose kommer att använda dessa instruktioner för att bygga och köra de två bilderna i två Docker-behållare. Den första behållaren, servern, kommer att vara värd för programmets bild; körs på port 3000.

Den andra behållaren kommer att vara värd för PostgreSQL-databasavbildningen. Du behöver inte ange en Dockerfil för den här bilden – Docker kommer att använda den redan existerande PostgreSQL-avbildningen i Dockers bildregister för att bygga den.

Starta Docker Containers

Slutligen, fortsätt att bygga bilderna och starta behållarna genom att köra följande kommando:

docker compose up

När processen är klar bör du se liknande logginformation på din terminal.

Nu, med både din webbserver och databasbehållare igång, fortsätt och lägg till mer funktionalitet till din Nest.js-applikation. Du kan till exempel bygga ett Nest.js CRUD REST API.

Skickar Docker-bilder till Docker Hub

Att skjuta Docker-bilder till Docker Hub liknar nästan att skjuta projekt till GitHub. Följ dessa steg för att överföra Nest.js-applikationens Docker-bild till Docker Hub.

  1. Gå över till Docker Hub, registrera dig och logga in på ditt kontos översiktssida.
  2. Klicka på Skapa arkiv knappen, fyll i namnet på ditt förvar, ange dess synlighet genom att välja någondera offentlig eller Privat, och klicka sedan Skapa.
  3. Nu måste du logga in på ditt konto via terminalen genom att köra kommandot nedan och sedan ange ditt Docker-användarnamn och lösenord.
    docker login
  4. Uppdatera sedan Dockerns bildnamn så att det matchar detta format: / genom att köra kommandot nedan.
    docker tag /
  5. Till sist, tryck på Docker-bilden.
    docker push /

Använder Dockers containeriseringsteknik under utveckling

Dockers containeriseringsteknik gör att du kan bunta ihop en applikation tillsammans med alla dess beroenden till Docker-bilder. Dessa bilder kan sedan köras smidigt i containrar i olika utvecklings- och produktionsmiljöer utan problem.