@gugananuvem/aws-local-simulator 1.0.9 → 1.0.10

package/README.md

@@ -24,9 +24,10 @@ Simulador local completo para serviços AWS. Desenvolva e teste suas aplicaçõe
 
 ```bash
 npm install --save-dev aws-local-simulator
+```
 🚀 Uso Rápido
 1. Crie um arquivo de configuração aws-local-simulator.json:
-json
+```json
 {
   "services": {
     "dynamodb": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gugananuvem/aws-local-simulator",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "Simulador local completo para serviços AWS",
   "main": "src/index.js",
   "bin": {
@@ -109,6 +109,6 @@
       "optional": true
     }
   },
-  "buildDate": "2026-03-29T02:36:24.504Z",
+  "buildDate": "2026-03-29T15:37:11.579Z",
   "published": true
 }

package/src/config/default-config.js

@@ -9,8 +9,8 @@ module.exports = {
     s3: true,
     sqs: true,
     lambda: true,
-    sns: false, // Desabilitado por padrão
-    eventbridge: false, // Desabilitado por padrão
+    sns: false,
+    eventbridge: false,
     ecs: false,
     cognito: false,
     apigateway: false,

package/src/config/env-loader.js

@@ -13,8 +13,9 @@ class EnvLoader {
       dynamodb: this.getEnvBool('AWS_LOCAL_SIMULATOR_DYNAMODB', true),
       s3: this.getEnvBool('AWS_LOCAL_SIMULATOR_S3', true),
       sqs: this.getEnvBool('AWS_LOCAL_SIMULATOR_SQS', true),
-      lambda: this.getEnvBool('AWS_LOCAL_SIMULATOR_LAMBDA', true),
       sns: this.getEnvBool('AWS_LOCAL_SIMULATOR_SNS', false),
+      lambda: this.getEnvBool('AWS_LOCAL_SIMULATOR_LAMBDA', true),
+      apigateway: this.getEnvBool('AWS_LOCAL_SIMULATOR_APIGATEWAY', false),
       eventbridge: this.getEnvBool('AWS_LOCAL_SIMULATOR_EVENTBRIDGE', false)
     };
     
@@ -25,6 +26,7 @@ class EnvLoader {
       sqs: this.getEnvInt('AWS_LOCAL_SIMULATOR_SQS_PORT', 9324),
       lambda: this.getEnvInt('AWS_LOCAL_SIMULATOR_LAMBDA_PORT', 3001),
       sns: this.getEnvInt('AWS_LOCAL_SIMULATOR_SNS_PORT', 9911),
+      apigateway: this.getEnvInt('AWS_LOCAL_SIMULATOR_APIGATEWAY_PORT', 4567),
       eventbridge: this.getEnvInt('AWS_LOCAL_SIMULATOR_EVENTBRIDGE_PORT', 4010)
     };
     

package/src/server.js

@@ -16,6 +16,7 @@ const SNSService = require("./services/sns");
 const EventBridgeService = require("./services/eventbridge");
 const CognitoService = require("./services/cognito");
 const APIGatewayService = require("./services/apigateway");
+const ECSService = require("./services/ecs");
 
 class Server {
   constructor(config) {
@@ -71,6 +72,8 @@ class Server {
       { name: "sns", class: SNSService, depends: [] },
       { name: "eventbridge", class: EventBridgeService, depends: [] },
       { name: "cognito", class: CognitoService, depends: [] },
+      { name: "ecs", class: ECSService, depends: [] },
+      { name: "cognito", class:CognitoService, depends: [] },
       { name: "apigateway", class: APIGatewayService, depends: [] },
     ];
 

package/src/services/ecs/index.js

@@ -0,0 +1,66 @@
+/**
+ * ECS Service - Simulador de Elastic Container Service
+ * Suporta: Fargate, EC2 launch types, Tasks, Services
+ */
+
+const ECSServer = require('./server');
+const ECSSimulator = require('./simulator');
+
+class ECSService {
+  constructor(config) {
+    this.config = config;
+    this.name = 'ecs';
+    this.port = config.ports.ecs || 8080;
+    this.server = null;
+    this.simulator = null;
+    this.isRunning = false;
+  }
+
+  async initialize() {
+    const logger = require('../../utils/logger');
+    logger.debug(`Inicializando ECS Service na porta ${this.port}...`);
+    
+    this.simulator = new ECSSimulator(this.config);
+    await this.simulator.initialize();
+    
+    this.server = new ECSServer(this.port, this.config);
+    this.server.simulator = this.simulator;
+    
+    await this.server.initialize();
+    
+    logger.debug('ECS Service inicializado');
+  }
+
+  async start() {
+    if (this.isRunning) return;
+    await this.server.start();
+    this.isRunning = true;
+  }
+
+  async stop() {
+    if (!this.isRunning) return;
+    await this.server.stop();
+    this.isRunning = false;
+  }
+
+  async reset() {
+    await this.simulator.reset();
+  }
+
+  getStatus() {
+    return {
+      running: this.isRunning,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      clustersCount: this.simulator?.getClustersCount() || 0,
+      servicesCount: this.simulator?.getServicesCount() || 0,
+      tasksCount: this.simulator?.getTasksCount() || 0
+    };
+  }
+
+  getSimulator() {
+    return this.simulator;
+  }
+}
+
+module.exports = ECSService;

package/src/services/ecs/server.js

@@ -0,0 +1,234 @@
+/**
+ * ECS Server - Servidor HTTP para ECS API
+ */
+
+const express = require('express');
+const logger = require('../../utils/logger');
+
+class ECSServer {
+  constructor(port, config) {
+    this.port = port;
+    this.config = config;
+    this.app = express();
+    this.simulator = null;
+    this.server = null;
+    this.setupMiddlewares();
+  }
+
+  setupMiddlewares() {
+    this.app.use(express.json());
+    
+    if (logger.currentLogLevel === 'verboso') {
+      this.app.use((req, res, next) => {
+        const start = Date.now();
+        res.on('finish', () => {
+          const duration = Date.now() - start;
+          logger.verboso(`ECS: ${req.method} ${req.path} - ${duration}ms`);
+        });
+        next();
+      });
+    }
+  }
+
+  async initialize() {
+    this.setupRoutes();
+    logger.debug('ECS Server inicializado');
+  }
+
+  setupRoutes() {
+    // Health check
+    this.app.get('/health', (req, res) => {
+      res.json({
+        status: 'healthy',
+        service: 'ecs-simulator',
+        version: '1.0.0'
+      });
+    });
+
+    // Cluster operations
+    this.app.post('/clusters', (req, res) => {
+      const { clusterName } = req.body;
+      const result = this.simulator.createCluster(clusterName);
+      if (result.error) {
+        res.status(result.status).json(result.error);
+      } else {
+        res.json(result.cluster);
+      }
+    });
+
+    this.app.get('/clusters', (req, res) => {
+      const clusters = this.simulator.listClusters();
+      res.json({ clusterArns: clusters.map(c => `arn:aws:ecs:local:000000000000:cluster/${c}`) });
+    });
+
+    this.app.get('/clusters/:clusterName', (req, res) => {
+      try {
+        const result = this.simulator.describeCluster(req.params.clusterName);
+        res.json(result);
+      } catch (error) {
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    this.app.delete('/clusters/:clusterName', (req, res) => {
+      const result = this.simulator.deleteCluster(req.params.clusterName);
+      if (result.error) {
+        res.status(result.status).json(result.error);
+      } else {
+        res.json({ message: 'Cluster deleted' });
+      }
+    });
+
+    // Task Definition operations
+    this.app.post('/task-definitions', (req, res) => {
+      const result = this.simulator.registerTaskDefinition(req.body);
+      if (result.error) {
+        res.status(result.status).json(result.error);
+      } else {
+        res.json(result.taskDefinition);
+      }
+    });
+
+    // Service operations
+    this.app.post('/services', (req, res) => {
+      const result = this.simulator.createService(req.body);
+      if (result.error) {
+        res.status(result.status).json(result.error);
+      } else {
+        res.json(result.service);
+      }
+    });
+
+    this.app.put('/services/:serviceName', (req, res) => {
+      const result = this.simulator.updateService({
+        ...req.body,
+        service: req.params.serviceName
+      });
+      if (result.error) {
+        res.status(result.status).json(result.error);
+      } else {
+        res.json(result.service);
+      }
+    });
+
+    // Task operations
+    this.app.post('/tasks', (req, res) => {
+      this.simulator.runTask(req.body).then(result => {
+        if (result.error) {
+          res.status(result.status).json(result.error);
+        } else {
+          res.json(result.task);
+        }
+      });
+    });
+
+    this.app.get('/tasks', (req, res) => {
+      const result = this.simulator.listTasks(req.query);
+      res.json(result);
+    });
+
+    this.app.post('/tasks/describe', (req, res) => {
+      const result = this.simulator.describeTasks(req.body);
+      res.json(result);
+    });
+
+    this.app.post('/tasks/:taskArn/stop', (req, res) => {
+      this.simulator.stopTask(req.params.taskArn).then(result => {
+        if (result.error) {
+          res.status(result.status).json(result.error);
+        } else {
+          res.json(result.task);
+        }
+      });
+    });
+
+    // Admin endpoints
+    this.setupAdminRoutes();
+  }
+
+  setupAdminRoutes() {
+    this.app.get('/__admin/clusters', (req, res) => {
+      res.json({
+        clusters: this.simulator.getClustersCount(),
+        services: this.simulator.getServicesCount(),
+        tasks: this.simulator.getTasksCount(),
+        runningContainers: this.simulator.getRunningContainers()
+      });
+    });
+
+    this.app.get('/__admin/clusters/:clusterName/details', (req, res) => {
+      const cluster = this.simulator.clusters.get(req.params.clusterName);
+      if (cluster) {
+        res.json(cluster);
+      } else {
+        res.status(404).json({ error: 'Cluster not found' });
+      }
+    });
+
+    this.app.get('/__admin/containers', (req, res) => {
+      const containers = [];
+      for (const [id, process] of this.simulator.containerProcesses) {
+        containers.push({
+          containerId: id,
+          taskArn: process.taskArn,
+          container: process.container,
+          running: process.running,
+          startTime: process.startTime
+        });
+      }
+      res.json(containers);
+    });
+
+    this.app.get('/__admin/ports', (req, res) => {
+      res.json({
+        availablePorts: Array.from(this.simulator.availablePorts),
+        usedPorts: this.getUsedPorts()
+      });
+    });
+  }
+
+  getUsedPorts() {
+    const usedPorts = [];
+    for (const [_, process] of this.simulator.containerProcesses) {
+      for (const mapping of process.container.portMappings) {
+        if (mapping.hostPort) {
+          usedPorts.push(mapping.hostPort);
+        }
+      }
+    }
+    return usedPorts;
+  }
+
+  start() {
+    return new Promise((resolve) => {
+      this.server = this.app.listen(this.port, () => {
+        logger.info(`🐳 ECS/Fargate rodando em http://localhost:${this.port}`);
+        resolve();
+      });
+    });
+  }
+
+  stop() {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => resolve());
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  getStatus() {
+    return {
+      running: !!this.server,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      clustersCount: this.simulator?.getClustersCount() || 0,
+      servicesCount: this.simulator?.getServicesCount() || 0,
+      tasksCount: this.simulator?.getTasksCount() || 0,
+      runningContainers: this.simulator?.getRunningContainers() || 0
+    };
+  }
+}
+
+module.exports = ECSServer;

package/src/services/ecs/simulator.js

@@ -0,0 +1,845 @@
+/**
+ * ECS Simulator Core
+ * Simula clusters, serviços, tarefas e containers
+ */
+
+const crypto = require('crypto');
+const { spawn, exec } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const logger = require('../../utils/logger');
+const LocalStore = require('../../utils/local-store');
+
+class ECSSimulator {
+  constructor(config) {
+    this.config = config;
+    this.dataDir = path.join(process.env.AWS_LOCAL_SIMULATOR_DATA_DIR, 'ecs');
+    this.store = new LocalStore(this.dataDir);
+    this.clusters = new Map();
+    this.services = new Map();
+    this.tasks = new Map();
+    this.containerProcesses = new Map();
+    this.availablePorts = new Set();
+    this.nextPort = 50000;
+  }
+
+  async initialize() {
+    logger.debug('Inicializando ECS Simulator...');
+    this.loadClusters();
+    this.loadServices();
+    this.loadTasks();
+    
+    // Inicializa range de portas para containers
+    for (let i = 50000; i <= 51000; i++) {
+      this.availablePorts.add(i);
+    }
+    this.nextPort = 50000;
+    
+    logger.debug(`✅ ECS Simulator inicializado com ${this.clusters.size} clusters, ${this.services.size} serviços, ${this.tasks.size} tarefas`);
+  }
+
+  loadClusters() {
+    const savedClusters = this.store.read('__clusters__');
+    if (savedClusters) {
+      for (const [name, data] of Object.entries(savedClusters)) {
+        this.clusters.set(name, {
+          name: data.name,
+          arn: data.arn,
+          status: data.status,
+          createdAt: new Date(data.createdAt),
+          services: data.services || [],
+          tasks: data.tasks || []
+        });
+      }
+    }
+    
+    // Cria clusters da configuração
+    if (this.config.ecs?.clusters) {
+      for (const clusterName of this.config.ecs.clusters) {
+        this.createCluster(clusterName);
+      }
+    }
+  }
+
+  loadServices() {
+    const savedServices = this.store.read('__services__');
+    if (savedServices) {
+      for (const [name, data] of Object.entries(savedServices)) {
+        this.services.set(name, {
+          name: data.name,
+          arn: data.arn,
+          clusterArn: data.clusterArn,
+          taskDefinition: data.taskDefinition,
+          desiredCount: data.desiredCount,
+          runningCount: data.runningCount,
+          status: data.status,
+          loadBalancers: data.loadBalancers,
+          networkConfiguration: data.networkConfiguration,
+          schedulingStrategy: data.schedulingStrategy,
+          createdAt: new Date(data.createdAt)
+        });
+      }
+    }
+  }
+
+  loadTasks() {
+    const savedTasks = this.store.read('__tasks__');
+    if (savedTasks) {
+      for (const [id, data] of Object.entries(savedTasks)) {
+        this.tasks.set(id, {
+          taskArn: data.taskArn,
+          taskDefinitionArn: data.taskDefinitionArn,
+          clusterArn: data.clusterArn,
+          serviceName: data.serviceName,
+          containers: data.containers,
+          lastStatus: data.lastStatus,
+          desiredStatus: data.desiredStatus,
+          startedAt: new Date(data.startedAt),
+          stoppedAt: data.stoppedAt ? new Date(data.stoppedAt) : null,
+          stopCode: data.stopCode,
+          createdAt: new Date(data.createdAt)
+        });
+        
+        // Reconstitui processos de container se estavam rodando
+        if (data.lastStatus === 'RUNNING') {
+          this.startContainerProcess(data.taskArn, data.containers);
+        }
+      }
+    }
+  }
+
+  // ============ Cluster Operations ============
+
+  createCluster(clusterName) {
+    if (this.clusters.has(clusterName)) {
+      return { error: { code: 'ClusterExists', message: 'Cluster already exists' }, status: 409 };
+    }
+    
+    const cluster = {
+      name: clusterName,
+      arn: `arn:aws:ecs:local:000000000000:cluster/${clusterName}`,
+      status: 'ACTIVE',
+      createdAt: new Date(),
+      services: [],
+      tasks: []
+    };
+    
+    this.clusters.set(clusterName, cluster);
+    this.persistClusters();
+    
+    logger.debug(`✅ Cluster ECS criado: ${clusterName}`);
+    
+    return { cluster };
+  }
+
+  listClusters() {
+    return Array.from(this.clusters.keys());
+  }
+
+  describeCluster(clusterName) {
+    const cluster = this.clusters.get(clusterName);
+    if (!cluster) {
+      throw new Error(`Cluster ${clusterName} not found`);
+    }
+    
+    return {
+      cluster: {
+        clusterName: cluster.name,
+        clusterArn: cluster.arn,
+        status: cluster.status,
+        registeredContainerInstancesCount: 0,
+        runningTasksCount: this.getRunningTasksCount(clusterName),
+        pendingTasksCount: this.getPendingTasksCount(clusterName),
+        activeServicesCount: this.getActiveServicesCount(clusterName),
+        statistics: []
+      }
+    };
+  }
+
+  deleteCluster(clusterName) {
+    const cluster = this.clusters.get(clusterName);
+    if (!cluster) {
+      return { error: { code: 'ClusterNotFound', message: 'Cluster not found' }, status: 404 };
+    }
+    
+    const services = this.getServicesInCluster(clusterName);
+    if (services.length > 0) {
+      return { error: { code: 'ClusterNotEmpty', message: 'Cluster has active services' }, status: 409 };
+    }
+    
+    const tasks = this.getTasksInCluster(clusterName);
+    if (tasks.length > 0) {
+      return { error: { code: 'ClusterNotEmpty', message: 'Cluster has active tasks' }, status: 409 };
+    }
+    
+    this.clusters.delete(clusterName);
+    this.persistClusters();
+    
+    return { success: true };
+  }
+
+  // ============ Task Definition Operations ============
+
+  registerTaskDefinition(params) {
+    const { family, containerDefinitions, networkMode, cpu, memory, executionRoleArn, taskRoleArn } = params;
+    
+    const taskDefinitionArn = `arn:aws:ecs:local:000000000000:task-definition/${family}:${this.getNextRevision(family)}`;
+    
+    const taskDefinition = {
+      family,
+      taskDefinitionArn,
+      revision: this.getNextRevision(family),
+      containerDefinitions: containerDefinitions.map(this.normalizeContainerDefinition.bind(this)),
+      networkMode: networkMode || 'awsvpc',
+      cpu: cpu || '256',
+      memory: memory || '512',
+      executionRoleArn,
+      taskRoleArn,
+      status: 'ACTIVE',
+      registeredAt: new Date().toISOString()
+    };
+    
+    this.store.write(`taskdef_${family}_${taskDefinition.revision}`, taskDefinition);
+    this.persistTaskDefinitions();
+    
+    logger.debug(`✅ Task Definition registrada: ${taskDefinitionArn}`);
+    
+    return { taskDefinition };
+  }
+
+  getNextRevision(family) {
+    const files = this.store.list();
+    const revisions = files
+      .filter(f => f.startsWith(`taskdef_${family}_`))
+      .map(f => parseInt(f.split('_')[2]) || 0);
+    
+    return Math.max(0, ...revisions) + 1;
+  }
+
+  normalizeContainerDefinition(container) {
+    return {
+      name: container.name,
+      image: container.image,
+      cpu: container.cpu || 0,
+      memory: container.memory || 0,
+      memoryReservation: container.memoryReservation || 0,
+      essential: container.essential !== false,
+      portMappings: (container.portMappings || []).map(pm => ({
+        containerPort: pm.containerPort,
+        hostPort: pm.hostPort || 0,
+        protocol: pm.protocol || 'tcp'
+      })),
+      environment: container.environment || [],
+      environmentFiles: container.environmentFiles || [],
+      secrets: container.secrets || [],
+      mountPoints: container.mountPoints || [],
+      volumesFrom: container.volumesFrom || [],
+      linuxParameters: container.linuxParameters || {},
+      logConfiguration: container.logConfiguration || {
+        logDriver: 'awslogs',
+        options: {
+          'awslogs-group': `/ecs/${container.name}`,
+          'awslogs-region': 'local',
+          'awslogs-stream-prefix': 'ecs'
+        }
+      }
+    };
+  }
+
+  // ============ Service Operations ============
+
+  createService(params) {
+    const { cluster, serviceName, taskDefinition, desiredCount, loadBalancers, networkConfiguration, schedulingStrategy } = params;
+    
+    const clusterObj = this.clusters.get(cluster);
+    if (!clusterObj) {
+      return { error: { code: 'ClusterNotFound', message: 'Cluster not found' }, status: 404 };
+    }
+    
+    if (this.services.has(serviceName)) {
+      return { error: { code: 'ServiceExists', message: 'Service already exists' }, status: 409 };
+    }
+    
+    const serviceArn = `arn:aws:ecs:local:000000000000:service/${cluster}/${serviceName}`;
+    
+    const service = {
+      name: serviceName,
+      arn: serviceArn,
+      clusterArn: clusterObj.arn,
+      taskDefinition,
+      desiredCount: desiredCount || 1,
+      runningCount: 0,
+      pendingCount: 0,
+      status: 'ACTIVE',
+      loadBalancers: loadBalancers || [],
+      networkConfiguration: networkConfiguration || {
+        awsvpcConfiguration: {
+          subnets: ['subnet-local'],
+          securityGroups: ['sg-local'],
+          assignPublicIp: 'ENABLED'
+        }
+      },
+      schedulingStrategy: schedulingStrategy || 'REPLICA',
+      createdAt: new Date(),
+      tasks: []
+    };
+    
+    this.services.set(serviceName, service);
+    clusterObj.services.push(serviceName);
+    this.persistServices();
+    this.persistClusters();
+    
+    // Inicia as tarefas do serviço
+    if (desiredCount > 0) {
+      this.scaleService(serviceName, desiredCount);
+    }
+    
+    logger.debug(`✅ Serviço ECS criado: ${serviceName} (${desiredCount} tarefas)`);
+    
+    return { service };
+  }
+
+  updateService(params) {
+    const { cluster, service, desiredCount, taskDefinition } = params;
+    
+    const serviceObj = this.services.get(service);
+    if (!serviceObj) {
+      return { error: { code: 'ServiceNotFound', message: 'Service not found' }, status: 404 };
+    }
+    
+    if (desiredCount !== undefined) {
+      serviceObj.desiredCount = desiredCount;
+      this.scaleService(service, desiredCount);
+    }
+    
+    if (taskDefinition) {
+      serviceObj.taskDefinition = taskDefinition;
+      // Em produção, faria uma atualização gradual
+      this.updateServiceTasks(service, taskDefinition);
+    }
+    
+    this.persistServices();
+    
+    return { service: serviceObj };
+  }
+
+  scaleService(serviceName, desiredCount) {
+    const service = this.services.get(serviceName);
+    if (!service) return;
+    
+    const currentCount = this.getRunningTasksCountForService(serviceName);
+    const diff = desiredCount - currentCount;
+    
+    if (diff > 0) {
+      // Scale up
+      for (let i = 0; i < diff; i++) {
+        this.runTask({
+          cluster: service.clusterArn.split('/').pop(),
+          taskDefinition: service.taskDefinition,
+          serviceName: service.name
+        });
+      }
+    } else if (diff < 0) {
+      // Scale down
+      const tasks = this.getTasksForService(serviceName);
+      const toStop = tasks.slice(0, -diff);
+      for (const task of toStop) {
+        this.stopTask(task.taskArn);
+      }
+    }
+    
+    service.runningCount = this.getRunningTasksCountForService(serviceName);
+    service.pendingCount = this.getPendingTasksCountForService(serviceName);
+  }
+
+  // ============ Task Operations ============
+
+  async runTask(params) {
+    const { cluster, taskDefinition, serviceName, overrides } = params;
+    
+    const clusterObj = this.clusters.get(cluster);
+    if (!clusterObj) {
+      return { error: { code: 'ClusterNotFound', message: 'Cluster not found' }, status: 404 };
+    }
+    
+    // Busca a task definition
+    const taskDef = this.getTaskDefinition(taskDefinition);
+    if (!taskDef) {
+      return { error: { code: 'TaskDefinitionNotFound', message: 'Task definition not found' }, status: 404 };
+    }
+    
+    const taskId = crypto.randomUUID();
+    const taskArn = `arn:aws:ecs:local:000000000000:task/${cluster}/${taskId}`;
+    
+    // Prepara containers com portas mapeadas
+    const containers = await this.prepareContainers(taskDef.containerDefinitions, overrides);
+    
+    const task = {
+      taskArn,
+      taskDefinitionArn: taskDef.taskDefinitionArn,
+      clusterArn: clusterObj.arn,
+      serviceName: serviceName || null,
+      containers,
+      lastStatus: 'PROVISIONING',
+      desiredStatus: 'RUNNING',
+      startedAt: null,
+      stoppedAt: null,
+      stopCode: null,
+      createdAt: new Date(),
+      overrides: overrides || {}
+    };
+    
+    this.tasks.set(taskArn, task);
+    clusterObj.tasks.push(taskArn);
+    
+    if (serviceName) {
+      const service = this.services.get(serviceName);
+      if (service) {
+        service.tasks.push(taskArn);
+        service.pendingCount++;
+      }
+    }
+    
+    this.persistTasks();
+    this.persistClusters();
+    this.persistServices();
+    
+    logger.debug(`📦 Tarefa ECS criada: ${taskArn}`);
+    
+    // Inicia os containers
+    this.startTask(task);
+    
+    return { task };
+  }
+
+  async prepareContainers(containerDefs, overrides) {
+    const containers = [];
+    
+    for (const containerDef of containerDefs) {
+      // Aloca portas para o container
+      const portMappings = [];
+      for (const mapping of containerDef.portMappings || []) {
+        const hostPort = this.allocatePort();
+        portMappings.push({
+          containerPort: mapping.containerPort,
+          hostPort,
+          protocol: mapping.protocol
+        });
+      }
+      
+      containers.push({
+        name: containerDef.name,
+        image: containerDef.image,
+        containerArn: `arn:aws:ecs:local:container/${crypto.randomUUID()}`,
+        lastStatus: 'PROVISIONING',
+        desiredStatus: 'RUNNING',
+        portMappings,
+        environment: containerDef.environment,
+        command: overrides?.containerOverrides?.find(c => c.name === containerDef.name)?.command || null,
+        startedAt: null,
+        stoppedAt: null
+      });
+    }
+    
+    return containers;
+  }
+
+  allocatePort() {
+    if (this.availablePorts.size === 0) {
+      // Expande range de portas
+      for (let i = this.nextPort; i <= this.nextPort + 100; i++) {
+        this.availablePorts.add(i);
+      }
+      this.nextPort += 100;
+    }
+    
+    const port = Array.from(this.availablePorts)[0];
+    this.availablePorts.delete(port);
+    return port;
+  }
+
+  releasePort(port) {
+    this.availablePorts.add(port);
+  }
+
+  async startTask(task) {
+    task.lastStatus = 'PENDING';
+    this.persistTasks();
+    
+    // Simula tempo de provisão
+    setTimeout(async () => {
+      task.lastStatus = 'RUNNING';
+      task.startedAt = new Date();
+      
+      if (task.serviceName) {
+        const service = this.services.get(task.serviceName);
+        if (service) {
+          service.runningCount++;
+          service.pendingCount--;
+          this.persistServices();
+        }
+      }
+      
+      this.persistTasks();
+      
+      // Inicia cada container
+      for (const container of task.containers) {
+        await this.startContainer(task.taskArn, container);
+      }
+      
+      logger.success(`✅ Tarefa ECS iniciada: ${task.taskArn}`);
+    }, 1000);
+  }
+
+  async startContainer(taskArn, container) {
+    const containerId = crypto.randomUUID();
+    container.lastStatus = 'RUNNING';
+    container.startedAt = new Date();
+    container.containerId = containerId;
+    
+    logger.info(`🐳 Container iniciado: ${container.name} (${container.image})`);
+    logger.info(`   Portas: ${container.portMappings.map(p => `${p.containerPort}:${p.hostPort}`).join(', ')}`);
+    
+    // Simula execução do container
+    // Em um cenário real, aqui você poderia realmente executar o container Docker
+    this.containerProcesses.set(container.containerId, {
+      taskArn,
+      container,
+      running: true,
+      startTime: new Date()
+    });
+    
+    this.persistTasks();
+  }
+
+  async stopTask(taskArn) {
+    const task = this.tasks.get(taskArn);
+    if (!task) {
+      return { error: { code: 'TaskNotFound', message: 'Task not found' }, status: 404 };
+    }
+    
+    // Para todos os containers
+    for (const container of task.containers) {
+      if (container.containerId) {
+        const process = this.containerProcesses.get(container.containerId);
+        if (process) {
+          process.running = false;
+          this.containerProcesses.delete(container.containerId);
+        }
+        container.lastStatus = 'STOPPED';
+        container.stoppedAt = new Date();
+        this.releasePorts(container.portMappings);
+      }
+    }
+    
+    task.lastStatus = 'STOPPED';
+    task.desiredStatus = 'STOPPED';
+    task.stoppedAt = new Date();
+    task.stopCode = 'UserInitiated';
+    
+    if (task.serviceName) {
+      const service = this.services.get(task.serviceName);
+      if (service && service.runningCount > 0) {
+        service.runningCount--;
+        this.persistServices();
+      }
+    }
+    
+    this.persistTasks();
+    
+    logger.debug(`🛑 Tarefa ECS parada: ${taskArn}`);
+    
+    return { task };
+  }
+
+  releasePorts(portMappings) {
+    for (const mapping of portMappings) {
+      if (mapping.hostPort) {
+        this.releasePort(mapping.hostPort);
+      }
+    }
+  }
+
+  listTasks(params) {
+    const { cluster, serviceName } = params;
+    let tasks = Array.from(this.tasks.values());
+    
+    if (cluster) {
+      tasks = tasks.filter(t => t.clusterArn.includes(cluster));
+    }
+    
+    if (serviceName) {
+      tasks = tasks.filter(t => t.serviceName === serviceName);
+    }
+    
+    return {
+      taskArns: tasks.map(t => t.taskArn)
+    };
+  }
+
+  describeTasks(params) {
+    const { cluster, tasks } = params;
+    const taskList = [];
+    
+    for (const taskArn of tasks) {
+      const task = this.tasks.get(taskArn);
+      if (task) {
+        taskList.push({
+          taskArn: task.taskArn,
+          taskDefinitionArn: task.taskDefinitionArn,
+          clusterArn: task.clusterArn,
+          serviceName: task.serviceName,
+          containers: task.containers.map(c => ({
+            name: c.name,
+            containerArn: c.containerArn,
+            lastStatus: c.lastStatus,
+            networkBindings: c.portMappings.map(pm => ({
+              containerPort: pm.containerPort,
+              hostPort: pm.hostPort,
+              protocol: pm.protocol
+            }))
+          })),
+          lastStatus: task.lastStatus,
+          desiredStatus: task.desiredStatus,
+          startedAt: task.startedAt,
+          stoppedAt: task.stoppedAt,
+          stopCode: task.stopCode,
+          createdAt: task.createdAt
+        });
+      }
+    }
+    
+    return { tasks: taskList, failures: [] };
+  }
+
+  // ============ Helper Methods ============
+
+  getTaskDefinition(taskDefinition) {
+    const [family, revision] = taskDefinition.split(':').pop().split('/').pop().split(':');
+    return this.store.read(`taskdef_${family}_${revision || this.getLatestRevision(family)}`);
+  }
+
+  getLatestRevision(family) {
+    const files = this.store.list();
+    const revisions = files
+      .filter(f => f.startsWith(`taskdef_${family}_`))
+      .map(f => parseInt(f.split('_')[2]) || 0);
+    
+    return Math.max(0, ...revisions);
+  }
+
+  getRunningTasksCount(clusterName) {
+    const cluster = this.clusters.get(clusterName);
+    if (!cluster) return 0;
+    
+    let count = 0;
+    for (const taskArn of cluster.tasks) {
+      const task = this.tasks.get(taskArn);
+      if (task && task.lastStatus === 'RUNNING') {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  getPendingTasksCount(clusterName) {
+    const cluster = this.clusters.get(clusterName);
+    if (!cluster) return 0;
+    
+    let count = 0;
+    for (const taskArn of cluster.tasks) {
+      const task = this.tasks.get(taskArn);
+      if (task && task.lastStatus === 'PENDING') {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  getActiveServicesCount(clusterName) {
+    const cluster = this.clusters.get(clusterName);
+    if (!cluster) return 0;
+    return cluster.services.length;
+  }
+
+  getServicesInCluster(clusterName) {
+    const cluster = this.clusters.get(clusterName);
+    if (!cluster) return [];
+    return cluster.services;
+  }
+
+  getTasksInCluster(clusterName) {
+    const cluster = this.clusters.get(clusterName);
+    if (!cluster) return [];
+    return cluster.tasks;
+  }
+
+  getRunningTasksCountForService(serviceName) {
+    const service = this.services.get(serviceName);
+    if (!service) return 0;
+    
+    let count = 0;
+    for (const taskArn of service.tasks) {
+      const task = this.tasks.get(taskArn);
+      if (task && task.lastStatus === 'RUNNING') {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  getPendingTasksCountForService(serviceName) {
+    const service = this.services.get(serviceName);
+    if (!service) return 0;
+    
+    let count = 0;
+    for (const taskArn of service.tasks) {
+      const task = this.tasks.get(taskArn);
+      if (task && task.lastStatus === 'PENDING') {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  getTasksForService(serviceName) {
+    const service = this.services.get(serviceName);
+    if (!service) return [];
+    
+    const tasks = [];
+    for (const taskArn of service.tasks) {
+      const task = this.tasks.get(taskArn);
+      if (task) {
+        tasks.push(task);
+      }
+    }
+    return tasks;
+  }
+
+  updateServiceTasks(serviceName, newTaskDefinition) {
+    const service = this.services.get(serviceName);
+    if (!service) return;
+    
+    const tasks = this.getTasksForService(serviceName);
+    for (const task of tasks) {
+      if (task.lastStatus === 'RUNNING') {
+        // Para a tarefa antiga e inicia nova
+        this.stopTask(task.taskArn);
+        this.runTask({
+          cluster: service.clusterArn.split('/').pop(),
+          taskDefinition: newTaskDefinition,
+          serviceName: service.name
+        });
+      }
+    }
+  }
+
+  // ============ Persistence ============
+
+  persistClusters() {
+    const clustersObj = {};
+    for (const [name, cluster] of this.clusters.entries()) {
+      clustersObj[name] = {
+        name: cluster.name,
+        arn: cluster.arn,
+        status: cluster.status,
+        createdAt: cluster.createdAt.toISOString(),
+        services: cluster.services,
+        tasks: cluster.tasks
+      };
+    }
+    this.store.write('__clusters__', clustersObj);
+  }
+
+  persistServices() {
+    const servicesObj = {};
+    for (const [name, service] of this.services.entries()) {
+      servicesObj[name] = {
+        name: service.name,
+        arn: service.arn,
+        clusterArn: service.clusterArn,
+        taskDefinition: service.taskDefinition,
+        desiredCount: service.desiredCount,
+        runningCount: service.runningCount,
+        status: service.status,
+        loadBalancers: service.loadBalancers,
+        networkConfiguration: service.networkConfiguration,
+        schedulingStrategy: service.schedulingStrategy,
+        createdAt: service.createdAt.toISOString(),
+        tasks: service.tasks
+      };
+    }
+    this.store.write('__services__', servicesObj);
+  }
+
+  persistTasks() {
+    const tasksObj = {};
+    for (const [arn, task] of this.tasks.entries()) {
+      tasksObj[arn] = {
+        taskArn: task.taskArn,
+        taskDefinitionArn: task.taskDefinitionArn,
+        clusterArn: task.clusterArn,
+        serviceName: task.serviceName,
+        containers: task.containers.map(c => ({
+          name: c.name,
+          image: c.image,
+          containerArn: c.containerArn,
+          lastStatus: c.lastStatus,
+          desiredStatus: c.desiredStatus,
+          portMappings: c.portMappings,
+          environment: c.environment,
+          startedAt: c.startedAt,
+          stoppedAt: c.stoppedAt
+        })),
+        lastStatus: task.lastStatus,
+        desiredStatus: task.desiredStatus,
+        startedAt: task.startedAt,
+        stoppedAt: task.stoppedAt,
+        stopCode: task.stopCode,
+        createdAt: task.createdAt.toISOString()
+      };
+    }
+    this.store.write('__tasks__', tasksObj);
+  }
+
+  persistTaskDefinitions() {
+    // Task definitions são persistidas individualmente
+    // Já salvas no registerTaskDefinition
+  }
+
+  async reset() {
+    // Para todas as tarefas em execução
+    for (const [taskArn] of this.tasks) {
+      await this.stopTask(taskArn);
+    }
+    
+    this.clusters.clear();
+    this.services.clear();
+    this.tasks.clear();
+    this.containerProcesses.clear();
+    
+    this.persistClusters();
+    this.persistServices();
+    this.persistTasks();
+    
+    logger.debug('ECS: Todos os dados resetados');
+  }
+
+  getClustersCount() {
+    return this.clusters.size;
+  }
+
+  getServicesCount() {
+    return this.services.size;
+  }
+
+  getTasksCount() {
+    return this.tasks.size;
+  }
+
+  getRunningContainers() {
+    return this.containerProcesses.size;
+  }
+}
+
+module.exports = ECSSimulator;

package/src/services/lambda/simulator.js

@@ -85,8 +85,15 @@ class LambdaSimulator {
     const runMiddlewares = async (index) => {
       if (index >= middlewares.length) {
         // Executa handler
+
         result = await this.executeHandler(matchedRoute.handler, event);
         handled = true;
+      
+        console.log(`✅ Resposta: ${result.statusCode}`);
+        res
+          .status(result.statusCode || 200)
+          .set(result.headers || {})
+          .send(result.body ? JSON.parse(result.body) : null);
         return;
       }
       
@@ -115,7 +122,7 @@ class LambdaSimulator {
     if (!handled && result) {
       return this.formatResponse(result);
     }
-    
+
     return null;
   }
 

package/src/template/config-template.json

@@ -6,7 +6,8 @@
     "lambda": true,
     "sns": false,
     "eventbridge": false,
-    "apigateway": true
+    "apigateway": true,
+    "ecs": false
   },
   "ports": {
     "dynamodb": 8000,
@@ -39,12 +40,8 @@
     "tables": [
       {
         "TableName": "users-table",
-        "KeySchema": [
-          { "AttributeName": "userId", "KeyType": "HASH" }
-        ],
-        "AttributeDefinitions": [
-          { "AttributeName": "userId", "AttributeType": "S" }
-        ],
+        "KeySchema": [{ "AttributeName": "userId", "KeyType": "HASH" }],
+        "AttributeDefinitions": [{ "AttributeName": "userId", "AttributeType": "S" }],
         "ProvisionedThroughput": {
           "ReadCapacityUnits": 5,
           "WriteCapacityUnits": 5
@@ -161,5 +158,46 @@
         }
       ]
     }
+  ],
+  "ecs": {
+    "clusters": ["production", "staging", "development"],
+    "defaultTaskCpu": 512,
+    "defaultTaskMemory": 1024,
+    "containerRuntime": "simulate"
+  },
+  "taskDefinitions": [
+    {
+      "family": "my-app",
+      "containerDefinitions": [
+        {
+          "name": "web",
+          "image": "nginx:alpine",
+          "cpu": 256,
+          "memory": 512,
+          "essential": true,
+          "portMappings": [
+            {
+              "containerPort": 80,
+              "hostPort": 0,
+              "protocol": "tcp"
+            }
+          ],
+          "environment": [{ "name": "ENVIRONMENT", "value": "local" }]
+        }
+      ],
+      "networkMode": "awsvpc",
+      "cpu": "512",
+      "memory": "1024"
+    }
+  ],
+  "services-ecs": [
+    {
+      "name": "my-web-service",
+      "cluster": "development",
+      "taskDefinition": "my-app",
+      "desiredCount": 2,
+      "schedulingStrategy": "REPLICA"
+    }
   ] 
-}
+
+}