Deployer NestJS sur DigitalOcean

Pourquoi Deployer NestJS sur DigitalOcean ?

Le déploiement d'une application NestJS sur DigitalOcean offre une solution flexible et performante pour les développeurs. En utilisant ce service, vous pouvez facilement échelloner votre application à la demande en ajustant le nombre de machines virtuelles (VM) selon vos besoins. De plus, DigitalOcean offre des ressources matérielles puissantes et des options de stockage fiables, ce qui est idéal pour les applications nécessitant une grande charge de travail.

Un cas d'utilisation concret serait l'implémentation d'une application de gestion de tâches en ligne. Avec un déploiement sur DigitalOcean, vous pouvez facilement gérer la mise à l'échelle de votre application lorsque le nombre de utilisateurs augmente, tout en assurant une performance optimale.

Prerequis

• Connaissance approfondie de NestJS et des concepts liés aux applications Node.js.
• Un compte DigitalOcean avec suffisamment d'argent pour couvrir les coûts du service.
• Un ordinateur sur lequel vous pouvez installer et exécuter les outils nécessaires (Node.js, npm).
• Git installé pour cloner le dépôt de votre projet.

Concepts fondamentaux

1. Création d'une Instance Droplet

Une Droplet est un conteneur virtuel qui fonctionne comme une machine physique sur l'infrastructure DigitalOcean. Voici comment créer une instance Droplet :

## Accédez à la console DigitalOcean et créez une nouvelle Droplet
## Choisissez une image OS (par exemple Ubuntu 20.04)
## Sélectionnez un plan approprié en fonction de vos besoins
## Configurez les paramètres réseau comme le nom du domaine, l'IPv4, etc.

2. Connexion à votre Droplet

Une fois que votre Droplet est créée, vous pouvez vous y connecter via SSH :

ssh root@<votre_ip_droplet>

3. Configuration de la Sécurité

Assurez-vous que votre Droplet est sécurisé en configurant les règles de pare-feu et en installant des logiciels antivirus.

## Installez le pare-feu UFW (Uncomplicated Firewall)
sudo apt update
sudo apt install ufw

## Activez UFW
sudo ufw enable

## Autorisez le port SSH
sudo ufw allow ssh

## Autorisez le port HTTP et HTTPS si vous utilisez une application web
sudo ufw allow http
sudo ufw allow https

4. Installation de Node.js et npm

Installez Node.js et npm sur votre Droplet :

## Ajoutez la source PPA pour Node.js
curl -sL https://deb.nodesource.com/setup_16.x | sudo -E bash -

## Installez Node.js et npm
sudo apt install -y nodejs

## Vérifiez l'installation
node -v
npm -v

5. Configuration de votre Projet NestJS

Clonez votre projet NestJS sur le serveur :

git clone <url_votre_projet>
cd votre_projet

Installez les dépendances du projet :

npm install

Mise en pratique : projet fil rouge

Nous allons créer une application simple de gestion de tâches en utilisant NestJS. L'application aura les fonctionnalités suivantes :

• Créer une tâche
• Mettre à jour une tâche
• Supprimer une tâche
• Afficher toutes les tâches

Étape 1 : Initialisation du Projet

Créez un nouveau projet NestJS :

nest new task-manager
cd task-manager

Étape 2 : Création de la Entité Tâche

Créez une entité pour représenter une tâche dans votre base de données.

// src/tasks/task.entity.ts
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

@Entity()
export class Task {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ length: 255 })
  title: string;

  @Column({ type: 'boolean', default: false })
  completed: boolean;
}

Étape 3 : Création du Modèle

Créez un modèle pour interagir avec la base de données.

// src/tasks/task.model.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Task } from './task.entity';

@Injectable()
export class TaskModel {
  constructor(
    @InjectRepository(Task)
    private readonly taskRepository: Repository<Task>,
  ) {}

  async createTask(taskData: Partial<Task>): Promise<Task> {
    return this.taskRepository.save(taskData);
  }

  async getTasks(): Promise<Task[]> {
    return this.taskRepository.find();
  }

  async updateTask(id: number, taskData: Partial<Task>): Promise<void> {
    await this.taskRepository.update(id, taskData);
  }

  async deleteTask(id: number): Promise<void> {
    await this.taskRepository.delete(id);
  }
}

Étape 4 : Création du Contrôleur

Créez un contrôleur pour gérer les requêtes HTTP.

// src/tasks/task.controller.ts
import { Controller, Get, Post, Put, Delete, Body, Param } from '@nestjs/common';
import { TaskModel } from './task.model';

@Controller('tasks')
export class TaskController {
  constructor(private readonly taskModel: TaskModel) {}

  @Post()
  async createTask(@Body() taskData: Partial<Task>): Promise<Task> {
    return this.taskModel.createTask(taskData);
  }

  @Get()
  async getTasks(): Promise<Task[]> {
    return this.taskModel.getTasks();
  }

  @Put(':id')
  async updateTask(
    @Param('id') id: number,
    @Body() taskData: Partial<Task>,
  ): Promise<void> {
    await this.taskModel.updateTask(id, taskData);
  }

  @Delete(':id')
  async deleteTask(@Param('id') id: number): Promise<void> {
    await this.taskModel.deleteTask(id);
  }
}

Étape 5 : Configuration de la Base de Données

Configurez la base de données dans votre fichier app.module.ts :

// src/app.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TaskController } from './tasks/task.controller';
import { TaskModel } from './tasks/task.model';
import { TaskEntity } from './tasks/task.entity';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'your_username',
      password: 'your_password',
      database: 'task_manager',
      entities: [TaskEntity],
      synchronize: true,
    }),
    TypeOrmModule.forFeature([TaskModel]),
  ],
  controllers: [TaskController],
})
export class AppModule {}

Étape 6 : Exécution de l'Application

Exécutez votre application NestJS sur le serveur :

npm run start:prod

Erreurs frequentes et debugging

1. Erreur : "Cannot find module 'typeorm'"

   // Code incorrect
   import { TypeOrmModule } from '@nestjs/typeorm';
   
   // Correction
   npm install --save typeorm @nestjs/typeorm
   

2. Erreur : "Connection to database failed"

   // Code incorrect
   TypeOrmModule.forRoot({
     type: 'postgres',
     host: 'localhost',
     port: 5432,
     username: 'your_username',
     password: 'your_password',
     database: 'task_manager',
     entities: [TaskEntity],
     synchronize: true,
   })
   
   // Correction
   TypeOrmModule.forRoot({
     type: 'postgres',
     host: 'localhost',
     port: 5432,
     username: 'your_username',
     password: 'your_password',
     database: 'task_manager',
     entities: [TaskEntity],
     synchronize: true,
   })
   

3. Erreur : "Cannot find name 'Partial'"

   // Code incorrect
   async createTask(taskData: Partial<Task>): Promise<Task> {
     return this.taskRepository.save(taskData);
   }
   
   // Correction
   import { PartialType } from '@nestjs/common';
   
   @Post()
   async createTask(@Body() taskData: PartialType<CreateTaskDto>): Promise<Task> {
     return this.taskModel.createTask(taskData);
   }
   

Pour aller plus loin

1. Intégration avec une base de données réelle (PostgreSQL, MongoDB)

   • Apprenez à configurer et utiliser différentes bases de données en NestJS.

2. Authentification et autorisation

   • Implémentez des systèmes d'authentification et d'autorisation pour sécuriser votre application.

3. Déploiement continu (CI/CD)

   • Configurez un pipeline CI/CD pour automatiser les tests et le déploiement de votre application.

Défi pratique

Créez une application NestJS qui permet à des utilisateurs de partager des images. L'application devrait avoir les fonctionnalités suivantes :

• Upload d'images
• Affichage des images uploadées
• Suppression d'images

Commencez par créer un nouveau projet NestJS et ajoutez les modèles, contrôleurs et routes nécessaires pour gérer les images. Utilisez une base de données appropriée (PostgreSQL ou MongoDB) pour stocker les images.