Guide de déploiement

Ce guide couvre les stratégies de déploiement pour AMRnet, y compris le développement local, les environnements de mise en scène et le déploiement de production sur diverses plateformes.

Configuration de l’environnement

AMRnet prend en charge plusieurs environnements de déploiement avec différentes configurations :

Environnement de développement

Pour le développement local avec rechargement chaud et débogage:

# Clone and setup
git clone https://github.com/amrnet/amrnet.git
cd amrnet

# Install dependencies
npm install
cd client && npm install && cd ..

# Environment configuration
cp .env.example .env

Variables d’environnement (.env):

NODE_ENV=development
PORT=8080

# Database
MONGODB_URI=mongodb://localhost:27017/amrnet

# Development settings
REACT_APP_API_URL=http://localhost:8080/api/
ENABLE_DEBUG_LOGS=true

Lancer les serveurs de développement :

# Start both backend and frontend
npm run start:dev

# Or individually:
npm run start:backend  # Backend only (port 8080)
npm run client         # Frontend only (port 3000)

Environnement de pré-production

Pour tester les versions de production localement :

# Build production bundle
npm run build

# Start production server
NODE_ENV=production npm start

Déploiement de production

Déploiement de Heroku

AMRnet est optimisé pour le déploiement de Heroku avec des processus de compilation automatiques:

1. Heroku App Setup:

# Install Heroku CLI and login
heroku login

# Create new app
heroku create your-app-name

# Provision MongoDB (e.g., mLab sandbox or an external managed cluster).
# AMRnet production itself runs MongoDB on the same EC2 host as the app;
# Heroku is shown here as an alternative hosting path.
heroku addons:create mongolab:sandbox

2. Configuration de l’environnement:

# Set environment variables
heroku config:set NODE_ENV=production
heroku config:set MONGODB_URI="your-mongodb-connection-string"
heroku config:set REACT_APP_API_URL="https://your-app-name.herokuapp.com/api/"

3. Déploiement :

# Deploy to Heroku
git add .
git commit -m "Deploy to Heroku"
git push heroku main

# Monitor deployment
heroku logs --tail

Fichiers de configuration Heroku :

Profil:

web: node server.js

package.json (heroku-postbuild script):

{
  "scripts": {
    "heroku-postbuild": "cd client && npm install && npm run build"
  }
}

MongoDB on EC2 Configuration

AMRnet production runs MongoDB locally on the application EC2 instance (bound to 127.0.0.1 — no public listener). This keeps the data plane off the public internet and avoids the cost and IP-allowlist maintenance of a managed Atlas cluster.

1. Host Setup:

  • Install MongoDB 6.0+ on the EC2 instance

  • Keep bindIp: 127.0.0.1 in /etc/mongod.conf

  • Enable authentication and create a read/write user for AMRnet

  • Store the URI in /opt/amrnet/.credentials with chmod 600

2. Configuration de la connexion :

# Production .env (EC2) — loopback only
MONGODB_URI=mongodb://amrnet_user:password@127.0.0.1:27017/amrnet?authSource=admin

3. MongoDB Compass access (developer laptops):

# Open an SSH tunnel, then point Compass at localhost:27018
ssh -L 27018:127.0.0.1:27017 ec2-user@<host>
# See deploy/mongo-tunnel.sh for the wrapper script

3. Optimisations de production :

// config/db.js - Production MongoDB settings
const mongoOptions = {
  useNewUrlParser: true,
  useUnifiedTopology: true,
  maxPoolSize: 10,
  minPoolSize: 5,
  maxIdleTimeMS: 30000,
  serverSelectionTimeoutMS: 5000,
  socketTimeoutMS: 45000,
  bufferMaxEntries: 0,
  bufferCommands: false,
};

Déploiement Docker

Pour le déploiement conteneurisé :

Fichier Docker:

# Multi-stage build for optimized production image
FROM node:18-alpine AS builder

WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

# Build client
COPY client/package*.json ./client/
WORKDIR /app/client
RUN npm ci --only=production
COPY client/ .
RUN npm run build

# Production stage
FROM node:18-alpine AS production

WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/client/build ./client/build
COPY . .

EXPOSE 8080
CMD ["node", "server.js"]

docker-compose.yml:

version: '3.8'
services:
  amrnet:
    build: .
    ports:
      - "8080:8080"
    environment:
      - NODE_ENV=production
      - MONGODB_URI=mongodb://mongo:27017/amrnet
    depends_on:
      - mongo

  mongo:
    image: mongo:6
    ports:
      - "27017:27017"
    volumes:
      - mongo_data:/data/db

volumes:
  mongo_data:

Commandes de déploiement :

# Build and start containers
docker-compose up -d

# View logs
docker-compose logs -f amrnet

Déploiement AWS

Pour le déploiement AWS en utilisant Elastic Beanstalk :

1. Configuration CLI EB :

# Install EB CLI
pip install awsebcli

# Initialize EB application
eb init amrnet

# Create environment
eb create amrnet-production

2. Fichiers de configuration:

.ebextensions/01_node_command.config:

option_settings:
  aws:elasticbeanstalk:container:nodejs:
    NodeCommand: "node server.js"
  aws:elasticbeanstalk:application:environment:
    NODE_ENV: production

3. Déploiement :

# Deploy to AWS
eb deploy

# Monitor health
eb health

Optimisation des performances

Optimisations de déploiement de production pour de meilleures performances:

Construire des optimisations

Configuration de la compilation du client :

// client/.env.production
GENERATE_SOURCEMAP=false
REACT_APP_NODE_ENV=production

// Build optimizations in package.json
{
  "scripts": {
    "build": "react-scripts build && npm run compress",
    "compress": "gzip -k build/static/js/*.js && gzip -k build/static/css/*.css"
  }
}

Optimisations du serveur

Configuration de production Express.js :

// server.js production settings
const express = require('express');
const compression = require('compression');
const helmet = require('helmet');

const app = express();

// Security middleware
app.use(helmet());

// Compression middleware
app.use(compression({
  level: 6,
  threshold: 1024,
}));

// Static file caching
app.use(express.static('client/build', {
  maxAge: '1y',
  etag: false
}));

Optimisations de la base de données

Index de production MongoDB :

// Database indexes for production
db.ecoli_data.createIndex({ COUNTRY_ONLY: 1, YEAR: 1 });
db.kpneumo_data.createIndex({ GENOTYPE: 1, COUNTRY_ONLY: 1 });
db.styphi_data.createIndex({ GENOTYPE: 1, YEAR: 1, COUNTRY_ONLY: 1 });

Surveillance et journalisation

Configuration de la surveillance de production pour les performances et le suivi des erreurs :

Surveillance de l’application

Winston Logging Configuration :

// config/logger.js
const winston = require('winston');

const logger = winston.createLogger({
  level: process.env.LOG_LEVEL || 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.errors({ stack: true }),
    winston.format.json()
  ),
  defaultMeta: { service: 'amrnet' },
  transports: [
    new winston.transports.File({ filename: 'logs/error.log', level: 'error' }),
    new winston.transports.File({ filename: 'logs/combined.log' }),
  ],
});

if (process.env.NODE_ENV !== 'production') {
  logger.add(new winston.transports.Console({
    format: winston.format.simple()
  }));
}

Middleware de surveillance des performances :

// middleware/performance.js
const performanceMiddleware = (req, res, next) => {
  const start = Date.now();

  res.on('finish', () => {
    const duration = Date.now() - start;
    logger.info(`${req.method} ${req.path}`, {
      duration,
      statusCode: res.statusCode,
      ip: req.ip
    });

    // Alert on slow requests
    if (duration > 2000) {
      logger.warn(`Slow request detected: ${req.path} took ${duration}ms`);
    }
  });

  next();
};

Suivi des erreurs

Intégration du Guetteur :

// Error tracking with Sentry
const Sentry = require('@sentry/node');

Sentry.init({
  dsn: process.env.SENTRY_DSN,
  environment: process.env.NODE_ENV,
});

// Error handler middleware
app.use(Sentry.Handlers.errorHandler());

Tests de santé

Point de terminaison de la santé de l’application :

// Health check endpoint
app.get('/health', async (req, res) => {
  try {
    // Check database connection
    await mongoose.connection.db.admin().ping();

    res.status(200).json({
      status: 'healthy',
      timestamp: new Date().toISOString(),
      uptime: process.uptime(),
      memory: process.memoryUsage(),
      database: 'connected'
    });
  } catch (error) {
    res.status(503).json({
      status: 'unhealthy',
      error: error.message
    });
  }
});

Sauvegarde et restauration

Stratégies de sauvegarde des données pour les environnements de production :

Sauvegardes de la base de données

EC2 Snapshot + mongodump Strategy:

  • Take AWS EBS snapshots of the MongoDB data volume on a schedule

  • Run periodic mongodump to an S3 bucket for logical backups

  • Test restoration into a staging instance regularly

Scripts de sauvegarde manuels :

#!/bin/bash
# backup-script.sh

DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR="/backups/amrnet_$DATE"

# Create backup directory
mkdir -p $BACKUP_DIR

# Backup each collection
mongodump --uri="$MONGODB_URI" --out=$BACKUP_DIR

# Compress backup
tar -czf "$BACKUP_DIR.tar.gz" -C /backups "amrnet_$DATE"

# Clean up uncompressed backup
rm -rf $BACKUP_DIR

# Upload to cloud storage (optional)
aws s3 cp "$BACKUP_DIR.tar.gz" s3://amrnet-backups/

Sauvegardes de l’application

Sauvegarde du code et de la configuration :

# Git-based backup strategy
git tag -a "production-$(date +%Y%m%d)" -m "Production backup $(date)"
git push origin --tags

Considérations de sécurité

Meilleures pratiques de sécurité pour le déploiement de production :

Sécurité de l’environnement

Variables d’environnement sécurisées :

# Use secure credential management
heroku config:set MONGODB_URI="$(cat mongodb_uri.txt)"

# Rotate credentials regularly
heroku config:set SESSION_SECRET="$(openssl rand -base64 32)"

Sécurité du réseau :

// CORS configuration
const cors = require('cors');

app.use(cors({
  origin: process.env.ALLOWED_ORIGINS?.split(',') || 'https://amrnet.org',
  credentials: true,
  optionsSuccessStatus: 200
}));

Sécurité de la base de données

Sécurité MongoDB :

  • Activer l’authentification et l’autorisation

  • Utiliser SSL/TLS pour les connexions

  • Implémenter la whitelisting IP

  • Mises à jour de sécurité régulières

  • Journalisation de l’audit pour l’accès à la base de données

Dépannage

Problèmes de déploiement et solutions courantes :

Échecs de construction :

# Clear build cache
rm -rf node_modules package-lock.json
npm install

# Frontend build issues
cd client
rm -rf node_modules package-lock.json build
npm install
npm run build

Problèmes de connexion à la base de données :

# Test MongoDB connection
mongosh "your-mongodb-uri"

# Check network connectivity
ping cluster.mongodb.net

Problèmes de performance :

# Monitor resource usage
heroku ps:exec
top

# Check logs for errors
heroku logs --tail

Problèmes de mémoire :

# Increase Heroku dyno size
heroku ps:scale web=1:standard-2x

# Check memory usage patterns
heroku logs --source=heroku.router