docker-compose.yml

version: '3'

services:

  offer-db: # Postgresql database for offers
    image: offer-db:latest
    container_name: offer-db
    volumes:
      - offer-db_data:/var/lib/postgresql/data
    networks:
      - offer-network
    env_file: ./env/offer/database.env
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U seasonsforce -d offer"]
      interval: 30s
      timeout: 60s
      retries: 5
    restart: unless-stopped

  offer-api:
    image: offer-api:latest  # Spring Boot API for offers
    container_name: offer-api
    depends_on:
      offer-db:
        condition:
          service_healthy
      keycloak-server:
        condition:
          service_healthy
      discovery-service:
        condition:
          service_healthy
      config-server:
        condition:
          service_healthy
      kafka-server:
        condition:
          service_healthy
    env_file: ./env/offer/api.env
    networks:
      - offer-network
      - api-network
    healthcheck:
      test: "curl --fail --silent localhost:8080/actuator/health | grep UP || exit 1"
      interval: 20s
      timeout: 5s
      retries: 15
    restart: unless-stopped

  address-db: # Postgresql database for addresses
    image: address-db:latest
    container_name: address-db
    volumes:
      - address-db_data:/var/lib/postgresql/data
    networks:
      - address-network
    env_file: ./env/address/database.env
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U seasonsforce -d address"]
      interval: 30s
      timeout: 60s
      retries: 5
    restart: unless-stopped

  address-api:
    image: address-api:latest  # Spring Boot API for addresses
    container_name: address-api
    depends_on:
      address-db:
        condition:
          service_healthy
      keycloak-server:
        condition:
          service_healthy
      discovery-service:
        condition:
          service_healthy
      config-server:
        condition:
          service_healthy
    env_file: ./env/address/api.env
    networks:
      - address-network
      - api-network
    healthcheck:
      test: "curl --fail --silent localhost:8080/actuator/health | grep UP || exit 1"
      interval: 20s
      timeout: 5s
      retries: 15
    restart: unless-stopped

  company-db: # Postgresql database for companies
    image: company-db:latest
    container_name: company-db
    volumes:
      - company-db_data:/var/lib/postgresql/data
    networks:
      - company-network
    env_file: ./env/company/database.env
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U seasonsforce -d company"]
      interval: 30s
      timeout: 60s
      retries: 5
    restart: unless-stopped

  company-minio: # Minio database for companies
    image: company-minio:latest
    container_name: company-minio
    ports:
      - "9000:9000"
      - "9001:9001"
    volumes:
      - company-minio-data:/data
    env_file: ./env/company/minio.env
    networks:
      - company-network
      - api-network
    restart: unless-stopped

  company-api:
    image: company-api:latest  # Spring Boot API for companies
    container_name: company-api
    depends_on:
      company-db:
        condition:
          service_healthy
      company-minio:
        condition:
          service_started
      keycloak-server:
        condition:
          service_healthy
      discovery-service:
        condition:
          service_healthy
      config-server:
        condition:
          service_healthy
    networks:
      - company-network
      - api-network
    env_file:
      - ./env/company/api.env
    healthcheck:
      test: "curl --fail --silent localhost:8080/actuator/health | grep UP || exit 1"
      interval: 20s
      timeout: 5s
      retries: 15
    restart: unless-stopped

  invoice-db: # Postgresql database for invoices
    image: invoice-db:latest
    container_name: invoice-db
    volumes:
      - invoice-db_data:/var/lib/postgresql/data
    networks:
      - invoice-network
    env_file: ./env/invoice/database.env
    healthcheck:
      test: [ "CMD-SHELL", "pg_isready -U seasonsforce -d invoice" ]
      interval: 30s
      timeout: 60s
      retries: 5
    restart: unless-stopped

  invoice-minio: # Minio database for invoices
    image: invoice-minio:latest
    container_name: invoice-minio
    ports:
      - "9002:9000"
      - "9003:9001"
    volumes:
      - invoice-minio-data:/data
    env_file: ./env/invoice/minio.env
    networks:
      - invoice-network
      - api-network
    restart: unless-stopped

  invoice-api:
    image: invoice-api:latest  # Spring Boot API for invoices
    container_name: invoice-api
    depends_on:
      invoice-db:
        condition:
          service_healthy
      invoice-minio:
        condition:
          service_started
      keycloak-server:
        condition:
          service_healthy
      discovery-service:
        condition:
          service_healthy
      config-server:
        condition:
          service_healthy
    networks:
      - invoice-network
      - api-network
    env_file:
      - ./env/invoice/api.env
    healthcheck:
      test: "curl --fail --silent localhost:8080/actuator/health | grep UP || exit 1"
      interval: 20s
      timeout: 5s
      retries: 15
    restart: unless-stopped

  user-minio: # Minio database for users
    image: user-minio:latest
    container_name: user-minio
    ports:
      - "9004:9000"
      - "9005:9001"
    volumes:
      - user-minio-data:/data
    env_file: ./env/user/minio.env
    networks:
      - api-network
      - user-network
    restart: unless-stopped

  user-api:
    image: user-api:latest  # Spring Boot API for users
    container_name: user-api
    depends_on:
      keycloak-server:
        condition:
          service_healthy
      discovery-service:
        condition:
          service_healthy
      config-server:
        condition:
          service_healthy
    networks:
      - api-network
      - user-network
    env_file: ./env/user/api.env
    healthcheck:
      test: "curl --fail --silent localhost:8080/actuator/health | grep UP || exit 1"
      interval: 20s
      timeout: 5s
      retries: 15
    restart: unless-stopped

  reference-db: # Postgresql database for references
    image: reference-db:latest
    container_name: reference-db
    volumes:
      - reference-db_data:/var/lib/postgresql/data
    networks:
      - reference-network
    env_file: ./env/reference/database.env
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U seasonsforce -d reference"]
      interval: 30s
      timeout: 60s
      retries: 5
    restart: unless-stopped

  reference-api:
    image: reference-api:latest  # Spring Boot API for references
    container_name: reference-api
    depends_on:
      keycloak-server:
        condition:
          service_healthy
      discovery-service:
        condition:
          service_healthy
      config-server:
        condition:
          service_healthy
    networks:
        - api-network
        - reference-network
    env_file: ./env/reference/api.env
    healthcheck:
        test: "curl --fail --silent localhost:8080/actuator/health | grep UP || exit 1"
        interval: 20s
        timeout: 5s
        retries: 15
    restart: unless-stopped

  experience-db: # Postgresql database for experiences
    image: experience-db:latest
    container_name: experience-db
    volumes:
      - experience-db_data:/var/lib/postgresql/data
    networks:
      - experience-network
    env_file: ./env/experience/database.env
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U seasonsforce -d experience"]
      interval: 30s
      timeout: 60s
      retries: 5
    restart: unless-stopped

  experience-api:
    image: experience-api:latest  # Spring Boot API for experiences
    container_name: experience-api
    depends_on:
      experience-db:
        condition:
          service_healthy
      keycloak-server:
        condition:
          service_healthy
      discovery-service:
        condition:
          service_healthy
      config-server:
        condition:
          service_healthy
    networks:
      - experience-network
      - api-network
    env_file: ./env/experience/api.env
    healthcheck:
      test: "curl --fail --silent localhost:8080/actuator/health | grep UP || exit 1"
      interval: 20s
      timeout: 5s
      retries: 15
    restart: unless-stopped

  availability-db: # Postgresql database for availabilities
    image: availability-db:latest
    container_name: availability-db
    volumes:
      - availability-db_data:/var/lib/postgresql/data
    networks:
      - availability-network
    env_file: ./env/availability/database.env
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U seasonsforce -d availability"]
      interval: 30s
      timeout: 60s
      retries: 5
    restart: unless-stopped

  availability-api: # Spring Boot API for availabilities
    image: availability-api:latest
    container_name: availability-api
    depends_on:
      availability-db:
        condition:
          service_healthy
      keycloak-server:
        condition:
          service_healthy
      discovery-service:
        condition:
          service_healthy
      config-server:
        condition:
          service_healthy
    networks:
      - availability-network
      - api-network
    env_file: ./env/availability/api.env
    healthcheck:
      test: "curl --fail --silent localhost:8080/actuator/health | grep UP || exit 1"
      interval: 20s
      timeout: 5s
      retries: 15
    restart: unless-stopped

  payment-db: # Postgresql database for payments
    image: payment-db:latest
    container_name: payment-db
    volumes:
      - payment-db_data:/var/lib/postgresql/data
    networks:
      - payment-network
    env_file: ./env/payment/database.env
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U seasonsforce -d payment"]
      interval: 30s
      timeout: 60s
      retries: 5
    restart: unless-stopped

  payment-api: # Spring Boot API for payments
    image: payment-api:latest
    container_name: payment-api
    depends_on:
      payment-db:
        condition:
          service_healthy
      keycloak-server:
        condition:
          service_healthy
      discovery-service:
        condition:
          service_healthy
      config-server:
        condition:
          service_healthy
    networks:
      - payment-network
      - api-network
    env_file: ./env/payment/api.env
    healthcheck:
      test: "curl --fail --silent localhost:8080/actuator/health | grep UP || exit 1"
      interval: 20s
      timeout: 5s
      retries: 15
    restart: unless-stopped

  review-db: # MongoDB database for reviews
    image: review-db:latest
    container_name: review-db
    volumes:
      - review-db_data:/data/db
    networks:
      - review-network
    env_file: ./env/review/database.env
    restart: unless-stopped

  review-api: # Kotlin Spring Boot API for reviews
    image: review-api:latest
    container_name: review-api
    depends_on:
      review-db:
        condition:
          service_started
      keycloak-server:
        condition:
          service_healthy
      discovery-service:
        condition:
          service_healthy
      config-server:
        condition:
          service_healthy
    networks:
      - review-network
      - api-network
    env_file: ./env/review/api.env
    healthcheck:
      test: "curl --fail --silent localhost:8080/actuator/health | grep UP || exit 1"
      interval: 30s
      timeout: 60s
      retries: 5
    restart: unless-stopped

  notification-db: # Mongo database for notifications
    image: notification-db:latest
    container_name: notification-db
    volumes:
      - notification-db_data:/data/db
    networks:
      - notification-network
    env_file: ./env/notification/database.env
    restart: unless-stopped

  notification-api: # Spring Boot API for notifications
    image: notification-api:latest
    container_name: notification-api
    depends_on:
      notification-db:
        condition:
          service_started
      keycloak-server:
        condition:
          service_healthy
      discovery-service:
        condition:
          service_healthy
      config-server:
        condition:
          service_healthy
      kafka-server:
        condition:
          service_healthy
    networks:
      - notification-network
      - api-network
    env_file: ./env/notification/api.env
    healthcheck:
      test: "curl --fail --silent localhost:8080/actuator/health | grep UP || exit 1"
      interval: 30s
      timeout: 60s
      retries: 5
    restart: unless-stopped

  api-gateway:
      image: api-gateway:latest  # Spring API Gateway
      container_name: api-gateway
      depends_on:
        config-server:
            condition:
                service_healthy
        discovery-service:
            condition:
                service_healthy
        keycloak-server:
            condition:
                service_healthy
      ports:
        - "8090:8080"  # Output to port 8090
      networks:
        - api-network
      env_file: ./env/gateway/api.env
      healthcheck:
        test: "curl --fail --silent localhost:8080/actuator/health | grep UP || exit 1"
        interval: 20s
        timeout: 5s
        retries: 15
      restart: unless-stopped

  discovery-service:
      image: discovery-service:latest  # Discovery server Eureka
      container_name: discovery-service
      depends_on:
        config-server:
          condition:
            service_healthy
      ports:
          - "8761:8761"  # Output to port 8761
      networks:
        - api-network
      healthcheck:
        test: "curl --fail --silent localhost:8761/actuator/health | grep UP || exit 1"
        interval: 20s
        timeout: 5s
        retries: 15
      restart: unless-stopped

  config-server:
    image: config-server:latest  # Spring Cloud Config Server
    container_name: config-server
    ports:
        - "4300:8888"  # Output to port 4300
    networks:
      - api-network
    env_file: ./env/config/server.env
    healthcheck:
      test: "curl --fail --silent localhost:8888/actuator/health | grep UP || exit 1"
      interval: 10s
      timeout: 5s
      retries: 50
    restart: unless-stopped

  keycloak-server:
    image: keycloak-server:latest
    hostname: keycloak-server
    container_name: keycloak-server
    ports:
      - "9090:8080"
    build: .
    depends_on:
        keycloak-db:
            condition:
                service_healthy
    env_file: ./env/keycloak/server.env
    healthcheck:
        test: [ "CMD-SHELL", "bash -c 'echo -n > /dev/tcp/0.0.0.0/8080'"]
        interval: 10s
        retries: 30
        timeout: 5s
    networks:
        - keycloak-network
        - api-network
    restart: unless-stopped

  keycloak-db:
    image: keycloak-db:latest
    hostname: keycloak-db
    container_name: keycloak-db
    volumes:
        - keycloak-db_data:/var/lib/postgresql/data
    ports:
      - "5432"
    networks:
        - keycloak-network
    env_file: ./env/keycloak/database.env
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U keycloak -d keycloak"]
      interval: 30s
      timeout: 60s
      retries: 5
    restart: unless-stopped

  kafka-server:
    image: confluentinc/cp-kafka:latest
    hostname: kafka-server
    container_name: kafka-server
    ports:
      - "9092"
    networks:
      - api-network
    volumes:
      - kafka_data:/var/lib/kafka/data
    env_file: ./env/kafka/kafka.env
    depends_on:
      zookeeper-server:
        condition:
          service_healthy
    healthcheck:
      test: [ "CMD-SHELL", "kafka-topics --bootstrap-server kafka-server:9092 --list" ]
      interval: 30s
      timeout: 60s
      retries: 5

  zookeeper-server:
    image: confluentinc/cp-zookeeper:latest
    hostname: zookeeper-server
    container_name: zookeeper-server
    ports:
      - "2181"
    networks:
      - api-network
    volumes:
      - zookeeper_data:/var/lib/zookeeper/data
      - zookeeper_datalog:/var/lib/zookeeper/log
    env_file: ./env/kafka/zookeeper.env
    healthcheck:
      test: ["CMD-SHELL", "zookeeper-shell zookeeper-server:2181 ls /"]
      interval: 30s
      timeout: 60s
      retries: 5

networks:
  offer-network:
  address-network:
  company-network:
  invoice-network:
  reference-network:
  experience-network:
  availability-network:
  payment-network:
  user-network:
  review-network:
  notification-network:
  api-network:
  kafka-network:
  keycloak-network:

volumes:
  offer-db_data:
  address-db_data:
  company-db_data:
  invoice-db_data:
  reference-db_data:
  experience-db_data:
  availability-db_data:
  payment-db_data:
  review-db_data:
  notification-db_data:
  keycloak-db_data:
  company-minio-data:
  invoice-minio-data:
  user-minio-data:
  zookeeper_data:
  zookeeper_datalog:
  kafka_data: