Déploiement

Guide complet pour déployer la plateforme 2Krika en production.

Vue d'Ensemble

La plateforme 2Krika peut être déployée sur différentes infrastructures. Ce guide couvre les déploiements recommandés.

Architecture de Déploiement

┌─────────────────────────────────────┐
│          CDN (Cloudflare)           │
└───────────────┬─────────────────────┘
                │
        ┌───────┴───────┐
        │               │
┌───────▼──────┐ ┌─────▼─────────┐
│   Vercel     │ │  AWS/DO       │
│              │ │               │
│ - Customers  │ │ - API Backend │
│ - Staffs     │ │ - Database    │
│ - Docs       │ │ - Redis       │
└──────────────┘ │ - Socket.io   │
                 │ - Storage (S3)│
                 └───────────────┘

Déploiement Frontend (Vercel)

App Customers

1. Configuration Vercel

Créer un nouveau projet sur Vercel:

# Se connecter à Vercel
vercel login

# Depuis le dossier apps/customers
cd apps/customers
vercel

2. Variables d'Environnement

Dans les settings du projet Vercel, ajouter:

NEXT_PUBLIC_API_URL=https://api.2krikaservices.cloud
NEXT_PUBLIC_SOCKET_URL=wss://socket.2krikaservices.cloud

3. Configuration Build

vercel.json

{
  "buildCommand": "pnpm build",
  "outputDirectory": ".next",
  "devCommand": "pnpm dev",
  "installCommand": "pnpm install",
  "framework": "nextjs",
  "regions": ["iad1"]
}

4. Domaines

Configurer les domaines dans Vercel:

Production: www.2krika.com
Staging: staging.2krika.com

App Staffs

Suivre les mêmes étapes que pour Customers:

cd apps/staffs
vercel

Domaines:

Production: staff.2krika.com
Staging: staff-staging.2krika.com

App Docs

cd apps/docs
vercel

Domaines:

Production: docs.2krika.com

Déploiement Backend

Option 1: AWS EC2

1. Créer une Instance EC2

# Ubuntu 22.04 LTS
# Instance type: t3.medium (ou plus selon le trafic)

2. Installer les Dépendances

# Se connecter via SSH
ssh -i key.pem ubuntu@your-server-ip

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

# Installer Node.js 18
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt install -y nodejs

# Installer pnpm
npm install -g pnpm

# Installer PM2 (process manager)
npm install -g pm2

# Installer Docker (pour PostgreSQL et Redis)
sudo apt install docker.io docker-compose -y
sudo usermod -aG docker $USER

3. Déployer l'Application

# Cloner le repo
git clone [backend-repo-url]
cd backend

# Installer les dépendances
pnpm install

# Créer le fichier .env
cp .env.example .env
nano .env

# Build
pnpm build

# Démarrer avec PM2
pm2 start npm --name "2krika-api" -- start
pm2 save
pm2 startup

4. Configuration Nginx

/etc/nginx/sites-available/2krika-api

server {
    listen 80;
    server_name api.2krikaservices.cloud;

    location / {
        proxy_pass http://localhost:8000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

# Activer le site
sudo ln -s /etc/nginx/sites-available/2krika-api /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

# Installer SSL avec Certbot
sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d api.2krikaservices.cloud

Option 2: DigitalOcean App Platform

1. Créer une App

Via l'interface DigitalOcean:

Connecter le repo GitHub
Sélectionner la branche (main)
Configurer le build

2. Configuration

.do/app.yaml

name: 2krika-backend
region: nyc
services:
  - name: api
    github:
      repo: your-org/backend-repo
      branch: main
      deploy_on_push: true
    build_command: pnpm install && pnpm build
    run_command: pnpm start
    environment_slug: node-js
    instance_count: 2
    instance_size_slug: professional-xs
    envs:
      - key: NODE_ENV
        value: "production"
      - key: DATABASE_URL
        scope: RUN_TIME
        type: SECRET

Base de Données

PostgreSQL

Avec Docker

docker-compose.yml

version: '3.8'
services:
  postgres:
    image: postgres:15
    restart: always
    environment:
      POSTGRES_DB: krika_db
      POSTGRES_USER: krika_user
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    restart: always
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data

volumes:
  postgres_data:
  redis_data:

# Démarrer les services
docker-compose up -d

# Vérifier les logs
docker-compose logs -f

Avec Managed Database

Utiliser un service managé comme:

AWS RDS
DigitalOcean Managed Databases
Supabase
Neon

Avantages:

Backups automatiques
High availability
Scaling facile
Maintenance gérée

Redis

Pour le cache et les sessions:

# Via Docker (voir docker-compose.yml ci-dessus)
# Ou service managé:
# - AWS ElastiCache
# - DigitalOcean Managed Redis
# - Upstash

Storage (Fichiers)

AWS S3

1. Créer un Bucket

aws s3 mb s3://2krika-uploads

2. Configuration CORS

{
  "CORSRules": [
    {
      "AllowedOrigins": ["https://www.2krika.com"],
      "AllowedMethods": ["GET", "PUT", "POST", "DELETE"],
      "AllowedHeaders": ["*"],
      "ExposeHeaders": ["ETag"]
    }
  ]
}

3. Configuration Backend

AWS_ACCESS_KEY_ID=your_access_key
AWS_SECRET_ACCESS_KEY=your_secret_key
AWS_REGION=us-east-1
AWS_BUCKET_NAME=2krika-uploads

Alternative: Cloudinary

CLOUDINARY_CLOUD_NAME=your_cloud_name
CLOUDINARY_API_KEY=your_api_key
CLOUDINARY_API_SECRET=your_api_secret

Socket.io Server

Déploiement Séparé

Pour le real-time, déployer Socket.io sur un serveur séparé:

socket-server.js

const io = require('socket.io')(3001, {
  cors: {
    origin: ['https://www.2krika.com'],
    methods: ['GET', 'POST'],
  },
});

io.on('connection', (socket) => {
  console.log('Client connected:', socket.id);

  socket.on('join-room', (roomId) => {
    socket.join(roomId);
  });

  socket.on('message', (data) => {
    io.to(data.roomId).emit('message', data);
  });

  socket.on('disconnect', () => {
    console.log('Client disconnected:', socket.id);
  });
});

# Démarrer avec PM2
pm2 start socket-server.js --name "2krika-socket"

Configuration Nginx pour WebSocket

server {
    listen 443 ssl;
    server_name socket.2krikaservices.cloud;

    ssl_certificate /etc/letsencrypt/live/socket.2krikaservices.cloud/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/socket.2krikaservices.cloud/privkey.pem;

    location / {
        proxy_pass http://localhost:3001;
        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;
    }
}

CI/CD avec GitHub Actions

Workflow Frontend

.github/workflows/deploy-customers.yml

name: Deploy Customers App

on:
  push:
    branches: [main]
    paths:
      - 'apps/customers/**'

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'

      - name: Install pnpm
        run: npm install -g pnpm

      - name: Install dependencies
        run: pnpm install

      - name: Build
        run: cd apps/customers && pnpm build

      - name: Deploy to Vercel
        uses: amondnet/vercel-action@v25
        with:
          vercel-token: ${{ secrets.VERCEL_TOKEN }}
          vercel-org-id: ${{ secrets.VERCEL_ORG_ID }}
          vercel-project-id: ${{ secrets.VERCEL_PROJECT_ID }}
          working-directory: ./apps/customers

Workflow Backend

.github/workflows/deploy-backend.yml

name: Deploy Backend

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Deploy to Server
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.SERVER_HOST }}
          username: ${{ secrets.SERVER_USER }}
          key: ${{ secrets.SSH_PRIVATE_KEY }}
          script: |
            cd /var/www/backend
            git pull origin main
            pnpm install
            pnpm build
            pm2 restart 2krika-api

Monitoring

Sentry

npm install @sentry/nextjs @sentry/node

sentry.client.config.js

import * as Sentry from '@sentry/nextjs';

Sentry.init({
  dsn: process.env.NEXT_PUBLIC_SENTRY_DSN,
  environment: process.env.NODE_ENV,
  tracesSampleRate: 1.0,
});

Uptime Monitoring

Utiliser des services comme:

UptimeRobot
Pingdom
Datadog

Logs

# Logs PM2
pm2 logs 2krika-api

# Logs Docker
docker-compose logs -f

# Logs Nginx
sudo tail -f /var/log/nginx/access.log
sudo tail -f /var/log/nginx/error.log

Backups

Base de Données

# Script de backup automatique
#!/bin/bash
BACKUP_DIR="/var/backups/postgres"
DATE=$(date +%Y%m%d_%H%M%S)

# Créer le backup
docker exec postgres pg_dump -U krika_user krika_db > "$BACKUP_DIR/backup_$DATE.sql"

# Garder seulement les 7 derniers jours
find $BACKUP_DIR -type f -mtime +7 -delete

# Upload vers S3
aws s3 cp "$BACKUP_DIR/backup_$DATE.sql" s3://2krika-backups/

# Ajouter au crontab (tous les jours à 2h du matin)
0 2 * * * /path/to/backup-script.sh

Fichiers

# Backup S3 vers autre région
aws s3 sync s3://2krika-uploads s3://2krika-uploads-backup --region eu-west-1

Scaling

Frontend

Vercel scale automatiquement.

Backend

Horizontal Scaling

# Augmenter le nombre d'instances PM2
pm2 scale 2krika-api +2

# Ou utiliser un load balancer

Load Balancer (Nginx)

upstream backend {
    least_conn;
    server localhost:8000;
    server localhost:8001;
    server localhost:8002;
}

server {
    location / {
        proxy_pass http://backend;
    }
}

Database

Utiliser des replicas en lecture
Implémenter le connection pooling
Ajouter des indexes
Optimiser les requêtes

Sécurité en Production

SSL/TLS

Toujours utiliser HTTPS avec des certificats valides (Let's Encrypt).

Firewall

# UFW (Ubuntu)
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable

Rate Limiting

Implémenter au niveau Nginx ou application:

limit_req_zone $binary_remote_addr zone=api:10m rate=10r/s;

location /api/ {
    limit_req zone=api burst=20;
}

Environment Variables

Ne jamais committer les secrets. Utiliser:

Variables d'environnement serveur
Secrets managers (AWS Secrets Manager, Vault)
Vercel Environment Variables

Checklist de Déploiement

Prochaines Étapes

Configuration

Variables d'environnement et configuration

API Reference

Documentation de l'API

Déploiement

Configuration

API Reference

On this page