docker-compose.yml

name: loopless

services:
  frontend:
    image: node:20-alpine
    container_name: loopless-frontend
    profiles: ["core"]
    working_dir: /app/client
    command: >
      sh -c "
      if [ -f package.json ]; then
        npm install && npm run dev -- --hostname 0.0.0.0;
      else
        echo 'Frontend scaffold detected. Add Next.js app in ./frontend/client.' && sleep infinity;
      fi"
    volumes:
      - ./frontend:/app:z
    environment:
      NEXT_PUBLIC_API_BASE_URL: http://localhost:8081
    ports:
      - "3002:3000"
    depends_on:
      - backend
    networks:
      - app-net

  backend:
    image: mcr.microsoft.com/dotnet/sdk:10.0
    container_name: loopless-backend
    profiles: ["core"]
    working_dir: /src
    command: >
      bash -c "
      if find . -name '*.csproj' | grep -q .; then
        dotnet restore && dotnet watch --project src/Loopless.Api/Loopless.Api.csproj run;
      else
        echo 'Backend scaffold detected. Add .NET solution in ./backend.' && sleep infinity;
      fi"
    volumes:
      - ./backend:/src:z
    environment:
      ASPNETCORE_ENVIRONMENT: Development
      ConnectionStrings__PostgreSQL: "Host=postgres;Port=5432;Database=${POSTGRES_DB:-loopless};Username=${POSTGRES_USER:-loopless};Password=${POSTGRES_PASSWORD:-change_me_local}"
      ConnectionStrings__Redis: redis:6379
      Keycloak__Authority: http://keycloak:8080/realms/loopless
      Keycloak__Audience: loopless-api
      Keycloak__ValidIssuer: http://localhost:8090/realms/loopless
      Keycloak__RequireHttpsMetadata: "false"
      Keycloak__AdminClientId: loopless-api
      Keycloak__AdminClientSecret: "${KEYCLOAK_ADMIN_CLIENT_SECRET:-change_me_local}"
      Keycloak__TokenClientId: loopless-api
      Keycloak__InternalAuthority: http://keycloak:8080/realms/loopless
      ConnectionStrings__RabbitMQ: "amqp://${RABBITMQ_DEFAULT_USER:-loopless}:${RABBITMQ_DEFAULT_PASS:-change_me_local}@rabbitmq:5672/"
      Seed__AdminEmail: "${Seed__AdminEmail:-enes.admin@loopless.dev}"
      Seed__AdminPassword: "${Seed__AdminPassword:-Admin123!}"
      OpenAI__ApiKey: "${OPENAI_API_KEY:-}"
      OpenAI__EmbeddingsApiKey: "${OPENAI_EMBEDDINGS_API_KEY:-}"
      OpenAI__EmbeddingsEndpoint: https://generativelanguage.googleapis.com/v1beta/openai/embeddings
      OpenAI__Model: gemini-embedding-001
      OpenAI__ChatEndpoint: "${OPENAI_CHAT_ENDPOINT:-https://api.openai.com/v1/chat/completions}"
      OpenAI__ChatModel: "${OPENAI_MODEL:-gpt-4o-mini}"
      GitHub__Token: "${GITHUB_TOKEN:-}"
      KeyVault__Uri: "${KEYVAULT_URI:-}"
      Storage__BucketName: "${STORAGE_BUCKET:-loopless-uploads-dev}"
      Storage__Region: us-east-1
      Storage__AccessKey: "${MINIO_ROOT_USER:-minioadmin}"
      Storage__SecretKey: "${MINIO_ROOT_PASSWORD:-minioadmin}"
      Storage__ServiceUrl: http://minio:9000
      Storage__ForcePathStyle: "true"
      Email__SmtpHost: mailpit
      Email__SmtpPort: "1025"
      Email__Username: ""
      Email__Password: ""
      Email__FromAddress: noreply@loopless.dev
      Email__FromName: Loopless
      Email__UseSsl: "false"
      Serilog__WriteTo__1__Name: GrafanaLoki
      Serilog__WriteTo__1__Args__uri: http://loki:3100
      Serilog__WriteTo__2__Name: Http
      Serilog__WriteTo__2__Args__requestUri: http://logstash:5044
    ports:
      - "8081:8080"
    healthcheck:
      test:
        ["CMD-SHELL", "curl -sf http://localhost:8080/health/ready || exit 1"]
      interval: 15s
      timeout: 5s
      retries: 5
      start_period: 30s
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      rabbitmq:
        condition: service_healthy
      keycloak:
        condition: service_started
      minio:
        condition: service_healthy
      mailpit:
        condition: service_healthy
      logstash:
        condition: service_started
        required: false
    networks:
      - app-net

  postgres:
    image: pgvector/pgvector:pg16
    container_name: loopless-postgres
    profiles: ["core"]
    environment:
      POSTGRES_DB: ${POSTGRES_DB:-loopless}
      POSTGRES_USER: ${POSTGRES_USER:-loopless}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-change_me_local}
    ports:
      - "5432:5432"
    volumes:
      - postgres-data:/var/lib/postgresql/data
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "pg_isready -U ${POSTGRES_USER:-loopless} -d ${POSTGRES_DB:-loopless}",
        ]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - app-net

  redis:
    image: redis:7-alpine
    container_name: loopless-redis
    profiles: ["core"]
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - app-net

  keycloak:
    image: quay.io/keycloak/keycloak:25.0
    container_name: loopless-keycloak
    profiles: ["core"]
    command: start-dev --import-realm
    environment:
      KEYCLOAK_ADMIN: ${KEYCLOAK_ADMIN:-admin}
      KEYCLOAK_ADMIN_PASSWORD: ${KEYCLOAK_ADMIN_PASSWORD:-change_me_local}
      KC_FEATURES: scripts
      KC_HOSTNAME: http://localhost:8090
      KC_HOSTNAME_STRICT: "false"
      KC_HOSTNAME_STRICT_BACKCHANNEL: "false"
      KC_HOSTNAME_BACKCHANNEL_DYNAMIC: "true"
      KC_HTTP_ENABLED: "true"
      KC_HEALTH_ENABLED: "true"
      KC_METRICS_ENABLED: "true"
      GITHUB_CLIENT_ID: ${GITHUB_CLIENT_ID:-}
      GITHUB_CLIENT_SECRET: ${GITHUB_CLIENT_SECRET:-}
    ports:
      - "8090:8080"
    volumes:
      - keycloak-data:/opt/keycloak/data
      - ./devops/keycloak/loopless-realm.json:/opt/keycloak/data/import/loopless-realm.json:ro
    healthcheck:
      test:
        - "CMD-SHELL"
        - "exec 3<>/dev/tcp/127.0.0.1/9000 && printf 'GET /health/ready HTTP/1.1\\r\\nHost: localhost\\r\\nConnection: close\\r\\n\\r\\n' >&3 && head -c 512 <&3 | grep -q UP"
      interval: 30s
      timeout: 10s
      retries: 6
      start_period: 60s
    networks:
      - app-net

  minio:
    image: minio/minio:RELEASE.2025-02-07T23-21-09Z
    container_name: loopless-minio
    profiles: ["core"]
    command: server /data --console-address ":9001"
    environment:
      MINIO_ROOT_USER: ${MINIO_ROOT_USER:-minioadmin}
      MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:-minioadmin}
    ports:
      - "9000:9000"
      - "9001:9001"
    volumes:
      - minio-data:/data
    healthcheck:
      test: ["CMD-SHELL", "mc ready local || exit 1"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - app-net

  minio-bucket-init:
    image: minio/mc:RELEASE.2025-02-08T19-14-21Z
    container_name: loopless-minio-bucket-init
    profiles: ["core"]
    depends_on:
      minio:
        condition: service_healthy
    entrypoint: >
      sh -c "
      mc alias set local http://minio:9000 ${MINIO_ROOT_USER:-minioadmin} ${MINIO_ROOT_PASSWORD:-minioadmin} &&
      mc mb -p local/${STORAGE_BUCKET:-loopless-uploads-dev} 2>/dev/null || true &&
      mc anonymous set download local/${STORAGE_BUCKET:-loopless-uploads-dev} 2>/dev/null || true &&
      echo 'Bucket ready: ${STORAGE_BUCKET:-loopless-uploads-dev}'
      "
    restart: "no"
    networks:
      - app-net

  mailpit:
    image: axllent/mailpit:v1.21
    container_name: loopless-mailpit
    profiles: ["core"]
    ports:
      - "1025:1025"
      - "8025:8025"
    environment:
      MP_MAX_MESSAGES: "5000"
      MP_DATABASE: /data/mailpit.db
    volumes:
      - mailpit-data:/data
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:8025/api/v1/info"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - app-net

  rabbitmq:
    image: rabbitmq:3-management
    container_name: loopless-rabbitmq
    profiles: ["core"]
    environment:
      RABBITMQ_DEFAULT_USER: ${RABBITMQ_DEFAULT_USER:-loopless}
      RABBITMQ_DEFAULT_PASS: ${RABBITMQ_DEFAULT_PASS:-change_me_local}
      RABBITMQ_SERVER_ADDITIONAL_ERL_ARGS: "-rabbitmq_prometheus return_per_object_metrics true"
    ports:
      - "5672:5672"
      - "15672:15672"
      - "15692:15692"
    volumes:
      - rabbitmq-data:/var/lib/rabbitmq
    healthcheck:
      test: ["CMD", "rabbitmq-diagnostics", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - app-net

  prometheus:
    image: prom/prometheus:v2.54.1
    container_name: loopless-prometheus
    profiles: ["observability"]
    command:
      - --config.file=/etc/prometheus/prometheus.yml
      - --storage.tsdb.path=/prometheus
      - --storage.tsdb.retention.time=15d
      - --web.enable-lifecycle
    ports:
      - "9090:9090"
    volumes:
      - ./devops/monitoring/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - ./devops/monitoring/prometheus/alert-rules.yml:/etc/prometheus/alert-rules.yml:ro
      - prometheus-data:/prometheus
    depends_on:
      alertmanager:
        condition: service_started
    networks:
      - app-net

  alertmanager:
    image: prom/alertmanager:v0.27.0
    container_name: loopless-alertmanager
    profiles: ["observability"]
    command:
      - --config.file=/etc/alertmanager/alertmanager.yml
      - --storage.path=/alertmanager
    ports:
      - "9093:9093"
    volumes:
      - ./devops/monitoring/alertmanager/alertmanager.yml:/etc/alertmanager/alertmanager.yml:ro
      - alertmanager-data:/alertmanager
    networks:
      - app-net

  aiops-triage:
    build:
      context: ./devops/aiops
      dockerfile: Dockerfile
    container_name: loopless-aiops-triage
    profiles: ["automation"]
    environment:
      PORT: "8085"
      OPENAI_API_KEY: "${OPENAI_API_KEY:-}"
      OPENAI_CHAT_ENDPOINT: "${OPENAI_CHAT_ENDPOINT:-https://api.openai.com/v1/chat/completions}"
      OPENAI_MODEL: "${OPENAI_MODEL:-gpt-4o-mini}"
      DISCORD_WEBHOOK_URL: "${DISCORD_WEBHOOK_URL:-}"
      SLACK_WEBHOOK_URL: "${SLACK_WEBHOOK_URL:-}"
      AIOPS_ALERT_TITLE: "${AIOPS_ALERT_TITLE:-Loopless Alert Triage}"
    ports:
      - "8085:8085"
    networks:
      - app-net
    restart: unless-stopped

  node-exporter:
    image: prom/node-exporter:v1.8.2
    container_name: loopless-node-exporter
    profiles: ["observability"]
    networks:
      - app-net

  postgres-exporter:
    image: prometheuscommunity/postgres-exporter:v0.15.0
    container_name: loopless-postgres-exporter
    profiles: ["observability"]
    environment:
      DATA_SOURCE_NAME: "postgresql://${POSTGRES_USER:-loopless}:${POSTGRES_PASSWORD:-change_me_local}@postgres:5432/${POSTGRES_DB:-loopless}?sslmode=disable"
    networks:
      - app-net

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:v0.49.1
    container_name: life-cadvisor
    profiles: ["observability"]
    privileged: true
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker:/var/lib/docker:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
    networks:
      - app-net

  grafana:
    image: grafana/grafana:11.2.0
    container_name: loopless-grafana
    profiles: ["observability"]
    environment:
      GF_SECURITY_ADMIN_USER: ${GF_SECURITY_ADMIN_USER:-admin}
      GF_SECURITY_ADMIN_PASSWORD: ${GF_SECURITY_ADMIN_PASSWORD:-change_me_local}
      GF_USERS_ALLOW_SIGN_UP: "false"
      GF_AUTH_ANONYMOUS_ENABLED: "false"
    ports:
      - "3011:3000"
    volumes:
      - grafana-data:/var/lib/grafana
      - ./devops/monitoring/grafana/dashboards:/var/lib/grafana/dashboards:ro
      - ./devops/monitoring/grafana/provisioning/datasources.yml:/etc/grafana/provisioning/datasources/datasources.yml:ro
      - ./devops/monitoring/grafana/provisioning/dashboards.yml:/etc/grafana/provisioning/dashboards/dashboards.yml:ro
    depends_on:
      - prometheus
    networks:
      - app-net

  loki:
    image: grafana/loki:3.1.1
    container_name: loopless-loki
    profiles: ["observability"]
    command: -config.file=/etc/loki/local-config.yaml
    ports:
      - "3100:3100"
    volumes:
      - loki-data:/loki
    networks:
      - app-net

  nginx-cert-generator:
    image: alpine:3.20
    container_name: loopless-nginx-cert-generator
    profiles: ["core", "utility"]
    command: >
      sh -c "
      apk add --no-cache openssl &&
      mkdir -p /certs &&
      if [ ! -f /certs/loopless.crt ] || [ ! -f /certs/loopless.key ]; then
        openssl req -x509 -nodes -newkey rsa:2048 -sha256 -days 3650 -keyout /certs/loopless.key -out /certs/loopless.crt -subj '/CN=localhost' &&
        chmod 600 /certs/loopless.key &&
        chmod 644 /certs/loopless.crt;
      fi"
    volumes:
      - nginx-certs:/certs
    restart: "no"
    networks:
      - app-net

  nginx:
    image: nginx:1.27-alpine
    container_name: loopless-nginx
    profiles: ["core"]
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./devops/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - nginx-certs:/etc/nginx/certs:ro
      # Mounted empty in dev; populated by certbot in production
      - certbot-certs:/etc/letsencrypt:ro
      - certbot-webroot:/var/www/certbot:ro
    depends_on:
      frontend:
        condition: service_started
      backend:
        condition: service_started
      nginx-cert-generator:
        condition: service_completed_successfully
    networks:
      - app-net

  certbot:
    image: certbot/certbot:latest
    container_name: loopless-certbot
    profiles: ["production-ssl"]
    volumes:
      - certbot-certs:/etc/letsencrypt
      - certbot-webroot:/var/www/certbot
    entrypoint: /bin/sh -c "trap exit TERM; while :; do certbot renew --webroot -w /var/www/certbot --quiet; sleep 12h & wait $${!}; done"
    networks:
      - app-net
    restart: unless-stopped

  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.14.3
    container_name: loopless-elasticsearch
    profiles: ["observability"]
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
      - ES_JAVA_OPTS=-Xms256m -Xmx256m
    ports:
      - "9200:9200"
    volumes:
      - elasticsearch-data:/usr/share/elasticsearch/data
    networks:
      - app-net
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "curl -sf http://localhost:9200/_cluster/health || exit 1",
        ]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s

  kibana:
    image: docker.elastic.co/kibana/kibana:8.14.3
    container_name: loopless-kibana
    profiles: ["observability"]
    environment:
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
    ports:
      - "5601:5601"
    depends_on:
      elasticsearch:
        condition: service_healthy
    networks:
      - app-net

  logstash:
    image: docker.elastic.co/logstash/logstash:8.14.3
    container_name: loopless-logstash
    profiles: ["observability"]
    volumes:
      - ./devops/monitoring/logstash/pipeline:/usr/share/logstash/pipeline:ro
      - ./devops/monitoring/logstash/config/logstash.yml:/usr/share/logstash/config/logstash.yml:ro
      - ./devops/monitoring/logstash/config/pipelines.yml:/usr/share/logstash/config/pipelines.yml:ro
    ports:
      - "5044:5044"
    environment:
      LS_JAVA_OPTS: "-Xms256m -Xmx256m"
    depends_on:
      elasticsearch:
        condition: service_healthy
    networks:
      - app-net
    healthcheck:
      test: ["CMD-SHELL", "curl -sf http://localhost:9600/_node/stats || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s

  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: loopless-uptime-kuma
    profiles: ["observability"]
    ports:
      - "3003:3001"
    volumes:
      - uptime-kuma-data:/app/data
    networks:
      - app-net
    restart: unless-stopped

  n8n:
    image: n8nio/n8n:latest
    container_name: loopless-n8n
    profiles: ["automation"]
    ports:
      - "5679:5678"
    environment:
      - N8N_HOST=localhost
      - N8N_PORT=5678
      - N8N_PROTOCOL=http
      - WEBHOOK_URL=http://localhost:5679/
      - GENERIC_TIMEZONE=UTC
    volumes:
      - n8n-data:/home/node/.n8n
    networks:
      - app-net
    restart: unless-stopped

networks:
  app-net:
    driver: bridge

volumes:
  postgres-data:
  redis-data:
  prometheus-data:
  grafana-data:
  keycloak-data:
  rabbitmq-data:
  loki-data:
  alertmanager-data:
  nginx-certs:
  certbot-certs:
  certbot-webroot:
  elasticsearch-data:
  uptime-kuma-data:
  n8n-data:
  minio-data:
  mailpit-data: