docker_compose.yaml

version: '3.8'

services:
  web-0:
    image: python:3.12-slim
    container_name: web-0-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3000:3076"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3014/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-1:
    image: nginx:alpine
    container_name: api-1-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3001:3020"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3024/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-2:
    image: node:20-alpine
    container_name: db-2-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3002:3078"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3014/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-3:
    image: elasticsearch:8.11.0
    container_name: cache-3-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3003:3031"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3072/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-4:
    image: elasticsearch:8.11.0
    container_name: worker-4-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3004:3067"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3006/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-5:
    image: python:3.12-slim
    container_name: nginx-5-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3005:3073"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3011/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-6:
    image: redis:7-alpine
    container_name: rabbitmq-6-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3006:3041"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3069/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-7:
    image: postgres:16
    container_name: elasticsearch-7-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3007:3072"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3080/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-8:
    image: node:20-alpine
    container_name: web-8-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3008:3033"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3064/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-9:
    image: nginx:alpine
    container_name: api-9-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3009:3032"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3010/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-10:
    image: node:20-alpine
    container_name: db-10-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3010:3077"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3019/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-11:
    image: elasticsearch:8.11.0
    container_name: cache-11-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3011:3043"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3094/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-12:
    image: rabbitmq:3-management
    container_name: worker-12-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3012:3070"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3009/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-13:
    image: rabbitmq:3-management
    container_name: nginx-13-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3013:3086"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3099/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-14:
    image: elasticsearch:8.11.0
    container_name: rabbitmq-14-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3014:3078"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3008/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-15:
    image: rabbitmq:3-management
    container_name: elasticsearch-15-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3015:3040"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3060/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-16:
    image: rabbitmq:3-management
    container_name: web-16-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3016:3023"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3020/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-17:
    image: elasticsearch:8.11.0
    container_name: api-17-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3017:3077"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3089/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-18:
    image: redis:7-alpine
    container_name: db-18-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3018:3048"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3009/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-19:
    image: redis:7-alpine
    container_name: cache-19-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3019:3058"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3091/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-20:
    image: node:20-alpine
    container_name: worker-20-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3020:3036"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3003/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-21:
    image: nginx:alpine
    container_name: nginx-21-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3021:3089"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3028/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-22:
    image: nginx:alpine
    container_name: rabbitmq-22-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3022:3027"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3047/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-23:
    image: python:3.12-slim
    container_name: elasticsearch-23-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3023:3041"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3045/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-24:
    image: nginx:alpine
    container_name: web-24-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3024:3061"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3064/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-25:
    image: rabbitmq:3-management
    container_name: api-25-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3025:3037"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3075/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-26:
    image: rabbitmq:3-management
    container_name: db-26-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3026:3005"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3007/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-27:
    image: postgres:16
    container_name: cache-27-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3027:3095"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3034/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-28:
    image: elasticsearch:8.11.0
    container_name: worker-28-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3028:3090"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3039/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-29:
    image: node:20-alpine
    container_name: nginx-29-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3029:3011"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3068/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-30:
    image: rabbitmq:3-management
    container_name: rabbitmq-30-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3030:3017"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3046/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-31:
    image: rabbitmq:3-management
    container_name: elasticsearch-31-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3031:3065"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3092/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-32:
    image: node:20-alpine
    container_name: web-32-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3032:3047"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3068/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-33:
    image: redis:7-alpine
    container_name: api-33-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3033:3006"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3008/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-34:
    image: nginx:alpine
    container_name: db-34-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3034:3010"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3096/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-35:
    image: elasticsearch:8.11.0
    container_name: cache-35-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3035:3055"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3019/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-36:
    image: rabbitmq:3-management
    container_name: worker-36-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3036:3070"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3018/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-37:
    image: elasticsearch:8.11.0
    container_name: nginx-37-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3037:3022"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3082/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-38:
    image: postgres:16
    container_name: rabbitmq-38-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3038:3032"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3077/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-39:
    image: postgres:16
    container_name: elasticsearch-39-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3039:3000"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3083/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-40:
    image: nginx:alpine
    container_name: web-40-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3040:3063"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3047/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-41:
    image: nginx:alpine
    container_name: api-41-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3041:3039"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3078/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-42:
    image: nginx:alpine
    container_name: db-42-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3042:3035"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3024/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-43:
    image: node:20-alpine
    container_name: cache-43-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3043:3087"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3009/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-44:
    image: node:20-alpine
    container_name: worker-44-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3044:3048"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3002/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-45:
    image: rabbitmq:3-management
    container_name: nginx-45-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3045:3021"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3090/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-46:
    image: redis:7-alpine
    container_name: rabbitmq-46-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3046:3025"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3010/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-47:
    image: python:3.12-slim
    container_name: elasticsearch-47-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3047:3042"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3054/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-48:
    image: nginx:alpine
    container_name: web-48-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3048:3002"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3073/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-49:
    image: redis:7-alpine
    container_name: api-49-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3049:3056"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3094/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-50:
    image: rabbitmq:3-management
    container_name: db-50-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3050:3094"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3068/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-51:
    image: elasticsearch:8.11.0
    container_name: cache-51-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3051:3095"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3019/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-52:
    image: postgres:16
    container_name: worker-52-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3052:3074"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3070/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-53:
    image: postgres:16
    container_name: nginx-53-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3053:3034"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3040/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-54:
    image: redis:7-alpine
    container_name: rabbitmq-54-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3054:3007"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3090/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-55:
    image: rabbitmq:3-management
    container_name: elasticsearch-55-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3055:3049"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3071/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-56:
    image: redis:7-alpine
    container_name: web-56-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3056:3004"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3021/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-57:
    image: redis:7-alpine
    container_name: api-57-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3057:3025"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3051/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-58:
    image: redis:7-alpine
    container_name: db-58-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3058:3099"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3095/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-59:
    image: elasticsearch:8.11.0
    container_name: cache-59-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3059:3090"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3063/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-60:
    image: python:3.12-slim
    container_name: worker-60-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3060:3043"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3076/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-61:
    image: redis:7-alpine
    container_name: nginx-61-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3061:3008"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3004/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-62:
    image: elasticsearch:8.11.0
    container_name: rabbitmq-62-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3062:3013"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-63:
    image: elasticsearch:8.11.0
    container_name: elasticsearch-63-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3063:3004"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3038/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-64:
    image: postgres:16
    container_name: web-64-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3064:3051"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3002/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-65:
    image: postgres:16
    container_name: api-65-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3065:3064"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3012/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-66:
    image: node:20-alpine
    container_name: db-66-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3066:3023"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3027/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-67:
    image: node:20-alpine
    container_name: cache-67-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3067:3037"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3083/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-68:
    image: node:20-alpine
    container_name: worker-68-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3068:3032"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3055/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-69:
    image: rabbitmq:3-management
    container_name: nginx-69-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3069:3072"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3093/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-70:
    image: rabbitmq:3-management
    container_name: rabbitmq-70-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3070:3033"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3070/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-71:
    image: elasticsearch:8.11.0
    container_name: elasticsearch-71-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3071:3012"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3016/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-72:
    image: node:20-alpine
    container_name: web-72-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3072:3040"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3038/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-73:
    image: python:3.12-slim
    container_name: api-73-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3073:3053"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3055/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-74:
    image: postgres:16
    container_name: db-74-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3074:3044"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3027/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-75:
    image: elasticsearch:8.11.0
    container_name: cache-75-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3075:3082"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3077/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-76:
    image: redis:7-alpine
    container_name: worker-76-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3076:3095"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3041/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-77:
    image: python:3.12-slim
    container_name: nginx-77-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3077:3087"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3046/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-78:
    image: elasticsearch:8.11.0
    container_name: rabbitmq-78-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3078:3038"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3015/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-79:
    image: rabbitmq:3-management
    container_name: elasticsearch-79-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3079:3006"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3081/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-80:
    image: node:20-alpine
    container_name: web-80-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3080:3051"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3009/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-81:
    image: rabbitmq:3-management
    container_name: api-81-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3081:3030"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3022/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-82:
    image: elasticsearch:8.11.0
    container_name: db-82-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3082:3096"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3020/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-83:
    image: nginx:alpine
    container_name: cache-83-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3083:3085"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3063/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-84:
    image: redis:7-alpine
    container_name: worker-84-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3084:3075"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3043/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-85:
    image: nginx:alpine
    container_name: nginx-85-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3085:3078"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3093/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-86:
    image: redis:7-alpine
    container_name: rabbitmq-86-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3086:3054"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3011/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-87:
    image: redis:7-alpine
    container_name: elasticsearch-87-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3087:3099"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3048/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-88:
    image: python:3.12-slim
    container_name: web-88-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3088:3079"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3094/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-89:
    image: nginx:alpine
    container_name: api-89-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3089:3036"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3054/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-90:
    image: postgres:16
    container_name: db-90-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3090:3080"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3061/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-91:
    image: elasticsearch:8.11.0
    container_name: cache-91-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3091:3037"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3041/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-92:
    image: python:3.12-slim
    container_name: worker-92-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3092:3015"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3079/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-93:
    image: elasticsearch:8.11.0
    container_name: nginx-93-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3093:3036"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3059/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-94:
    image: python:3.12-slim
    container_name: rabbitmq-94-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3094:3049"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3056/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-95:
    image: node:20-alpine
    container_name: elasticsearch-95-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3095:3031"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-96:
    image: redis:7-alpine
    container_name: web-96-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3096:3074"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3070/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-97:
    image: python:3.12-slim
    container_name: api-97-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3097:3082"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3070/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-98:
    image: nginx:alpine
    container_name: db-98-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3098:3002"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3019/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-99:
    image: nginx:alpine
    container_name: cache-99-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3099:3059"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3020/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-100:
    image: python:3.12-slim
    container_name: worker-100-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3100:3078"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3012/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-101:
    image: postgres:16
    container_name: nginx-101-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3101:3037"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3063/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-102:
    image: postgres:16
    container_name: rabbitmq-102-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3102:3026"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3019/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-103:
    image: postgres:16
    container_name: elasticsearch-103-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3103:3070"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3060/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-104:
    image: postgres:16
    container_name: web-104-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3104:3043"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3089/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-105:
    image: nginx:alpine
    container_name: api-105-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3105:3053"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3010/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-106:
    image: node:20-alpine
    container_name: db-106-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3106:3052"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3087/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-107:
    image: elasticsearch:8.11.0
    container_name: cache-107-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3107:3056"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3057/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-108:
    image: redis:7-alpine
    container_name: worker-108-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3108:3079"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3047/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-109:
    image: elasticsearch:8.11.0
    container_name: nginx-109-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3109:3058"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3078/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-110:
    image: postgres:16
    container_name: rabbitmq-110-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3110:3048"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3059/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-111:
    image: rabbitmq:3-management
    container_name: elasticsearch-111-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3111:3046"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3097/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-112:
    image: nginx:alpine
    container_name: web-112-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3112:3033"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3097/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-113:
    image: redis:7-alpine
    container_name: api-113-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3113:3068"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3018/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-114:
    image: redis:7-alpine
    container_name: db-114-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3114:3070"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3094/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-115:
    image: python:3.12-slim
    container_name: cache-115-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3115:3085"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3024/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-116:
    image: python:3.12-slim
    container_name: worker-116-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3116:3091"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3024/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-117:
    image: postgres:16
    container_name: nginx-117-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3117:3020"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3047/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-118:
    image: rabbitmq:3-management
    container_name: rabbitmq-118-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3118:3058"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3067/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-119:
    image: python:3.12-slim
    container_name: elasticsearch-119-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3119:3060"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3099/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-120:
    image: node:20-alpine
    container_name: web-120-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3120:3060"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3009/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-121:
    image: redis:7-alpine
    container_name: api-121-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3121:3090"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3007/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-122:
    image: elasticsearch:8.11.0
    container_name: db-122-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3122:3079"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3056/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-123:
    image: elasticsearch:8.11.0
    container_name: cache-123-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3123:3036"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3038/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-124:
    image: rabbitmq:3-management
    container_name: worker-124-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3124:3012"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3015/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-125:
    image: nginx:alpine
    container_name: nginx-125-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3125:3064"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3039/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-126:
    image: elasticsearch:8.11.0
    container_name: rabbitmq-126-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3126:3063"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3086/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-127:
    image: nginx:alpine
    container_name: elasticsearch-127-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3127:3024"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3021/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-128:
    image: elasticsearch:8.11.0
    container_name: web-128-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3128:3009"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3074/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-129:
    image: elasticsearch:8.11.0
    container_name: api-129-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3129:3079"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3057/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-130:
    image: rabbitmq:3-management
    container_name: db-130-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3130:3017"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3014/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-131:
    image: elasticsearch:8.11.0
    container_name: cache-131-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3131:3022"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3001/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-132:
    image: rabbitmq:3-management
    container_name: worker-132-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3132:3076"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3099/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-133:
    image: elasticsearch:8.11.0
    container_name: nginx-133-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3133:3054"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3057/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-134:
    image: postgres:16
    container_name: rabbitmq-134-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3134:3088"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3053/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-135:
    image: postgres:16
    container_name: elasticsearch-135-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3135:3030"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3033/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-136:
    image: elasticsearch:8.11.0
    container_name: web-136-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3136:3016"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3047/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-137:
    image: rabbitmq:3-management
    container_name: api-137-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3137:3088"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3055/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-138:
    image: nginx:alpine
    container_name: db-138-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3138:3024"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3003/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-139:
    image: rabbitmq:3-management
    container_name: cache-139-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3139:3003"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3065/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-140:
    image: redis:7-alpine
    container_name: worker-140-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3140:3066"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3034/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-141:
    image: postgres:16
    container_name: nginx-141-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3141:3045"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3031/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-142:
    image: nginx:alpine
    container_name: rabbitmq-142-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3142:3001"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3078/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-143:
    image: nginx:alpine
    container_name: elasticsearch-143-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3143:3058"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3025/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-144:
    image: elasticsearch:8.11.0
    container_name: web-144-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3144:3029"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3021/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-145:
    image: postgres:16
    container_name: api-145-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3145:3067"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3097/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-146:
    image: postgres:16
    container_name: db-146-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3146:3029"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3066/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-147:
    image: node:20-alpine
    container_name: cache-147-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3147:3096"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3079/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-148:
    image: nginx:alpine
    container_name: worker-148-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3148:3035"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3035/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-149:
    image: redis:7-alpine
    container_name: nginx-149-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3149:3047"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3073/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-150:
    image: elasticsearch:8.11.0
    container_name: rabbitmq-150-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3150:3071"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3081/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-151:
    image: elasticsearch:8.11.0
    container_name: elasticsearch-151-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3151:3098"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3091/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-152:
    image: rabbitmq:3-management
    container_name: web-152-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3152:3048"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3037/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-153:
    image: rabbitmq:3-management
    container_name: api-153-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3153:3017"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3034/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-154:
    image: elasticsearch:8.11.0
    container_name: db-154-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3154:3078"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3094/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-155:
    image: postgres:16
    container_name: cache-155-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3155:3006"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3085/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-156:
    image: python:3.12-slim
    container_name: worker-156-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3156:3076"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3049/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-157:
    image: postgres:16
    container_name: nginx-157-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3157:3040"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3055/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-158:
    image: postgres:16
    container_name: rabbitmq-158-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3158:3033"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3049/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-159:
    image: elasticsearch:8.11.0
    container_name: elasticsearch-159-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3159:3057"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3079/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-160:
    image: node:20-alpine
    container_name: web-160-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3160:3027"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3080/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-161:
    image: elasticsearch:8.11.0
    container_name: api-161-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3161:3032"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3096/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-162:
    image: node:20-alpine
    container_name: db-162-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3162:3010"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3079/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-163:
    image: postgres:16
    container_name: cache-163-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3163:3097"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3004/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-164:
    image: postgres:16
    container_name: worker-164-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3164:3091"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3021/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-165:
    image: postgres:16
    container_name: nginx-165-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3165:3060"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3053/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-166:
    image: node:20-alpine
    container_name: rabbitmq-166-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3166:3005"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3011/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-167:
    image: node:20-alpine
    container_name: elasticsearch-167-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3167:3080"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3081/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-168:
    image: postgres:16
    container_name: web-168-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3168:3007"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3064/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-169:
    image: elasticsearch:8.11.0
    container_name: api-169-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3169:3021"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3041/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-170:
    image: redis:7-alpine
    container_name: db-170-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3170:3066"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3031/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-171:
    image: redis:7-alpine
    container_name: cache-171-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3171:3053"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3008/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-172:
    image: postgres:16
    container_name: worker-172-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3172:3009"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3077/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-173:
    image: node:20-alpine
    container_name: nginx-173-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3173:3033"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3087/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-174:
    image: python:3.12-slim
    container_name: rabbitmq-174-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3174:3065"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3018/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-175:
    image: nginx:alpine
    container_name: elasticsearch-175-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3175:3040"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3003/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-176:
    image: nginx:alpine
    container_name: web-176-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3176:3019"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3023/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-177:
    image: redis:7-alpine
    container_name: api-177-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3177:3082"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3029/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-178:
    image: python:3.12-slim
    container_name: db-178-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3178:3075"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3039/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-179:
    image: rabbitmq:3-management
    container_name: cache-179-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3179:3075"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3083/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-180:
    image: redis:7-alpine
    container_name: worker-180-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3180:3083"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-181:
    image: node:20-alpine
    container_name: nginx-181-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3181:3058"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3090/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-182:
    image: elasticsearch:8.11.0
    container_name: rabbitmq-182-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3182:3078"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3032/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-183:
    image: rabbitmq:3-management
    container_name: elasticsearch-183-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3183:3001"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3070/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-184:
    image: elasticsearch:8.11.0
    container_name: web-184-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3184:3024"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3059/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-185:
    image: node:20-alpine
    container_name: api-185-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3185:3045"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3004/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-186:
    image: elasticsearch:8.11.0
    container_name: db-186-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3186:3046"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3066/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-187:
    image: redis:7-alpine
    container_name: cache-187-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3187:3095"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3084/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-188:
    image: rabbitmq:3-management
    container_name: worker-188-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3188:3017"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3089/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-189:
    image: python:3.12-slim
    container_name: nginx-189-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3189:3032"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3046/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-190:
    image: postgres:16
    container_name: rabbitmq-190-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3190:3048"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3021/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-191:
    image: node:20-alpine
    container_name: elasticsearch-191-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3191:3028"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3091/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-192:
    image: rabbitmq:3-management
    container_name: web-192-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3192:3008"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3044/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-193:
    image: elasticsearch:8.11.0
    container_name: api-193-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3193:3033"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3028/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-194:
    image: python:3.12-slim
    container_name: db-194-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3194:3031"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3086/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-195:
    image: postgres:16
    container_name: cache-195-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3195:3039"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3003/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-196:
    image: nginx:alpine
    container_name: worker-196-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3196:3062"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3067/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-197:
    image: python:3.12-slim
    container_name: nginx-197-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3197:3085"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3071/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-198:
    image: redis:7-alpine
    container_name: rabbitmq-198-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3198:3012"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3094/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-199:
    image: node:20-alpine
    container_name: elasticsearch-199-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3199:3084"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3082/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-200:
    image: python:3.12-slim
    container_name: web-200-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3200:3016"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3024/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-201:
    image: postgres:16
    container_name: api-201-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3201:3091"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3052/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-202:
    image: postgres:16
    container_name: db-202-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3202:3002"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3026/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-203:
    image: rabbitmq:3-management
    container_name: cache-203-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3203:3039"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3080/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-204:
    image: node:20-alpine
    container_name: worker-204-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3204:3091"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3084/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-205:
    image: redis:7-alpine
    container_name: nginx-205-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3205:3069"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3006/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-206:
    image: python:3.12-slim
    container_name: rabbitmq-206-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3206:3078"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3081/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-207:
    image: nginx:alpine
    container_name: elasticsearch-207-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3207:3068"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3008/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-208:
    image: rabbitmq:3-management
    container_name: web-208-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3208:3080"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3099/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-209:
    image: nginx:alpine
    container_name: api-209-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3209:3071"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3012/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-210:
    image: node:20-alpine
    container_name: db-210-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3210:3020"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3058/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-211:
    image: postgres:16
    container_name: cache-211-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3211:3017"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3017/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-212:
    image: node:20-alpine
    container_name: worker-212-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3212:3006"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3093/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-213:
    image: elasticsearch:8.11.0
    container_name: nginx-213-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3213:3038"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3096/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-214:
    image: postgres:16
    container_name: rabbitmq-214-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3214:3093"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3030/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-215:
    image: node:20-alpine
    container_name: elasticsearch-215-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3215:3041"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3073/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-216:
    image: nginx:alpine
    container_name: web-216-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3216:3088"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3061/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-217:
    image: python:3.12-slim
    container_name: api-217-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3217:3000"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3039/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-218:
    image: postgres:16
    container_name: db-218-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3218:3065"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3058/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-219:
    image: nginx:alpine
    container_name: cache-219-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3219:3040"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3032/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-220:
    image: nginx:alpine
    container_name: worker-220-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3220:3022"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3051/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-221:
    image: redis:7-alpine
    container_name: nginx-221-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3221:3072"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3069/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-222:
    image: elasticsearch:8.11.0
    container_name: rabbitmq-222-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3222:3062"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3058/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-223:
    image: redis:7-alpine
    container_name: elasticsearch-223-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3223:3059"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3007/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-224:
    image: node:20-alpine
    container_name: web-224-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3224:3062"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3054/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-225:
    image: elasticsearch:8.11.0
    container_name: api-225-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3225:3089"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3078/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-226:
    image: elasticsearch:8.11.0
    container_name: db-226-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3226:3057"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3026/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-227:
    image: redis:7-alpine
    container_name: cache-227-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3227:3006"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3052/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-228:
    image: elasticsearch:8.11.0
    container_name: worker-228-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3228:3039"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3081/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-229:
    image: redis:7-alpine
    container_name: nginx-229-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3229:3067"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3007/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-230:
    image: postgres:16
    container_name: rabbitmq-230-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3230:3000"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3010/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-231:
    image: rabbitmq:3-management
    container_name: elasticsearch-231-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3231:3072"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3023/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-232:
    image: python:3.12-slim
    container_name: web-232-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3232:3094"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3051/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-233:
    image: node:20-alpine
    container_name: api-233-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3233:3055"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3084/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-234:
    image: python:3.12-slim
    container_name: db-234-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3234:3085"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3017/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-235:
    image: rabbitmq:3-management
    container_name: cache-235-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3235:3055"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3068/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-236:
    image: rabbitmq:3-management
    container_name: worker-236-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3236:3048"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3043/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-237:
    image: rabbitmq:3-management
    container_name: nginx-237-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3237:3006"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3063/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-238:
    image: postgres:16
    container_name: rabbitmq-238-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3238:3018"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3018/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-239:
    image: postgres:16
    container_name: elasticsearch-239-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3239:3045"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3038/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-240:
    image: python:3.12-slim
    container_name: web-240-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3240:3069"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3070/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-241:
    image: nginx:alpine
    container_name: api-241-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3241:3028"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3025/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-242:
    image: redis:7-alpine
    container_name: db-242-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3242:3075"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3046/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-243:
    image: redis:7-alpine
    container_name: cache-243-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3243:3091"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3065/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-244:
    image: elasticsearch:8.11.0
    container_name: worker-244-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3244:3031"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3013/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-245:
    image: node:20-alpine
    container_name: nginx-245-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3245:3043"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3012/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-246:
    image: node:20-alpine
    container_name: rabbitmq-246-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3246:3035"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3047/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-247:
    image: python:3.12-slim
    container_name: elasticsearch-247-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3247:3081"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3039/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-248:
    image: rabbitmq:3-management
    container_name: web-248-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3248:3039"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3072/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-249:
    image: rabbitmq:3-management
    container_name: api-249-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3249:3011"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3018/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-250:
    image: postgres:16
    container_name: db-250-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3250:3068"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3012/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-251:
    image: rabbitmq:3-management
    container_name: cache-251-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3251:3095"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3060/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-252:
    image: postgres:16
    container_name: worker-252-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3252:3060"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3040/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-253:
    image: nginx:alpine
    container_name: nginx-253-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3253:3056"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3013/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-254:
    image: rabbitmq:3-management
    container_name: rabbitmq-254-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3254:3067"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3036/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-255:
    image: node:20-alpine
    container_name: elasticsearch-255-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3255:3061"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3037/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-256:
    image: nginx:alpine
    container_name: web-256-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3256:3081"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3098/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-257:
    image: rabbitmq:3-management
    container_name: api-257-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3257:3002"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3087/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-258:
    image: redis:7-alpine
    container_name: db-258-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3258:3032"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3077/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-259:
    image: redis:7-alpine
    container_name: cache-259-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3259:3032"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3046/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-260:
    image: redis:7-alpine
    container_name: worker-260-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3260:3090"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3024/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-261:
    image: redis:7-alpine
    container_name: nginx-261-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3261:3042"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3088/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-262:
    image: rabbitmq:3-management
    container_name: rabbitmq-262-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3262:3093"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3012/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-263:
    image: postgres:16
    container_name: elasticsearch-263-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3263:3032"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3060/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-264:
    image: redis:7-alpine
    container_name: web-264-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3264:3009"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3015/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-265:
    image: redis:7-alpine
    container_name: api-265-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3265:3018"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3016/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-266:
    image: python:3.12-slim
    container_name: db-266-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3266:3012"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3002/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-267:
    image: redis:7-alpine
    container_name: cache-267-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3267:3092"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3085/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-268:
    image: postgres:16
    container_name: worker-268-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3268:3016"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3076/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-269:
    image: rabbitmq:3-management
    container_name: nginx-269-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3269:3069"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3024/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-270:
    image: rabbitmq:3-management
    container_name: rabbitmq-270-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3270:3036"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3071/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-271:
    image: rabbitmq:3-management
    container_name: elasticsearch-271-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3271:3064"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3003/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-272:
    image: elasticsearch:8.11.0
    container_name: web-272-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3272:3079"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3050/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-273:
    image: redis:7-alpine
    container_name: api-273-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3273:3021"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3093/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-274:
    image: redis:7-alpine
    container_name: db-274-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3274:3029"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3046/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-275:
    image: nginx:alpine
    container_name: cache-275-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3275:3059"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3016/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-276:
    image: nginx:alpine
    container_name: worker-276-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3276:3044"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3029/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-277:
    image: python:3.12-slim
    container_name: nginx-277-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3277:3020"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3096/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-278:
    image: node:20-alpine
    container_name: rabbitmq-278-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3278:3054"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3014/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-279:
    image: python:3.12-slim
    container_name: elasticsearch-279-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3279:3036"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3009/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-280:
    image: python:3.12-slim
    container_name: web-280-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3280:3098"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3062/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-281:
    image: elasticsearch:8.11.0
    container_name: api-281-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3281:3059"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3029/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-282:
    image: postgres:16
    container_name: db-282-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3282:3053"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3045/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-283:
    image: python:3.12-slim
    container_name: cache-283-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3283:3006"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3094/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-284:
    image: nginx:alpine
    container_name: worker-284-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3284:3043"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3092/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-285:
    image: redis:7-alpine
    container_name: nginx-285-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3285:3055"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3066/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-286:
    image: postgres:16
    container_name: rabbitmq-286-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3286:3038"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3033/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-287:
    image: python:3.12-slim
    container_name: elasticsearch-287-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3287:3004"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3052/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-288:
    image: node:20-alpine
    container_name: web-288-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3288:3043"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3088/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-289:
    image: nginx:alpine
    container_name: api-289-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3289:3027"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3063/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-290:
    image: elasticsearch:8.11.0
    container_name: db-290-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3290:3041"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3001/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-291:
    image: redis:7-alpine
    container_name: cache-291-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3291:3020"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3017/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-292:
    image: nginx:alpine
    container_name: worker-292-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3292:3083"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3026/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-293:
    image: postgres:16
    container_name: nginx-293-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3293:3000"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3058/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-294:
    image: nginx:alpine
    container_name: rabbitmq-294-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3294:3018"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3014/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-295:
    image: elasticsearch:8.11.0
    container_name: elasticsearch-295-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3295:3071"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3043/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-296:
    image: postgres:16
    container_name: web-296-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3296:3087"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3048/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-297:
    image: postgres:16
    container_name: api-297-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3297:3030"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3010/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-298:
    image: node:20-alpine
    container_name: db-298-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3298:3009"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3060/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-299:
    image: python:3.12-slim
    container_name: cache-299-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3299:3062"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3024/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-300:
    image: rabbitmq:3-management
    container_name: worker-300-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3300:3011"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3061/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-301:
    image: nginx:alpine
    container_name: nginx-301-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3301:3084"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3009/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-302:
    image: rabbitmq:3-management
    container_name: rabbitmq-302-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3302:3036"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3087/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-303:
    image: elasticsearch:8.11.0
    container_name: elasticsearch-303-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3303:3037"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3060/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-304:
    image: redis:7-alpine
    container_name: web-304-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3304:3012"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3082/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-305:
    image: elasticsearch:8.11.0
    container_name: api-305-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3305:3028"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3026/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-306:
    image: rabbitmq:3-management
    container_name: db-306-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3306:3066"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3035/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-307:
    image: redis:7-alpine
    container_name: cache-307-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3307:3062"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3095/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-308:
    image: rabbitmq:3-management
    container_name: worker-308-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3308:3041"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3035/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-309:
    image: node:20-alpine
    container_name: nginx-309-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3309:3096"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3026/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-310:
    image: elasticsearch:8.11.0
    container_name: rabbitmq-310-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3310:3094"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3078/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-311:
    image: nginx:alpine
    container_name: elasticsearch-311-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3311:3089"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3081/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-312:
    image: node:20-alpine
    container_name: web-312-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3312:3022"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3037/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-313:
    image: nginx:alpine
    container_name: api-313-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3313:3044"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3037/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-314:
    image: node:20-alpine
    container_name: db-314-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3314:3039"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3050/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-315:
    image: redis:7-alpine
    container_name: cache-315-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3315:3078"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3078/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-316:
    image: node:20-alpine
    container_name: worker-316-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3316:3030"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3023/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-317:
    image: python:3.12-slim
    container_name: nginx-317-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3317:3097"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3057/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-318:
    image: python:3.12-slim
    container_name: rabbitmq-318-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3318:3094"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3063/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-319:
    image: node:20-alpine
    container_name: elasticsearch-319-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3319:3040"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3023/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-320:
    image: redis:7-alpine
    container_name: web-320-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3320:3080"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3004/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-321:
    image: postgres:16
    container_name: api-321-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3321:3025"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3065/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-322:
    image: postgres:16
    container_name: db-322-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3322:3052"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3060/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-323:
    image: node:20-alpine
    container_name: cache-323-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3323:3043"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3053/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-324:
    image: nginx:alpine
    container_name: worker-324-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3324:3040"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3057/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-325:
    image: nginx:alpine
    container_name: nginx-325-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3325:3022"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3037/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-326:
    image: node:20-alpine
    container_name: rabbitmq-326-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3326:3051"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3003/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-327:
    image: redis:7-alpine
    container_name: elasticsearch-327-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3327:3034"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3041/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-328:
    image: rabbitmq:3-management
    container_name: web-328-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3328:3065"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3047/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-329:
    image: nginx:alpine
    container_name: api-329-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3329:3045"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3026/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-330:
    image: python:3.12-slim
    container_name: db-330-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3330:3032"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3009/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-331:
    image: redis:7-alpine
    container_name: cache-331-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3331:3012"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3060/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-332:
    image: nginx:alpine
    container_name: worker-332-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3332:3097"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3089/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-333:
    image: nginx:alpine
    container_name: nginx-333-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3333:3019"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3037/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-334:
    image: elasticsearch:8.11.0
    container_name: rabbitmq-334-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3334:3029"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3057/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-335:
    image: nginx:alpine
    container_name: elasticsearch-335-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3335:3066"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3040/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-336:
    image: node:20-alpine
    container_name: web-336-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3336:3082"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3078/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-337:
    image: elasticsearch:8.11.0
    container_name: api-337-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3337:3003"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3027/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-338:
    image: node:20-alpine
    container_name: db-338-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3338:3069"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3055/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-339:
    image: node:20-alpine
    container_name: cache-339-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3339:3003"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3042/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-340:
    image: rabbitmq:3-management
    container_name: worker-340-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3340:3008"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3081/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-341:
    image: rabbitmq:3-management
    container_name: nginx-341-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3341:3054"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3081/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-342:
    image: redis:7-alpine
    container_name: rabbitmq-342-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3342:3014"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3058/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-343:
    image: rabbitmq:3-management
    container_name: elasticsearch-343-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3343:3042"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3052/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-344:
    image: elasticsearch:8.11.0
    container_name: web-344-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3344:3057"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3073/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-345:
    image: node:20-alpine
    container_name: api-345-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3345:3002"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3031/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-346:
    image: postgres:16
    container_name: db-346-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3346:3072"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3079/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-347:
    image: elasticsearch:8.11.0
    container_name: cache-347-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3347:3013"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3053/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-348:
    image: redis:7-alpine
    container_name: worker-348-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3348:3040"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3065/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-349:
    image: rabbitmq:3-management
    container_name: nginx-349-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3349:3095"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3024/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-350:
    image: redis:7-alpine
    container_name: rabbitmq-350-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3350:3084"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3037/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-351:
    image: nginx:alpine
    container_name: elasticsearch-351-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3351:3033"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3052/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-352:
    image: rabbitmq:3-management
    container_name: web-352-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3352:3027"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3029/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-353:
    image: rabbitmq:3-management
    container_name: api-353-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3353:3057"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3075/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-354:
    image: node:20-alpine
    container_name: db-354-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3354:3008"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3008/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-355:
    image: node:20-alpine
    container_name: cache-355-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3355:3006"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3058/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-356:
    image: node:20-alpine
    container_name: worker-356-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3356:3054"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3002/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-357:
    image: redis:7-alpine
    container_name: nginx-357-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3357:3064"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3096/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-358:
    image: rabbitmq:3-management
    container_name: rabbitmq-358-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3358:3019"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3021/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-359:
    image: elasticsearch:8.11.0
    container_name: elasticsearch-359-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3359:3095"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3074/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-360:
    image: elasticsearch:8.11.0
    container_name: web-360-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3360:3091"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3070/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-361:
    image: python:3.12-slim
    container_name: api-361-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3361:3035"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3099/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-362:
    image: nginx:alpine
    container_name: db-362-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3362:3071"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3064/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-363:
    image: node:20-alpine
    container_name: cache-363-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3363:3080"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3020/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-364:
    image: node:20-alpine
    container_name: worker-364-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3364:3025"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3058/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-365:
    image: elasticsearch:8.11.0
    container_name: nginx-365-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3365:3080"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3038/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-366:
    image: node:20-alpine
    container_name: rabbitmq-366-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3366:3089"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3057/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-367:
    image: postgres:16
    container_name: elasticsearch-367-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3367:3028"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3029/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-368:
    image: node:20-alpine
    container_name: web-368-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3368:3079"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3055/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-369:
    image: python:3.12-slim
    container_name: api-369-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3369:3081"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3071/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-370:
    image: python:3.12-slim
    container_name: db-370-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3370:3001"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3084/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-371:
    image: rabbitmq:3-management
    container_name: cache-371-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3371:3030"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3040/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-372:
    image: node:20-alpine
    container_name: worker-372-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3372:3060"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3062/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-373:
    image: postgres:16
    container_name: nginx-373-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3373:3073"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-374:
    image: node:20-alpine
    container_name: rabbitmq-374-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3374:3078"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3038/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-375:
    image: postgres:16
    container_name: elasticsearch-375-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3375:3029"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3098/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-376:
    image: rabbitmq:3-management
    container_name: web-376-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3376:3047"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3041/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-377:
    image: nginx:alpine
    container_name: api-377-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3377:3006"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3010/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-378:
    image: redis:7-alpine
    container_name: db-378-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3378:3039"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3065/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-379:
    image: python:3.12-slim
    container_name: cache-379-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3379:3003"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3080/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-380:
    image: postgres:16
    container_name: worker-380-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3380:3064"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3080/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-381:
    image: nginx:alpine
    container_name: nginx-381-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3381:3014"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3016/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-382:
    image: redis:7-alpine
    container_name: rabbitmq-382-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3382:3057"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3057/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-383:
    image: elasticsearch:8.11.0
    container_name: elasticsearch-383-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3383:3038"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3097/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-384:
    image: nginx:alpine
    container_name: web-384-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3384:3053"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3068/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-385:
    image: nginx:alpine
    container_name: api-385-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3385:3099"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3004/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-386:
    image: nginx:alpine
    container_name: db-386-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3386:3027"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3014/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-387:
    image: python:3.12-slim
    container_name: cache-387-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3387:3036"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-388:
    image: python:3.12-slim
    container_name: worker-388-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3388:3047"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3052/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-389:
    image: redis:7-alpine
    container_name: nginx-389-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3389:3026"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3026/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-390:
    image: postgres:16
    container_name: rabbitmq-390-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3390:3015"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3021/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-391:
    image: nginx:alpine
    container_name: elasticsearch-391-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3391:3064"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3039/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-392:
    image: python:3.12-slim
    container_name: web-392-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3392:3049"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3071/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-393:
    image: node:20-alpine
    container_name: api-393-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3393:3019"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3078/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-394:
    image: python:3.12-slim
    container_name: db-394-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3394:3057"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3074/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-395:
    image: redis:7-alpine
    container_name: cache-395-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3395:3064"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3095/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-396:
    image: nginx:alpine
    container_name: worker-396-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3396:3060"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3036/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-397:
    image: redis:7-alpine
    container_name: nginx-397-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3397:3075"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3066/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-398:
    image: redis:7-alpine
    container_name: rabbitmq-398-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3398:3015"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3039/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-399:
    image: postgres:16
    container_name: elasticsearch-399-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3399:3095"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3016/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-400:
    image: node:20-alpine
    container_name: web-400-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3400:3085"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3016/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-401:
    image: python:3.12-slim
    container_name: api-401-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3401:3005"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3052/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-402:
    image: node:20-alpine
    container_name: db-402-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3402:3032"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3093/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-403:
    image: elasticsearch:8.11.0
    container_name: cache-403-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3403:3085"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3034/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-404:
    image: redis:7-alpine
    container_name: worker-404-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3404:3009"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3076/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-405:
    image: postgres:16
    container_name: nginx-405-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3405:3053"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3083/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-406:
    image: python:3.12-slim
    container_name: rabbitmq-406-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3406:3084"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3052/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-407:
    image: postgres:16
    container_name: elasticsearch-407-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3407:3002"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3054/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-408:
    image: nginx:alpine
    container_name: web-408-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3408:3072"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3082/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-409:
    image: elasticsearch:8.11.0
    container_name: api-409-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3409:3092"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3037/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-410:
    image: nginx:alpine
    container_name: db-410-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3410:3088"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3049/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-411:
    image: rabbitmq:3-management
    container_name: cache-411-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3411:3034"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3035/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-412:
    image: nginx:alpine
    container_name: worker-412-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3412:3070"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3005/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-413:
    image: redis:7-alpine
    container_name: nginx-413-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3413:3057"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3098/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-414:
    image: rabbitmq:3-management
    container_name: rabbitmq-414-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3414:3064"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3047/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-415:
    image: node:20-alpine
    container_name: elasticsearch-415-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3415:3007"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3014/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-416:
    image: nginx:alpine
    container_name: web-416-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3416:3043"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3060/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-417:
    image: node:20-alpine
    container_name: api-417-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3417:3009"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3076/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-418:
    image: python:3.12-slim
    container_name: db-418-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3418:3036"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3048/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-419:
    image: node:20-alpine
    container_name: cache-419-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3419:3053"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3061/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-420:
    image: python:3.12-slim
    container_name: worker-420-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3420:3016"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3028/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-421:
    image: python:3.12-slim
    container_name: nginx-421-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3421:3087"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3096/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-422:
    image: redis:7-alpine
    container_name: rabbitmq-422-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3422:3045"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3089/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-423:
    image: redis:7-alpine
    container_name: elasticsearch-423-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3423:3032"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3091/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-424:
    image: nginx:alpine
    container_name: web-424-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3424:3068"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3091/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-425:
    image: nginx:alpine
    container_name: api-425-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3425:3002"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3002/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-426:
    image: node:20-alpine
    container_name: db-426-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3426:3010"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3057/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-427:
    image: python:3.12-slim
    container_name: cache-427-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3427:3032"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3040/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-428:
    image: python:3.12-slim
    container_name: worker-428-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3428:3093"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3011/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-429:
    image: redis:7-alpine
    container_name: nginx-429-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3429:3065"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3056/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-430:
    image: node:20-alpine
    container_name: rabbitmq-430-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3430:3018"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3045/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-431:
    image: redis:7-alpine
    container_name: elasticsearch-431-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3431:3095"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3008/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-432:
    image: nginx:alpine
    container_name: web-432-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3432:3001"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3010/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-433:
    image: node:20-alpine
    container_name: api-433-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3433:3060"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3019/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-434:
    image: node:20-alpine
    container_name: db-434-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3434:3050"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3074/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-435:
    image: nginx:alpine
    container_name: cache-435-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3435:3097"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3058/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-436:
    image: redis:7-alpine
    container_name: worker-436-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3436:3099"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3080/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-437:
    image: nginx:alpine
    container_name: nginx-437-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3437:3099"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3095/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-438:
    image: rabbitmq:3-management
    container_name: rabbitmq-438-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3438:3096"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3071/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-439:
    image: rabbitmq:3-management
    container_name: elasticsearch-439-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3439:3090"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3074/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-440:
    image: elasticsearch:8.11.0
    container_name: web-440-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3440:3070"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3038/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api-441:
    image: node:20-alpine
    container_name: api-441-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3441:3065"
    volumes:
      - ./data/api:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3004/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db-442:
    image: redis:7-alpine
    container_name: db-442-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3442:3058"
    volumes:
      - ./data/db:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3046/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  cache-443:
    image: rabbitmq:3-management
    container_name: cache-443-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3443:3046"
    volumes:
      - ./data/cache:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3079/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  worker-444:
    image: postgres:16
    container_name: worker-444-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3444:3007"
    volumes:
      - ./data/worker:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3083/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx-445:
    image: elasticsearch:8.11.0
    container_name: nginx-445-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3445:3043"
    volumes:
      - ./data/nginx:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3089/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  rabbitmq-446:
    image: nginx:alpine
    container_name: rabbitmq-446-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3446:3043"
    volumes:
      - ./data/rabbitmq:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3083/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  elasticsearch-447:
    image: postgres:16
    container_name: elasticsearch-447-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=info
    ports:
      - "3447:3052"
    volumes:
      - ./data/elasticsearch:/app/data
      - ./logs:/app/logs
    depends_on:
      - db-0
      - cache-0
    networks:
      - backend
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3077/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  web-448:
    image: elasticsearch:8.11.0
    container_name: web-448-container
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
      - REDIS_URL=redis://cache:6379
      - LOG_LEVEL=debug
    ports:
      - "3448:3039"
    volumes:
      - ./data/web:/app/data
      - ./logs:/app/logs
    depends_on