Guía de despliegue¶

Esta guía cubre estrategias de despliegue para AMRnet, incluyendo desarrollo local, entornos de puesta en escena y despliegue de producción en varias plataformas.

Configuración de entorno¶

AMRnet soporta múltiples entornos de despliegue con diferentes configuraciones:

Entorno de Desarrollo¶

Para desarrollo local con recarga caliente y depuración:

# 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 de entorno (.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

Iniciar Servidores de Desarrollo:

# 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)

Entorno de Staging¶

Para pruebas de construcción de producción localmente:

# Build production bundle
npm run build

# Start production server
NODE_ENV=production npm start

Despliegue de producción¶

Despliegue de Heroku¶

AMRnet está optimizado para la implementación de Heroku con procesos de construcción automáticos:

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. Configuración del entorno:

# 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. Desplegamiento:

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

# Monitor deployment
heroku logs --tail

Archivos de configuración de Heroku:

Perfil:

web: node server.js

package.json (heroku-postbuild script):

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

Configuración del Atlas de MongoDB¶

Para despliegue de base de datos de producción:

1. Atlas Cluster Setup:

Crear cuenta de MongoDB Atlas
Crear un nuevo clúster (nivel gratuito M0 para la prueba)
Configurar acceso a la red (lista blanca de sus IPs)
Crear usuario de base de datos con permisos de lectura/escritura

2. Configuración de la conexión:

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

3. Optimizaciones de producción:

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

Despliegue de Docker¶

Para el despliegue contenedor:

Archivo 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:

Comandos de despliegue:

# Build and start containers
docker-compose up -d

# View logs
docker-compose logs -f amrnet

Despliegue AWS¶

Para el despliegue de AWS usando Elastic Beanstalk:

1. Configuración de EB CLI:

# Install EB CLI
pip install awsebcli

# Initialize EB application
eb init amrnet

# Create environment
eb create amrnet-production

2. Archivos de configuración:

.ebextensions/01_node_command.config:

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

3. Desplegar:

# Deploy to AWS
eb deploy

# Monitor health
eb health

Optimización de rendimiento¶

Optimizaciones de despliegue de producción para un mejor rendimiento:

Crear Optimizaciones¶

Configuración de la compilación del cliente:

// 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"
  }
}

Optimizaciones de servidor¶

Configuración de Producción de 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
}));

Optimizaciones de base de datos¶

Índice de Producción de 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 });

Monitoreo y Registro¶

Configuración de monitorización de producción para el rendimiento y seguimiento de errores:

Monitoreo de aplicaciones¶

Configuración de registro de Winston:

// 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 Monitoreo de Rendimiento:

// 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();
};

Seguimiento de errores¶

**Integración centinela **

// 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());

Comprobaciones de salud¶

Terminal de Salud de la aplicación:

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

Copia de seguridad y recuperación¶

Estrategias de respaldo de datos para entornos de producción:

Copias de seguridad de base de datos¶

Respaldas automatizadas de Atlas de MongoDB:

Atlas proporciona copias de seguridad automatizadas con recuperación punto-en-tiempo
Configurar la agenda de copias de seguridad y políticas de retención
Pruebe regularmente los procedimientos de restauración de copias de seguridad

Copia de seguridad manual:

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

Copias de seguridad de aplicaciones¶

Copia de seguridad de código y configuración:

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

Consideraciones de seguridad¶

Mejores prácticas de seguridad para el despliegue de la producción:

Seguridad del entorno¶

Variables de entorno seguros:

# 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)"

Seguridad de red:

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

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

Seguridad de la base de datos¶

Seguridad MongoDB:

Habilitar autenticación y autorización
Usar SSL/TLS para conexiones
Implementar lista blanca de IP
Actualizaciones de seguridad regulares
Registro de auditoría para acceso a base de datos

Solución de problemas¶

Problemas y soluciones comunes de despliegue:

Fallos de compilación:

# 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

Problemas de conexión de base de datos:

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

# Check network connectivity
ping cluster.mongodb.net

Problemas de rendimiento:

# Monitor resource usage
heroku ps:exec
top

# Check logs for errors
heroku logs --tail

Problemas de memoria:

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

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