Hoe Nest.js-applicaties te containeriseren met Docker en Docker Compose

“Maar het werkt op mijn computer…” een grapje van een ontwikkelaar geeft perfect de uitdaging weer van het implementeren en uitvoeren van applicaties op verschillende systemen.

Navigeren door de complexiteit van afhankelijkheidsconfiguratie en versiecompatibiliteit kan een ontmoedigende taak zijn voor ontwikkelaars. Er is echter een effectieve aanpak die deze uitdagingen kan verlichten door gebruik te maken van containerisatie technologieën zoals Docker. Deze aanpak vereenvoudigt het proces door alle benodigde componenten in te kapselen in een op zichzelf staande omgeving, waardoor potentiële conflicten worden verminderd en implementatieprocessen worden gestroomlijnd.

Het platform stelt gebruikers in staat om applicaties naadloos te implementeren en uit te voeren, samen met de benodigde componenten, binnen een gecontaineriseerde omgeving, waardoor ingewikkelde installatieprocedures in productieomgevingen overbodig worden.

Docker en Docker Compose begrijpen

Docker is een open-source ontwikkelplatform dat containerisatietechnologie biedt die wordt gebruikt bij het bouwen en verpakken van applicaties samen met hun afhankelijkheden als draagbare images.

De eerder genoemde afbeeldingen worden vervolgens uitgevoerd in de vorm van uitvoerbare modules binnen op zichzelf staande containerinstellingen. De inzet van toepassingen binnen dergelijke grenzen zorgt voor uniformiteit in termen van prestatieconsistentie voor diverse productieplatforms, zonder potentiële discrepanties of interoperabiliteitshindernissen.

Docker Compose dient als een hulpinstrument wanneer het wordt gebruikt in combinatie met Docker, waardoor het instellen en beheren van multicontainerapplicaties wordt gestroomlijnd.

Docker Compose breidt de functionaliteit van Docker uit door het beheer van meerdere containers mogelijk te maken die samen een enkele applicatie vormen.

Deze aanpak is vooral voordelig in scenario’s waar een softwaretoepassing meerdere onderling afhankelijke services bevat, inclusief maar niet beperkt tot verschillende databasesystemen en meerdere API-services met wederzijdse afhankelijkheden.

Voordat je in de code duikt, moet je Docker Desktop installeren op je lokale machine. Doorloop de systeemspecifieke vereisten en installatiestappen uit de officiële documentatie.

Je kunt de broncode van deze software vinden in deGitHub repository, die dient als een digitaal archiverings- en versiebeheersysteem voor het bijhouden van wijzigingen aan het programma in de loop der tijd.

Een Nest.js-project opzetten

Deze tutorial beschrijft de procedure om twee Docker-containers in tandem te implementeren om als een verenigde Nest.js-toepassing te functioneren. De eerste container host een instantiatie van de Nest.js webserver Docker image, en de volgende container draait de Docker PostgreSQL database image.

Om het proces te starten, moet het hulpprogramma Nest.js Command Line Interface (CLI) worden geïnstalleerd. Dit biedt een handige manier om met je project te communiceren en verschillende commando’s vanaf de terminal uit te voeren.

 npm i -g @nestjs/cli 

Om een nieuw Nest.js-project op te zetten met behulp van de Terminal, voer je de volgende opdracht uit in het Terminal-venster:

 nest new docker-nest-app 

Na het selecteren van ‘Create Project’ wordt een lijst met beschikbare pakketbeheerders weergegeven. Selecteer nu de gewenste. Laten we omwille van het voorbeeld kiezen voor ’npm’, wat de Node Package Manager is.

Ten slotte kan men naar de map van het project navigeren en de ontwikkelserver starten.

 cd docker-nest-app
npm run start 

De databasemodule aanmaken

Installeer eerst deze afhankelijkheden:

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

Maak in de hoofdmap van je project een bestand “.env” aan en voeg de volgende configuraties voor de databaseverbinding in:

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

Ga ten slotte verder met het aanmaken van de databasemodule.

 nest g module database 

Nadat u een nieuwe module hebt gemaakt in Visual Studio Code, opent u het bestand “database/database.module.ts” en voegt u de volgende code voor database-instellingen in:

 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],
     }),
  ],
})

export class DatabaseModule {} 

Na het implementeren van de gespecificeerde Docker PostgreSQL configuratie binnen je TypeORM setup, zal je Nest.js applicatie succesvol verbinding maken met de database.

Werk het bestand app.module.ts bij

Wijzig ten slotte het primaire applicatiemodulebestand om de instellingen voor de databasemodule te integreren.

 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],
})

export class AppModule {} 

Een Dockerfile opzetten

Een Dockerfile dient als een blauwdruk die de noodzakelijke stappen specificeert voor het bouwen van een Docker image, dat de broncode van de applicatie bevat samen met alle vereiste afhankelijkheden.

Maak in de hoofdmap van je project een nieuw document aan met de naam “Dockerfile”. Voeg vervolgens de volgende onderdelen toe aan het document:

 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" ] 

Hier is wat elk commando vertegenwoordigt:

De bovenstaande richtlijn bepaalt de basis waarop Docker de opdracht krijgt om de visuele weergave van de software, een image, te bouwen.

De eerder genoemde richtlijn dicteert dat de map /app wordt aangewezen als de actieve werkruimte voor de activiteiten van de applicatie binnen de grenzen van de Docker-container.

Het bestand package.json kopieert automatisch alle bestanden binnen het gespecificeerde formaat van de huidige projectmap naar de map “app” als onderdeel van het configuratieproces.

De eerder genoemde stap omvat het uitvoeren van het commando “npm install”, dat de installatie mogelijk maakt van alle benodigde pakketten en afhankelijkheden die nodig zijn voor het goed functioneren van de applicatie binnen de grenzen van de Docker-container.

Docker wordt geïnstrueerd om alle inhoud van de applicatiebronbestanden van de huidige werkmap te repliceren in de aangewezen subdirectory ‘/app’ door middel van deze richtlijn.

Om de Nest.js-toepassing uit te voeren, is de voorgestelde stap om eerst het bouwproces te starten door het npm run build commando uit te voeren. Hierbij wordt de TypeScript broncode omgezet naar het overeenkomstige JavaScript equivalent met behulp van de gespecificeerde presets en plugins. Tegelijkertijd produceert het een geoptimaliseerde bundel in de map dist voor verdere implementatie of uitvoering.

De gegeven tekst beschrijft een Dockerfile instructie die het commando specificeert dat moet worden uitgevoerd wanneer de container wordt gestart. Specifiek stuurt het de uitvoering van een npm run start:dev commando, dat de server in zijn ontwikkelingsstatus start.

De bovenstaande configuratie stelt de softwaretoepassing in staat om wijzigingen in de broncode zorgvuldig te observeren. Bij het identificeren van wijzigingen is de container geprogrammeerd om een automatisch reconstructieproces te starten.

Maak het Docker Compose-bestand

Maak in de hoofdmap van je projectwerkruimte een nieuw docker-compose.yml-document aan. Voeg vervolgens de volgende bepalingen toe aan dit nieuwe bestand:

 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 zal de gegeven richtlijnen gebruiken voor het bouwen en uitvoeren van twee Docker-images in twee aparte Docker-containers. De eerste container, aangeduid als de “server”, dient als platform voor het hosten van het applicatie-image en is toegankelijk via poort 3000.

De tweede container bevat het PostgreSQL database image, dat wordt opgebouwd uit een bestaand PostgreSQL image uit de Docker image repository. Er is geen apart Dockerbestand nodig, omdat de benodigde instructies al in het voorgebouwde image zitten.

De Docker-containers starten

Voer tot slot het volgende commando uit om de images te maken en de containers te starten:

 docker compose up 

Na succesvolle uitvoering van het proces wordt verwacht dat een vergelijkbare set loggegevens wordt weergegeven in de terminaluitvoer van uw systeem.

Zodra zowel de webserver als de databasecontainers operationeel zijn, is het tijd om de mogelijkheden van onze Nest.js-applicatie verder uit te breiden. Een van die uitbreidingen zou een gebruikersvriendelijke interface kunnen zijn voor interactie met gegevens die zijn opgeslagen in de PostgreSQL database met behulp van een CRUD (Create, Read, Update, Delete) RESTful API die is gebouwd op het Nest.js framework.

Docker-images naar Docker Hub pushen

Docker-images naar Docker Hub overzetten lijkt sterk op het indienen van projecten bij GitHub. Volg dit proces om de Nest.js applicatie Docker image te uploaden:

⭐ Ga naar Docker Hub , meld je aan en log in op de overzichtspagina van je account.

⭐ Klik op de knop Maak repository, vul de naam van uw repository in, specificeer de zichtbaarheid door Public of Private te selecteren en klik vervolgens op Create .

⭐ Nu moet je inloggen op je account via de terminal door het onderstaande commando uit te voeren en vervolgens je Docker gebruikersnaam en wachtwoord op te geven.

 docker login 

⭐ Werk vervolgens de Docker-afbeeldingsnaam bij in dit formaat: / door het onderstaande commando uit te voeren.

 docker tag <image> <your docker username>/<repo name> 

⭐ Plaats ten slotte de Docker-image.

 docker push <image>/<repo name> 

Dockers containerisatietechnologie gebruiken in ontwikkeling

Dockers containeriseringsmogelijkheden maken het mogelijk om applicaties, samen met hun vereiste afhankelijkheden, te bundelen in Docker-images. Dit zorgt ervoor dat deze images naadloos functioneren in verschillende ontwikkel- en productieomgevingen zonder complicaties of compatibiliteitsproblemen.