Guide Complet : Déployer une API NestJS avec PostgreSQL sur AWS Lightsail

votre-projet/
├── src/                    # Code NestJS
├── package.json
├── Dockerfile              # Configuration Docker
├── docker-compose.yml      # Orchestration des services
├── .env.production         # Variables d'environnement production
├── .dockerignore
└── .gitignore

FROM node:20

WORKDIR /app

# Copier package.json et package-lock.json
COPY package*.json ./

# Installer toutes les dépendances
RUN npm ci

# Copier le code source
COPY . .

# Build de l'application
RUN npm run build

# Supprimer les dev dependencies
RUN npm prune --production

# Exposer le port
EXPOSE 3000

# Commande de démarrage
CMD ["npm", "run", "start:prod"]

version: '3.8'
services:
  postgres:
    image: postgres:15
    container_name: postgres_db
    restart: always
    environment:
      POSTGRES_DB: ${DB_NAME}
      POSTGRES_USER: ${DB_USERNAME}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - app_network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${DB_USERNAME} -d ${DB_NAME}"]
      interval: 10s
      timeout: 5s
      retries: 5

  nestjs_app:
    build: .
    container_name: nestjs_container
    restart: always
    environment:
      NODE_ENV: ${NODE_ENV}
      DB_HOST: postgres
      DB_PORT: ${DB_PORT}
      DB_USERNAME: ${DB_USERNAME}
      DB_PASSWORD: ${DB_PASSWORD}
      DB_NAME: ${DB_NAME}
      PORT: ${PORT}
      JWT_SECRET: ${JWT_SECRET}
      SWAGGER_PASSWORD: ${SWAGGER_PASSWORD}
      # Ajoutez toutes vos autres variables d'environnement ici
    ports:
      - "127.0.0.1:3000:3000"
    depends_on:
      postgres:
        condition: service_healthy
    networks:
      - app_network

volumes:
  postgres_data:

networks:
  app_network:
    driver: bridge

TypeOrmModule.forRootAsync({
  imports: [ConfigModule],
  useFactory: (configService: ConfigService) => ({
    type: 'postgres',
    host: configService.get('DB_HOST', 'localhost'),
    port: configService.get('DB_PORT', 5432),
    username: configService.get('DB_USERNAME', 'postgres'),
    password: configService.get('DB_PASSWORD', ''),
    database: configService.get('DB_NAME', 'dabaseName'),
    entities: [__dirname + '/**/*.entity{.ts,.js}'],
    autoLoadEntities: true,
    synchronize: configService.get('NODE_ENV') !== 'production',
  }),
  inject: [ConfigService],
}),

# Se connecter au serveur
ssh -i votre-cle.pem ubuntu@votre-ip-lightsail

# Mettre à jour le système
sudo apt update && sudo apt upgrade -y

# Installer Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Ajouter votre utilisateur au groupe docker
sudo usermod -aG docker $USER

# Installer Docker Compose
sudo apt install docker-compose -y

# Installer Git
sudo apt install git -y

# Redémarrer la session
exit
# Reconnectez-vous

# Cloner depuis GitLab
git clone https://gitlab.com/votre-username/votre-repo.git
cd votre-repo

# Créer le fichier .env pour la production
cp .env.production .env

# Ou créer manuellement
nano .env

# Database Configuration
DB_HOST=postgres
DB_PORT=5432
DB_USERNAME=dabaseName
DB_PASSWORD=VotreMotDePasseSecure2024!
DB_NAME=spidcash

# Application Configuration
PORT=3000
NODE_ENV=production

# JWT Secret
JWT_SECRET=votre_jwt_secret_super_long_et_secure_pour_production_123456789

# Swagger Configuration
SWAGGER_PASSWORD=admin_prod_secure

# Vos autres variables d'environnement...

# Construire et démarrer
docker-compose up -d --build

# Vérifier que tout fonctionne
docker-compose ps
docker-compose logs -f

# Tester l'API
curl http://localhost:3000

# Vérifier Swagger
curl http://localhost:3000/docs

# Installer Nginx
sudo apt install nginx -y
sudo systemctl start nginx
sudo systemctl enable nginx

# Créer la configuration
sudo nano /etc/nginx/sites-available/api.votredomaine.com

server {
    listen 80;
    server_name api.votredomaine.com;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
        proxy_read_timeout 300s;
        proxy_connect_timeout 300s;
        proxy_send_timeout 300s;
    }

    location /docs {
        proxy_pass http://127.0.0.1:3000/docs;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

# Créer le lien symbolique
sudo ln -s /etc/nginx/sites-available/api.votredomaine.com /etc/nginx/sites-enabled/

# Tester la configuration
sudo nginx -t

# Recharger Nginx
sudo systemctl reload nginx

# Autoriser HTTP et HTTPS
sudo ufw allow 'Nginx Full'

# Vérifier les règles
sudo ufw status

# Tester HTTP
curl http://api.votredomaine.com

# Tester HTTPS
curl https://api.votredomaine.com

# Tester Swagger
curl https://api.votredomaine.com/docs

# Créer le script
nano deploy.sh

#!/bin/bash

echo "🚀 Déploiement en cours..."

# Pull du code depuis GitLab
git pull origin main

# Copier le fichier d'environnement de production
cp .env.production .env

# Arrêter les services existants
docker-compose down

# Reconstruire et redémarrer
docker-compose up -d --build

echo "✅ Déploiement terminé!"
echo "🌐 API disponible sur : https://api.$(hostname -I | awk '{print $1}' | xargs dig +short -x | sed 's/\.$//').com"

# Rendre exécutable
chmod +x deploy.sh

# Voir tous les logs
docker-compose logs -f

# Logs spécifiques
docker-compose logs -f nestjs_app
docker-compose logs -f postgres

# Redémarrer un service
docker-compose restart nestjs_app

# Reconstruire après modification
docker-compose up -d --build

# Arrêter tous les services
docker-compose down

# Créer une sauvegarde
docker exec postgres_db pg_dump -U votre_username votre_db_name > backup.sql

# Restaurer une sauvegarde
cat backup.sql | docker exec -i postgres_db psql -U votre_username -d votre_db_name