docker-compose.yml

x-sentry-env: &sentry-env
  SENTRY_DSN: ${SENTRY_DSN:-}
  SENTRY_ENVIRONMENT: ${SENTRY_ENVIRONMENT:-development}
  SENTRY_TRACES_SAMPLE_RATE: ${SENTRY_TRACES_SAMPLE_RATE:-0.1}
  SENTRY_LOG_LEVEL: ${SENTRY_LOG_LEVEL:-info}
  RUST_LOG: ${RUST_LOG:-info}

x-log-volume: &log-volume
  volumes:
    - ./logs:/logs

services:
  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: osship
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
      POSTGRES_DB: osship
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./migrations/init/001_schemas.sql:/docker-entrypoint-initdb.d/01_schemas.sql:ro
      - ./migrations/general/001_init.up.sql:/docker-entrypoint-initdb.d/02_general.sql:ro
      - ./migrations/general/002_stripe_connect.up.sql:/docker-entrypoint-initdb.d/02b_stripe.sql:ro
      - ./migrations/general/003_password_salt.up.sql:/docker-entrypoint-initdb.d/02c_password_salt.sql:ro
      - ./migrations/general/004_session_is_active.up.sql:/docker-entrypoint-initdb.d/session_active.sql:ro
      - ./migrations/payments/001_init.up.sql:/docker-entrypoint-initdb.d/03_payments.sql:ro
      - ./migrations/payments/002_outbox.up.sql:/docker-entrypoint-initdb.d/03b_outbox.sql:ro
      - ./migrations/metrics/001_init.up.sql:/docker-entrypoint-initdb.d/04_metrics.sql:ro
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U osship -d osship"]
      interval: 5s
      timeout: 5s
      retries: 5
    networks:
      - osship-net

  redis:
    image: redis:7-alpine
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5
    networks:
      - osship-net

  kafka:
    image: apache/kafka:3.8.0
    environment:
      KAFKA_NODE_ID: 1
      KAFKA_PROCESS_ROLES: broker,controller
      KAFKA_LISTENERS: PLAINTEXT://:9092,CONTROLLER://:9093
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092
      KAFKA_CONTROLLER_LISTENER_NAMES: CONTROLLER
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT
      KAFKA_CONTROLLER_QUORUM_VOTERS: 1@kafka:9093
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
      KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0
      KAFKA_NUM_PARTITIONS: 1
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "/opt/kafka/bin/kafka-broker-api-versions.sh --bootstrap-server localhost:9092 || exit 1",
        ]
      interval: 10s
      timeout: 10s
      retries: 10
      start_period: 30s
    networks:
      - osship-net

  kafka-init:
    image: apache/kafka:3.8.0
    depends_on:
      kafka:
        condition: service_healthy
    volumes:
      - ./scripts/kafka-init-topics.sh:/kafka-init-topics.sh:ro
    entrypoint: ["/bin/bash", "/kafka-init-topics.sh"]
    environment:
      KAFKA_BOOTSTRAP: kafka:9092
    networks:
      - osship-net
    restart: "no"

  prometheus:
    image: prom/prometheus:v2.54.1
    volumes:
      - ./observability/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prometheus_data:/prometheus
    command:
      - --config.file=/etc/prometheus/prometheus.yml
      - --storage.tsdb.retention.time=${PROMETHEUS_RETENTION:-15d}
    healthcheck:
      test: ["CMD", "wget", "-q", "--spider", "http://localhost:9090/-/healthy"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - osship-net

  grafana:
    image: grafana/grafana:11.2.0
    environment:
      GF_SECURITY_ADMIN_USER: ${GRAFANA_ADMIN_USER:-admin}
      GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_ADMIN_PASSWORD:?Set GRAFANA_ADMIN_PASSWORD in .env}
      GF_SERVER_ROOT_URL: ${GF_SERVER_ROOT_URL:-http://127.0.0.1:3030/}
      GF_SERVER_SERVE_FROM_SUB_PATH: "false"
    ports:
      - "127.0.0.1:3030:3000"
    volumes:
      - ./observability/grafana/provisioning:/etc/grafana/provisioning:ro
      - ./observability/grafana/dashboards:/var/lib/grafana/dashboards:ro
      - grafana_data:/var/lib/grafana
    healthcheck:
      test:
        ["CMD", "wget", "-q", "--spider", "http://localhost:3000/api/health"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - osship-net

  auth:
    build:
      context: .
      dockerfile: services/auth/Dockerfile
    <<: *log-volume
    environment:
      DATABASE_URL_GENERAL: postgres://osship:${POSTGRES_PASSWORD}@postgres:5432/osship?sslmode=disable&search_path=general
      JWT_SECRET: ${JWT_SECRET:?Set JWT_SECRET in .env}
      JWT_EXPIRY_HOURS: ${JWT_EXPIRY_HOURS:-24}
      GITHUB_CLIENT_ID: ${GITHUB_CLIENT_ID:-}
      GITHUB_CLIENT_SECRET: ${GITHUB_CLIENT_SECRET:-}
      GITHUB_OAUTH_REDIRECT_URI: ${GITHUB_OAUTH_REDIRECT_URI:-http://localhost/api/v1/auth/oauth/github/callback}
      OAUTH_SUCCESS_REDIRECT: ${OAUTH_SUCCESS_REDIRECT:-http://localhost/auth/github/callback}
      APP_BASE_URL: ${APP_BASE_URL:-http://localhost}
      PORT: "8081"
      <<: *sentry-env
    depends_on:
      postgres:
        condition: service_healthy
    healthcheck:
      test:
        ["CMD", "wget", "-q", "-O", "/dev/null", "http://localhost:8081/health"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - osship-net

  users:
    build:
      context: .
      dockerfile: services/users/Dockerfile
    <<: *log-volume
    environment:
      DATABASE_URL_GENERAL: postgres://osship:${POSTGRES_PASSWORD}@postgres:5432/osship?sslmode=disable&search_path=general
      KAFKA_BROKERS: kafka:9092
      GITHUB_TOKEN: ${GITHUB_TOKEN:-}
      PORT: "8083"
      <<: *sentry-env
    depends_on:
      postgres:
        condition: service_healthy
      kafka:
        condition: service_healthy
      kafka-init:
        condition: service_completed_successfully
    healthcheck:
      test:
        ["CMD", "wget", "-q", "-O", "/dev/null", "http://localhost:8083/health"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - osship-net

  listings:
    build:
      context: .
      dockerfile: services/listings/Dockerfile
    <<: *log-volume
    environment:
      DATABASE_URL_GENERAL: postgres://osship:${POSTGRES_PASSWORD}@postgres:5432/osship?sslmode=disable&search_path=general
      KAFKA_BROKERS: kafka:9092
      PORT: "8082"
      <<: *sentry-env
    depends_on:
      postgres:
        condition: service_healthy
      kafka:
        condition: service_healthy
      kafka-init:
        condition: service_completed_successfully
    healthcheck:
      test:
        ["CMD", "wget", "-q", "-O", "/dev/null", "http://localhost:8082/health"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - osship-net

  mentors:
    build:
      context: .
      dockerfile: services/mentors/Dockerfile
    <<: *log-volume
    environment:
      DATABASE_URL_GENERAL: postgres://osship:${POSTGRES_PASSWORD}@postgres:5432/osship?sslmode=disable&search_path=general
      KAFKA_BROKERS: kafka:9092
      GITHUB_TOKEN: ${GITHUB_TOKEN:-}
      PORT: "8085"
      <<: *sentry-env
    depends_on:
      postgres:
        condition: service_healthy
      kafka:
        condition: service_healthy
      kafka-init:
        condition: service_completed_successfully
    healthcheck:
      test:
        ["CMD", "wget", "-q", "-O", "/dev/null", "http://localhost:8085/health"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - osship-net

  sessions:
    build:
      context: .
      dockerfile: services/sessions/Dockerfile
    <<: *log-volume
    environment:
      DATABASE_URL_GENERAL: postgres://osship:${POSTGRES_PASSWORD}@postgres:5432/osship?sslmode=disable&search_path=general
      KAFKA_BROKERS: kafka:9092
      JITSI_BASE_URL: ${JITSI_BASE_URL:-https://meet.jit.si}
      JITSI_APP_ID: ${JITSI_APP_ID}
      JITSI_API_KEY: ${JITSI_API_KEY}
      JITSI_PRIVATE_KEY_PATH: ${JITSI_PRIVATE_KEY_PATH}
      PORT: "8084"
      <<: *sentry-env
    depends_on:
      postgres:
        condition: service_healthy
      kafka:
        condition: service_healthy
      kafka-init:
        condition: service_completed_successfully
    healthcheck:
      test:
        ["CMD", "wget", "-q", "-O", "/dev/null", "http://localhost:8084/health"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - osship-net

  payments:
    build:
      context: services/payments
      dockerfile: Dockerfile
    environment:
      DATABASE_URL_PAYMENTS: postgres://osship:${POSTGRES_PASSWORD}@postgres:5432/osship?sslmode=disable
      DATABASE_URL_GENERAL: postgres://osship:${POSTGRES_PASSWORD}@postgres:5432/osship?sslmode=disable
      STRIPE_SECRET_KEY: ${STRIPE_SECRET_KEY:-sk_test_...}
      STRIPE_WEBHOOK_SECRET: ${STRIPE_WEBHOOK_SECRET:-whsec_...}
      PLATFORM_FEE_PERCENT: ${PLATFORM_FEE_PERCENT:-10}
      USERS_SERVICE_URL: http://users:8083
      KAFKA_BROKERS: kafka:9092
      APP_BASE_URL: ${APP_BASE_URL:-http://localhost}
      PORT: "8087"
      <<: *sentry-env
    depends_on:
      postgres:
        condition: service_healthy
      kafka:
        condition: service_healthy
      kafka-init:
        condition: service_completed_successfully
      users:
        condition: service_healthy
    healthcheck:
      test:
        ["CMD", "wget", "-q", "-O", "/dev/null", "http://localhost:8087/health"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - osship-net

  notifications:
    build:
      context: .
      dockerfile: services/notifications/Dockerfile
    <<: *log-volume
    environment:
      KAFKA_BROKERS: kafka:9092
      RESEND_API_KEY: ${RESEND_API_KEY:-}
      RESEND_FROM_EMAIL: ${RESEND_FROM_EMAIL:-noreply@osship.local}
      PORT: "8086"
      <<: *sentry-env
    depends_on:
      kafka:
        condition: service_healthy
      kafka-init:
        condition: service_completed_successfully
    healthcheck:
      test:
        ["CMD", "wget", "-q", "-O", "/dev/null", "http://localhost:8086/health"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - osship-net

  metrics:
    build:
      context: services/metrics
      dockerfile: Dockerfile
    environment:
      DATABASE_URL_METRICS: postgres://osship:${POSTGRES_PASSWORD}@postgres:5432/osship?sslmode=disable
      KAFKA_BROKERS: kafka:9092
      PORT: "8088"
      <<: *sentry-env
    depends_on:
      postgres:
        condition: service_healthy
      kafka:
        condition: service_healthy
      kafka-init:
        condition: service_completed_successfully
    healthcheck:
      test:
        ["CMD", "wget", "-q", "-O", "/dev/null", "http://localhost:8088/health"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - osship-net

  gateway:
    build:
      context: .
      dockerfile: services/gateway/Dockerfile
    <<: *log-volume
    environment:
      PORT: "8080"
      REDIS_URL: redis://redis:6379
      JWT_SECRET: ${JWT_SECRET:?Set JWT_SECRET in .env}
      AUTH_SERVICE_URL: http://auth:8081
      LISTINGS_SERVICE_URL: http://listings:8082
      USERS_SERVICE_URL: http://users:8083
      SESSIONS_SERVICE_URL: http://sessions:8084
      MENTORS_SERVICE_URL: http://mentors:8085
      PAYMENTS_SERVICE_URL: http://payments:8087
      RATE_LIMIT_AUTH_LOGIN: ${RATE_LIMIT_AUTH_LOGIN:-10}
      RATE_LIMIT_PAYMENTS_CHECKOUT: ${RATE_LIMIT_PAYMENTS_CHECKOUT:-5}
      ENABLE_SWAGGER: ${ENABLE_SWAGGER:-false}
      <<: *sentry-env
    depends_on:
      redis:
        condition: service_healthy
      auth:
        condition: service_healthy
      users:
        condition: service_healthy
      listings:
        condition: service_healthy
      mentors:
        condition: service_healthy
      payments:
        condition: service_healthy
    healthcheck:
      test:
        ["CMD", "wget", "-q", "-O", "/dev/null", "http://localhost:8080/health"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - osship-net

  ui:
    build:
      context: ui
      args:
        NEXT_PUBLIC_JITSI_APP_ID: ${NEXT_PUBLIC_JITSI_APP_ID}
      dockerfile: Dockerfile
    environment:
      NEXT_PUBLIC_API_URL: /api/v1
      INTERNAL_API_URL: http://gateway:8080/api/v1
      NEXT_PUBLIC_SENTRY_DSN: ${NEXT_PUBLIC_SENTRY_DSN}
      NEXT_PUBLIC_JITSI_APP_ID: ${NEXT_PUBLIC_JITSI_APP_ID}
      <<: *sentry-env
    depends_on:
      gateway:
        condition: service_healthy
    networks:
      - osship-net

  nginx:
    image: nginx:1.27-alpine
    ports:
      - "3000:80"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/conf.d/default.conf:ro
    depends_on:
      ui:
        condition: service_started
      gateway:
        condition: service_healthy
      grafana:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://localhost"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - osship-net

volumes:
  postgres_data:
  prometheus_data:
  grafana_data:

networks:
  osship-net:
    driver: bridge