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

# Add MongoDB Atlas add-on (or use existing Atlas cluster)
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-atlas-uri"
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"
  }
}

Configuration de l’Atlas MongoDB¶

Pour le déploiement de la base de données de production :

1. Atlas Cluster Setup:

Créer un compte MongoDB Atlas
Créer une nouvelle grappe de serveurs (M0 niveau gratuit pour les tests)
Configurer l’accès au réseau (liste blanche de vos IPs)
Créer un utilisateur de la base de données avec les permissions en lecture/écriture

2. Configuration de la connexion :

# Atlas connection string format
MONGODB_URI=mongodb+srv://username:password@cluster.mongodb.net/amrnet?retryWrites=true&w=majority

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¶

Sauvegardes automatisées de l’Atlas MongoDB :

Atlas fournit des sauvegardes automatisées avec la restauration ponctuelle
Configurer le calendrier de sauvegarde et les politiques de rétention
Tester régulièrement les procédures de restauration de sauvegarde

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