DEV Community: Georges HELOUSSATO

Setting Up Shopify App + NestJS Backend: A Step-by-Step Local Development Guide

Georges HELOUSSATO — Sun, 07 Sep 2025 22:41:20 +0000

Ever wanted to connect a Shopify app to your own backend? Here's a complete walkthrough to get both servers running on your local machine and talking to each other.

What We're Building 🎯

Shopify App: Handles webhooks from Shopify stores
NestJS Backend: Processes webhook data and handles business logic
Connection: Shopify app forwards order data to NestJS API

Let's get both servers up and running!

Part 1: Setting Up the Shopify App 🏪

Step 1: Create the Shopify App

Open your terminal and run:

npm init @shopify/app@latest

Answer the prompts:

App name: bridge-app (or any name you prefer)
Type: Public: An app built for a wide merchant audience
Template: Remix (TypeScript)
Package manager: npm

Step 2: Navigate to Your App

cd bridge-app

Step 3: Configure Permissions and Webhooks

Edit the shopify.app.toml file:

nano shopify.app.toml

Find this line:

scopes = "write_products"

Replace it with:

scopes = "write_products,read_orders,write_orders"

Then find this section:

  [[webhooks.subscriptions]]
  topics = [ "app/scopes_update" ]
  uri = "/webhooks/app/scopes_update"

Add after it:

  [[webhooks.subscriptions]]
  topics = [ "orders/create" ]
  uri = "/webhooks/orders/create"

Save and exit: Ctrl + X, then Y, then Enter

Step 4: Start the Shopify App

shopify app dev

Follow the prompts:

Create or select a development store
Allow automatic URL updates (Y)
The app will start and give you a preview URL

Keep this terminal open - your Shopify app is now running!

Part 2: Setting Up the NestJS Backend 🔧

Step 1: Open a New Terminal

Important: Keep your Shopify terminal running and open a new terminal window.

Step 2: Create NestJS Project

# Install NestJS CLI globally
npm i -g @nestjs/cli

# Create new project
nest new bridgeapp-api

# Navigate to project
cd bridgeapp-api

Step 3: Create the Webhook Controller

Create a new directory:

mkdir src/webhook

Create the controller file:

touch src/webhook/webhook.controller.ts

Edit the file:

nano src/webhook/webhook.controller.ts

Add this code:

import { Controller, Post, Body, Headers, Logger } from '@nestjs/common';

@Controller('webhook')
export class WebhookController {
  private readonly logger = new Logger(WebhookController.name);

  @Post('shopify/order')
  handleShopifyOrder(
    @Body() body: any,
    @Headers() headers: any,
  ) {
    this.logger.log('🔔 WEBHOOK RECEIVED!');
    this.logger.log('📦 Headers:', JSON.stringify(headers, null, 2));
    this.logger.log('📊 Body:', JSON.stringify(body, null, 2));

    return { status: 'OK', message: 'Webhook received!' };
  }
}

Save and exit: Ctrl + X, then Y, then Enter

Step 4: Update App Module

Edit the main app module:

nano src/app.module.ts

Replace the content with:

import { Module } from '@nestjs/common';
import { WebhookController } from './webhook/webhook.controller';

@Module({
  controllers: [WebhookController],
})
export class AppModule {}

Save and exit: Ctrl + X, then Y, then Enter

Step 5: Start NestJS

npm run start:dev

Keep this terminal open too - your NestJS API is now running on http://localhost:3000!

Part 3: Connecting Shopify to NestJS 🔗

Step 1: Create the Bridge

In your Shopify app terminal (the first one), create a new webhook file:

touch app/routes/webhooks.orders.create.tsx

Edit this file:

nano app/routes/webhooks.orders.create.tsx

Add this code:

import type { ActionFunctionArgs } from "@remix-run/node";
import { authenticate } from "../shopify.server";

export const action = async ({ request }: ActionFunctionArgs) => {
  const { topic, shop, session, admin, payload } = await authenticate.webhook(request);

  console.log("🔔 SHOPIFY WEBHOOK RECEIVED!");
  console.log("📊 Topic:", topic);
  console.log("🏪 Shop:", shop);
  console.log("📦 Order:", JSON.stringify(payload, null, 2));

  try {
    console.log("➡️ Sending to NestJS...");

    const response = await fetch('http://localhost:3000/webhook/shopify/order', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        shop: shop,
        order: payload
      })
    });

    if (response.ok) {
      console.log("✅ Successfully sent to NestJS");
    } else {
      console.log("❌ Error sending to NestJS:", response.status);
    }
  } catch (error) {
    console.log("❌ Connection error:", error);
  }

  return new Response("OK", { status: 200 });
};

Save and exit: Ctrl + X, then Y, then Enter

Part 4: Testing the Connection 🧪

Step 1: Install Your App

In your browser, go to the preview URL shown in your Shopify terminal. Install the app on your development store.

Step 2: Test with Direct API Call

In a third terminal, test your NestJS API directly:

curl -X POST http://localhost:3000/webhook/shopify/order \
  -H "Content-Type: application/json" \
  -d '{
    "shop": "test-shop.myshopify.com",
    "order": {
      "id": 123,
      "name": "#1001",
      "customer": {
        "first_name": "John",
        "phone": "+1234567890"
      }
    }
  }'

You should see logs in your NestJS terminal!

Step 3: Test End-to-End

Go to your Shopify admin
Navigate to Orders → Create order
Add a product and customer
Create the order
Watch both terminals for logs!

What You Should See 👀

Terminal 1 (Shopify App):

🔔 SHOPIFY WEBHOOK RECEIVED!
📊 Topic: orders/create
🏪 Shop: your-store.myshopify.com
➡️ Sending to NestJS...
✅ Successfully sent to NestJS

Terminal 2 (NestJS API):

[WebhookController] 🔔 WEBHOOK RECEIVED!
[WebhookController] 📦 Headers: {...}
[WebhookController] 📊 Body: {"shop": "...", "order": {...}}

Troubleshooting Common Issues 🔧

"Connection refused" Error

Check: Is NestJS running on port 3000?
Test: curl http://localhost:3000/webhook/shopify/order

No Webhook Received

Check: Did you save the webhook file correctly?
Try: Restart your Shopify app (Ctrl+C then shopify app dev)

Port Already in Use

NestJS: Change port in main.ts to 3001
Update: Shopify webhook URL to localhost:3001

Your Local Development Setup ✅

Congratulations! You now have:

✅ Shopify app running and receiving webhooks
✅ NestJS backend processing webhook data
✅ Communication between both servers
✅ Local development environment ready for building features

Next Steps 🚀

Now that both servers are talking, you can:

Add business logic to your NestJS webhook handler
Integrate external APIs (WhatsApp, email, SMS)
Add database to store and process data
Build frontend components for your Shopify app
Deploy to production when ready

Keeping Everything Running 💡

Terminal Management:

Terminal 1: shopify app dev (keep running)
Terminal 2: npm run start:dev in NestJS folder (keep running)
Terminal 3: Available for testing commands

When you restart:

Start NestJS first (npm run start:dev)
Start Shopify app second (shopify app dev)
Both should reconnect automatically

That's it! You now have a complete local development setup with Shopify and NestJS talking to each other. Happy coding! 🎉

Questions about the setup? Drop them in the comments below!

Complete Guide: Deploy NestJS API with PostgreSQL on AWS Lightsail

Georges HELOUSSATO — Mon, 01 Sep 2025 16:12:29 +0000

This comprehensive guide walks you through deploying a NestJS application with PostgreSQL database on AWS Lightsail, featuring a custom subdomain managed by Cloudflare.

🎯 Final Objective

NestJS API accessible via https://api.yourdomain.com
Containerized PostgreSQL database
SSL managed by Cloudflare
Swagger documentation accessible

📋 Prerequisites

AWS Lightsail server (Ubuntu)
Domain configured with Cloudflare
NestJS project on GitLab
SSH access to your server

1. 📁 Project Preparation

Required file structure

Your project should contain these files at the root:

your-project/
├── src/                    # NestJS code
├── package.json
├── Dockerfile              # Docker configuration
├── docker-compose.yml      # Service orchestration
├── .env.production         # Production environment variables
├── .dockerignore
└── .gitignore

`Dockerfile`

FROM node:20

WORKDIR /app

# Copy package.json and package-lock.json
COPY package*.json ./

# Install all dependencies
RUN npm ci

# Copy source code
COPY . .

# Build the application
RUN npm run build

# Remove dev dependencies
RUN npm prune --production

# Expose port
EXPOSE 3000

# Start command
CMD ["npm", "run", "start:prod"]

`docker-compose.yml`

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}
      # Add all your other environment variables here
    ports:
      - "127.0.0.1:3000:3000"
    depends_on:
      postgres:
        condition: service_healthy
    networks:
      - app_network

volumes:
  postgres_data:

networks:
  app_network:
    driver: bridge

NestJS Configuration (`app.module.ts`)

Ensure your main module uses the correct environment variables:

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', 'db_password'),
    database: configService.get('DB_NAME', 'myapp'),
    entities: [__dirname + '/**/*.entity{.ts,.js}'],
    autoLoadEntities: true,
    synchronize: configService.get('NODE_ENV') !== 'production',
  }),
  inject: [ConfigService],
}),

2. 🔧 Lightsail Server Configuration

Connection and updates

# Connect to server
ssh -i your-key.pem ubuntu@your-lightsail-ip

# Update system
sudo apt update && sudo apt upgrade -y

Docker Installation

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

# Add your user to docker group
sudo usermod -aG docker $USER

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

# Install Git
sudo apt install git -y

# Restart session
exit
# Reconnect

3. 📦 Application Deployment

Clone the project

# Clone from GitLab
git clone https://gitlab.com/your-username/your-repo.git
cd your-repo

Environment configuration

# Create .env file for production
cp .env.production .env

# Or create manually
nano .env

Example .env file:

# Database Configuration
DB_HOST=postgres
DB_PORT=5432
DB_USERNAME=app_admin
DB_PASSWORD=YourSecurePassword2024!
DB_NAME=myapp

# Application Configuration
PORT=3000
NODE_ENV=production

# JWT Secret
JWT_SECRET=your_super_long_and_secure_jwt_secret_for_production_123456789

# Swagger Configuration
SWAGGER_PASSWORD=admin_prod_secure

# Your other environment variables...

Build and start services

# Build and start
docker-compose up -d --build

# Verify everything works
docker-compose ps
docker-compose logs -f

API Verification

# Test API
curl http://localhost:3000

# Check Swagger
curl http://localhost:3000/docs

4. 🌐 Subdomain Configuration

DNS Configuration in Cloudflare

Log in to your Cloudflare dashboard
Go to DNS → Records
Click Add record
Configure:
- Type: A
- Name: api
- IPv4 address: YOUR_LIGHTSAIL_IP
- Proxy status: 🟠 Proxied
- TTL: Auto

Nginx Installation and Configuration

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

Reverse proxy configuration

# Create configuration
sudo nano /etc/nginx/sites-available/api.yourdomain.com

File content:

server {
    listen 80;
    server_name api.yourdomain.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;
    }
}

Enable configuration

# Create symbolic link
sudo ln -s /etc/nginx/sites-available/api.yourdomain.com /etc/nginx/sites-enabled/

# Test configuration
sudo nginx -t

# Reload Nginx
sudo systemctl reload nginx

Firewall configuration

# Allow HTTP and HTTPS
sudo ufw allow 'Nginx Full'

# Check rules
sudo ufw status

5. 🔒 SSL Configuration with Cloudflare

In Cloudflare dashboard

SSL/TLS → Overview → Mode: Flexible
SSL/TLS → Edge Certificates → Always Use HTTPS: ON
Verify your DNS record is in Proxied mode (🟠)

Final test

# Test HTTP
curl http://api.yourdomain.com

# Test HTTPS
curl https://api.yourdomain.com

# Test Swagger
curl https://api.yourdomain.com/docs

6. 🚀 Automated Deployment Script

Create a script to facilitate future updates:

# Create script
nano deploy.sh

Content:

#!/bin/bash

echo "🚀 Deployment in progress..."

# Pull code from GitLab
git pull origin main

# Copy production environment file
cp .env.production .env

# Stop existing services
docker-compose down

# Rebuild and restart
docker-compose up -d --build

echo "✅ Deployment completed!"
echo "🌐 API available at: https://api.yourdomain.com"

# Make executable
chmod +x deploy.sh

7. 🔧 Maintenance Commands

Log monitoring

# View all logs
docker-compose logs -f

# Specific logs
docker-compose logs -f nestjs_app
docker-compose logs -f postgres

Service management

# Restart a service
docker-compose restart nestjs_app

# Rebuild after changes
docker-compose up -d --build

# Stop all services
docker-compose down

Database backup

# Create backup
docker exec postgres_db pg_dump -U your_username your_db_name > backup.sql

# Restore backup
cat backup.sql | docker exec -i postgres_db psql -U your_username -d your_db_name

8. 📊 Health Monitoring

Basic monitoring commands

# Check container status
docker-compose ps

# Monitor resource usage
docker stats

# Check disk usage
df -h
docker system df

Log rotation setup

# Configure log rotation for Docker
sudo nano /etc/docker/daemon.json

Add:

{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  }
}

# Restart Docker daemon
sudo systemctl restart docker

9. 🛡️ Security Best Practices

Environment variables security

# Secure .env file permissions
chmod 600 .env

# Never commit .env files to version control
echo ".env*" >> .gitignore

Firewall configuration

# Enable UFW
sudo ufw enable

# Allow only necessary ports
sudo ufw allow ssh
sudo ufw allow 'Nginx Full'

# Check firewall status
sudo ufw status verbose

Database security

# Change default PostgreSQL port (optional)
# In docker-compose.yml, change port mapping to:
# ports:
#   - "127.0.0.1:5433:5432"

# Regular security updates
sudo apt update && sudo apt upgrade -y

🎉 Final Result

Your NestJS API is now accessible via:

API: https://api.yourdomain.com
Documentation: https://api.yourdomain.com/docs
Automatic SSL via Cloudflare
Containerized PostgreSQL database with persistent storage

🚨 Troubleshooting

Common issues and solutions

API not responding

# Check container status
docker-compose ps

# Check logs
docker-compose logs nestjs_app

# Restart if needed
docker-compose restart nestjs_app

Database connection issues

# Check PostgreSQL logs
docker-compose logs postgres

# Verify environment variables
docker-compose config

# Reset database (caution: data loss)
docker-compose down
docker volume rm your-project_postgres_data
docker-compose up -d

SSL certificate issues

# Check Cloudflare SSL settings
# Verify DNS propagation
dig api.yourdomain.com

# Test SSL
openssl s_client -connect api.yourdomain.com:443

🔄 Future Deployments

For updates:

Push code to GitLab
On server: ./deploy.sh
Verify everything works

📝 Additional Notes

Performance optimization

# Monitor API performance
curl -w "@curl-format.txt" -o /dev/null -s "https://api.yourdomain.com"

# Database performance monitoring
docker exec -it postgres_db psql -U your_username -d your_db_name -c "SELECT * FROM pg_stat_activity;"

Backup automation

# Create automated backup script
nano backup.sh

#!/bin/bash
DATE=$(date +%Y%m%d_%H%M%S)
docker exec postgres_db pg_dump -U your_username your_db_name > "backup_${DATE}.sql"
echo "Backup created: backup_${DATE}.sql"

Your production infrastructure is now ready! 🚀

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

Georges HELOUSSATO — Mon, 01 Sep 2025 16:08:46 +0000

Ce guide vous accompagne étape par étape pour déployer votre application NestJS avec une base de données PostgreSQL sur AWS Lightsail, avec un sous-domaine personnalisé géré par Cloudflare.

🎯 Objectif Final

API NestJS accessible via https://api.votredomaine.com
Base de données PostgreSQL containerisée
SSL géré par Cloudflare
Documentation Swagger accessible

📋 Prérequis

Un serveur AWS Lightsail (Ubuntu)
Un domaine configuré avec Cloudflare
Votre projet NestJS sur GitLab
Accès SSH à votre serveur

1. 📁 Préparation du Projet

Structure des fichiers nécessaires

Votre projet doit contenir ces fichiers à la racine :

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

Fichier `Dockerfile`

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

Fichier `docker-compose.yml`

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

Configuration NestJS (`app.module.ts`)

Assurez-vous que votre module principal utilise les bonnes variables d'environnement :

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

2. 🔧 Configuration du Serveur Lightsail

Connexion et mise à jour

# 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

Installation de Docker

# 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

3. 📦 Déploiement de l'Application

Cloner le projet

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

Configuration de l'environnement

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

# Ou créer manuellement
nano .env

Exemple de fichier .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 les services

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

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

Vérification de l'API

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

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

4. 🌐 Configuration du Sous-domaine

Configuration DNS dans Cloudflare

Connectez-vous à votre dashboard Cloudflare
Allez dans DNS → Records
Cliquez sur Add record
Configurez :
- Type : A
- Name : api
- IPv4 address : VOTRE_IP_LIGHTSAIL
- Proxy status : 🟠 Proxied
- TTL : Auto

Installation et configuration de Nginx

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

Configuration du reverse proxy

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

Contenu du fichier :

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;
    }
}

Activer la configuration

# 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

Configuration du pare-feu

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

# Vérifier les règles
sudo ufw status

5. 🔒 Configuration SSL avec Cloudflare

Dans le dashboard Cloudflare

SSL/TLS → Overview → Mode : Flexible
SSL/TLS → Edge Certificates → Always Use HTTPS : ON
Vérifiez que votre enregistrement DNS est en mode Proxied (🟠)

Test final

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

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

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

6. 🚀 Script de Déploiement Automatique

Créez un script pour faciliter les mises à jour futures :

# Créer le script
nano deploy.sh

Contenu :

#!/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

7. 🔧 Commandes de Maintenance

Surveillance des logs

# Voir tous les logs
docker-compose logs -f

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

Gestion des services

# 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

Sauvegarde de la base de données

# 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

🎉 Résultat Final

Votre API NestJS est maintenant accessible via :

API : https://api.votredomaine.com
Documentation : https://api.votredomaine.com/docs
SSL automatique via Cloudflare
Base de données PostgreSQL containerisée et persistante

🛡️ Points de Sécurité Importants

Changez tous les mots de passe par défaut
Utilisez des JWT secrets longs et aléatoires
Configurez le pare-feu correctement
Ne commitez jamais les fichiers .env sur GitLab
Surveillez régulièrement les logs

🔄 Déploiements Futurs

Pour les mises à jour :

Pousser le code sur GitLab
Sur le serveur : ./deploy.sh
Vérifier que tout fonctionne

Votre infrastructure est maintenant prête pour la production ! 🚀

DEV Community: Georges HELOUSSATO

Setting Up Shopify App + NestJS Backend: A Step-by-Step Local Development Guide

What We're Building 🎯

Part 1: Setting Up the Shopify App 🏪

Step 1: Create the Shopify App

Step 2: Navigate to Your App

Step 3: Configure Permissions and Webhooks

Step 4: Start the Shopify App

Part 2: Setting Up the NestJS Backend 🔧

Step 1: Open a New Terminal

Step 2: Create NestJS Project

Step 3: Create the Webhook Controller

Step 4: Update App Module

Step 5: Start NestJS

Part 3: Connecting Shopify to NestJS 🔗

Step 1: Create the Bridge

Part 4: Testing the Connection 🧪

Step 1: Install Your App

Step 2: Test with Direct API Call

Step 3: Test End-to-End

What You Should See 👀

Terminal 1 (Shopify App):

Terminal 2 (NestJS API):

Troubleshooting Common Issues 🔧

"Connection refused" Error

No Webhook Received

Port Already in Use

Your Local Development Setup ✅

Next Steps 🚀

Keeping Everything Running 💡

Complete Guide: Deploy NestJS API with PostgreSQL on AWS Lightsail

🎯 Final Objective

📋 Prerequisites

1. 📁 Project Preparation

Required file structure

Dockerfile

docker-compose.yml

NestJS Configuration (app.module.ts)

2. 🔧 Lightsail Server Configuration

Connection and updates

Docker Installation

3. 📦 Application Deployment

Clone the project

Environment configuration

Build and start services

API Verification

4. 🌐 Subdomain Configuration

DNS Configuration in Cloudflare

Nginx Installation and Configuration

Reverse proxy configuration

Enable configuration

Firewall configuration

5. 🔒 SSL Configuration with Cloudflare

In Cloudflare dashboard

Final test

6. 🚀 Automated Deployment Script

7. 🔧 Maintenance Commands

Log monitoring

Service management

Database backup

8. 📊 Health Monitoring

Basic monitoring commands

Log rotation setup

9. 🛡️ Security Best Practices

Environment variables security

Firewall configuration

Database security

🎉 Final Result

🚨 Troubleshooting

Common issues and solutions

API not responding

Database connection issues

SSL certificate issues

🔄 Future Deployments

📝 Additional Notes

Performance optimization

Backup automation

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

🎯 Objectif Final

📋 Prérequis

`Dockerfile`

`docker-compose.yml`

NestJS Configuration (`app.module.ts`)

Fichier `Dockerfile`

Fichier `docker-compose.yml`

Configuration NestJS (`app.module.ts`)