docker-compose.yaml - main - iezhelev/cppsh_micro

docker-compose.yaml
434 строки10 KB
iezhelev
more config
04 авг 2025, 15:15
04 авг 2025, 15:15fcc2ae0
services:

  # Consul для Service Discovery
  # consul:
  #   image: consul:1.10
  #   ports:
  #     - "8500:8500"
  #   healthcheck:
  #     test: ["CMD", "curl", "-f", "http://consul:8500/v1/status/leader"]
  #     interval: 5s
  #     timeout: 3s
  #     retries: 10
  #   command: consul agent -dev -client=0.0.0.0
  #   networks:
  #     - cppsh-network

  # registrator:
  #   image: hypolas/registrator:latest
  #   volumes:
  #     - /var/run/docker.sock:/tmp/docker.sock:ro
  #   command: -internal -cleanup -resync 10 -networks-priority "10.10.0.0/16" consul://consul:8500
  #   depends_on:
  #     consul:
  #       condition: service_healthy
  #   networks:
  #     - cppsh-network

  # PostgreSQL для Command Service
  postgres:
    image: postgres:13-alpine
    env_file:
      - common.env 
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: cppsh_micro
      TZ: Europe/Moscow  # Use the host system's timezone or default to UTC
    ports:
      - "5433:5432"
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 4G
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres -d cppsh_micro"]
      interval: 5s
      timeout: 3s
      retries: 20
      start_period: 15s 
    networks:
      - cppsh-network
  

  # kafka:
  #   profiles: ["optional"]
  #   image: bitnami/kafka:latest
  #   environment:
  #     # KRaft mode settings
  #     KAFKA_CFG_PROCESS_ROLES: "controller,broker"  # Must be both for single-node
  #     KAFKA_CFG_NODE_ID: 1
  #     KAFKA_CFG_CONTROLLER_QUORUM_VOTERS: "1@kafka:9093"  # Format: nodeId@host:port
  #     KAFKA_CFG_CONTROLLER_LISTENER_NAMES: "CONTROLLER"
  #     KAFKA_CFG_LISTENERS: "PLAINTEXT://:9092,CONTROLLER://:9093"
  #     KAFKA_CFG_LISTENER_SECURITY_PROTOCOL_MAP: "CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT"
  #     KAFKA_CFG_ADVERTISED_LISTENERS: "PLAINTEXT://kafka:9092"
  #     KAFKA_CFG_INTER_BROKER_LISTENER_NAME: "PLAINTEXT"
  #     KAFKA_CFG_AUTO_CREATE_TOPICS_ENABLE: "true"
  #     # Auto-generate cluster ID if not set (optional)
  #     KAFKA_KRAFT_CLUSTER_ID: "Yr44nHbDR_mjENuH5jRwCQ"  
  #     KAFKA_CONNECT_OFFSETS_TOPIC_CLEANUP_POLICY: compact
  #     KAFKA_CONNECT_CONFIGS_TOPIC_CLEANUP_POLICY: compact
  #     KAFKA_CONNECT_STATUSES_TOPIC_CLEANUP_POLICY: compact
  #   healthcheck:
  #     test: kafka-topics.sh --list --bootstrap-server localhost:9092 || exit 1 
  #     interval: 10s
  #     timeout: 30s
  #     retries: 10
  #     start_period: 60s
  #   ports:
  #     - "9092:9092"
  #   networks:
  #     - cppsh-network

  # kafka-connect:
  #   profiles: ["optional"]
  #   image: quay.io/debezium/connect
  #   depends_on:
  #     kafka:
  #       condition: service_healthy
  #   environment:
  #     BOOTSTRAP_SERVERS: kafka:9092
  #     GROUP_ID: 1
  #     CONFIG_STORAGE_TOPIC: connect_configs
  #     OFFSET_STORAGE_TOPIC: connect_offsets
  #     STATUS_STORAGE_TOPIC: connect_statuses
  #   ports:
  #     - "8075:8075"
  #   networks:
  #     - cppsh-network

  # debezium-configurator:
  #   profiles: ["optional"]
  #   build:
  #     context: .
  #     dockerfile: Dockerfile.debezium-config
  #   env_file:
  #     - common.env 
  #   depends_on:
  #     - kafka-connect
  #   networks:
  #     - cppsh-network

  cdc-consumer:
    profiles: ["optional"]
    build:
      context: .
      dockerfile: Dockerfile.cdc-consumer
    env_file:
      - common.env
    ports:
      - "8074:8074"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://cdc-consumer:8074/health"]
      interval: 5s
      timeout: 7s
      retries: 10
    depends_on:
      - kafka-connect
    networks:
      - cppsh-network


  migration-service:
    build:
      context: .
      dockerfile: Dockerfile.migration
    env_file:
      - common.env
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - cppsh-network

  # RabbitMQ для событий
  rabbitmq:
    build:
      context: .
      dockerfile: Dockerfile.rabbitmq
    ports:
      - "5672:5672"
      - "15672:15672"
    deploy:
      resources:
        limits:
          cpus: '2'     # Max 2 CPU cores
          memory: 2G    # Max 2GB RAM
        reservations:
          memory: 1G   # Guaranteed 1GB RAM
    healthcheck:
      test: ["CMD", "nc", "-z", "localhost", "5672"]
      interval: 5s
      timeout: 3s
      retries: 10
    networks:
      - cppsh-network

  # Redis для кэширования и других задач (Alpine-based)
  redis:
    image: redis:alpine
    ports:
      - "6379:6379"
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5
    networks:
      - cppsh-network

  # Query Service
  query-service:
    build:
      context: .
      dockerfile: Dockerfile.query
    env_file:
      - common.env
    ports:
      - "8081:8081"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://query-service:8081/health"]
      interval: 5s
      timeout: 7s
      retries: 10
    depends_on:
      rabbitmq:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - cppsh-network
  
  ws-service:
    build:
      context: .
      dockerfile: Dockerfile.ws
    env_file:
      - common.env
    ports:
      - "8078:8078"
    environment:
      - GOMAXPROCS=4  # Match CPU cores
      - UV_THREADPOOL_SIZE=16  # For async I/O (if using libuv)
    sysctls:
      - net.core.somaxconn=65535  # Increase TCP backlog
      - net.ipv4.tcp_max_syn_backlog=65535
      - net.ipv4.tcp_tw_reuse=1  # Reuse TIME_WAIT sockets
    ulimits:
      nofile:
        soft: 65535  # Max open files (critical for WebSockets)
        hard: 65535
    deploy:
      resources:
        limits:
          cpus: '4'      # Allocate 4 CPU cores
          memory: 2G     # Max RAM
        reservations:
          memory: 1G    # Guaranteed RAM      
    healthcheck:
      test: ["CMD", "curl", "-f", "http://ws-service:8078/health"]
      interval: 5s
      timeout: 7s
      retries: 10
    depends_on:
      rabbitmq:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - cppsh-network 
  
  
  rabbit-listener:
    build:
      context: .
      dockerfile: Dockerfile.rabbit-listener
    env_file:
      - common.env
    depends_on:
      rabbitmq:
        condition: service_healthy
    networks:
      - cppsh-network

  rabbit-query-listener:
    build:
      context: .
      dockerfile: Dockerfile.rabbit-query-listener
    env_file:
      - common.env
    depends_on:
      rabbitmq:
        condition: service_healthy
    networks:
      - cppsh-network    
  # API Gateway
  api-gateway:
    build:
      context: .
      dockerfile: Dockerfile.gateway
    env_file:
      - common.env
    ports:
      - "8082:8082"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://api-gateway:8082/health"]
      interval: 5s
      timeout: 7s
      retries: 15
    #depends_on:
      #- consul
      #- command-service
      #- query-service
    networks:
      - cppsh-network

  token-validation:
    build:
      context: .
      dockerfile: Dockerfile.token-validation
    ports:
      - "8084:8084"
    env_file:
      - common.env
    healthcheck:
      test: ["CMD", "curl", "-f", "http://token-validation:8084/health"]
      interval: 5s
      timeout: 7s
      retries: 5
    depends_on:
      redis:
        condition: service_healthy
    networks:
      - cppsh-network

  # NGINX Load Balancer
  nginx:
    build:
      context: .
      dockerfile: Dockerfile.nginx
    ports:
      - "8088:8088"
    env_file:
      - common.env
    volumes:
      - ./nginx.conf.template:/etc/nginx/nginx.conf.template:ro
    depends_on:
      - token-validation
      - api-gateway
      - ws-service
    networks:
      - cppsh-network

  # Sync Service
  sync-service:
    build:
      context: .
      dockerfile: Dockerfile.sync
    env_file:
      - common.env
    healthcheck:
      test: ["CMD", "curl", "-f", "http://sync-service:8083/health"]
      interval: 5s
      timeout: 3s
      retries: 5
    depends_on:
      postgres:
        condition: service_healthy
      migration-service:
        condition: service_completed_successfully
      rabbitmq:
        condition: service_healthy
    networks:
      - cppsh-network

  file-service:
    build:
      context: .
      dockerfile: Dockerfile.file
    env_file:
      - common.env
    healthcheck:
      test: ["CMD", "curl", "-f", "http://file-servicee:8073/health"]
      interval: 5s
      timeout: 3s
      retries: 5
    ports:
      - "8073:8073"
    environment:
      - FILE_STORAGE_PATH=/app/uploads_data # Matches Dockerfile
      - FILE_SERVICE_PORT=8073
    networks:
      - cppsh-network      
    volumes:
      - file_uploads:/app/uploads_data # Persistent storage for uploads
      - ./tnk:/app/tnk
      - ./apks:/app/apks
    restart: unless-stopped


  prometheus:
    profiles: ["optional"]
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
    restart: unless-stopped
    networks:
      - monitoring

  grafana:
    profiles: ["optional"]
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    volumes:
      - grafana-storage:/var/lib/grafana
    restart: unless-stopped
    networks:
      - monitoring

  node-exporter:
    profiles: ["optional"]
    image: prom/node-exporter:latest
    container_name: node-exporter
    ports:
      - "9100:9100"
    restart: unless-stopped
    networks:
      - monitoring

  cadvisor:
    profiles: ["optional"]
    image: gcr.io/google-containers/cadvisor:latest
    container_name: cadvisor
    ports:
      - "8090:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    restart: unless-stopped
    networks:
      - monitoring

networks:
  cppsh-network:
    driver: bridge
  monitoring:
    driver: bridge

volumes:
  grafana-storage: {}
  file_uploads: {}
  client_app: {}