Guia de implantação¶

Este guia abrange estratégias de implantação para AMRnet, incluindo desenvolvimento local, ambientes de preparo e implantação de produção em várias plataformas.

Configurações do Ambiente¶

AMRnet suporta vários ambientes de implantação com configurações diferentes:

Ambiente de Desenvolvimento¶

Para desenvolvimento local com hot reloading e depuração:

# 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

Variáveis de ambiente (.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 Desenvolvimento:

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

Ambiente de Staging¶

Para testar as compilações de produção localmente:

# Build production bundle
npm run build

# Start production server
NODE_ENV=production npm start

Implantação de produção¶

Implantação de Heroku¶

AMRnet é otimizado para deploy de Heroku com processos de compilação 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. Configuração de ambiente:

# 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. Implementação:

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

# Monitor deployment
heroku logs --tail

Arquivos de configuração do Heroku:

Perfil:

web: node server.js

package.json (script heroku-postbuild):

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

Configuração do Atlas MongoDB¶

Para a implantação do banco de dados:

1. Atlas Cluster Setup:

Criar conta no MongoDB Atlas
Criar novo cluster (M0 tier livre para teste)
Configurar acesso à rede (whitelist seus IPs)
Criar usuário do banco de dados com permissões de leitura/escrita

2. Configuração de Conexão:

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

3. Otimização de produção:

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

Implantação do Docker¶

Para implantação containerizada:

Dockerfile:

# 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 implantação:

# Build and start containers
docker-compose up -d

# View logs
docker-compose logs -f amrnet

Implantação AWS¶

Para implantação AWS usando Elastic Beanstalk:

1. Configuração do CLI EB:

# Install EB CLI
pip install awsebcli

# Initialize EB application
eb init amrnet

# Create environment
eb create amrnet-production

2. Arquivos de configuração:

.ebextensions/01_node_command.config:

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

3. Implantar:

# Deploy to AWS
eb deploy

# Monitor health
eb health

Otimização de desempenho¶

Otimizações de implantação de produção para melhor desempenho:

Otimizações de compilação¶

Configuração de construção do 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"
  }
}

Otimizações do Servidor¶

Configuração de Produção do 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
}));

Otimizações do Banco de Dados¶

Índices de produção do 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 });

Monitoramento e registro¶

Configuração de monitoramento de produção para rastreamento de desempenho e erro de rastreamento:

Monitoramento de Aplicações¶

Configuração do Winston Logging:

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

Performance Monitoring Middleware:

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

Rastreamento de erros¶

Integração de entrada:

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

Exame de saúde¶

Ponto de extremidade do aplicativo:

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

Backup e recuperação¶

Estratégias de backup de dados para ambientes de produção:

Backups de banco¶

Backups automatizados do MongoDB Atls:

O Atlas fornece backups automatizados com recuperação ponto-tempo
Configurar horário de backup e políticas de retenção
Testar procedimentos de restauração de backup regularmente

Scripts de backup manuais:

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

Backups do aplicativo¶

Código e backup de configuração:

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

Considerações de segurança¶

Melhores práticas de segurança para a implantação na produção:

Segurança do Ambiente¶

Variáveis de ambiente seguras:

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

Segurança de rede:

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

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

Segurança da base¶

Segurança do MongoDB:

Habilitar autenticação e autorização
Usar SSL/TLS para conexões
Implementar lista branca IP
Atualizações de segurança regulares
Registro de auditoria para acesso ao banco de dados

Solução de problemas¶

Questões e soluções comuns de implantação:

Falha na compilação:

# 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 Conexão:

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

# Check network connectivity
ping cluster.mongodb.net

Problemas de desempenho:

# Monitor resource usage
heroku ps:exec
top

# Check logs for errors
heroku logs --tail

Problemas de memória:

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

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