JVM-based FHIR server from Health Samurai. Native Prometheus endpoint on :8379.

aidbox:
    container_name: perf-aidbox
    image: healthsamurai/aidboxone:edge
    pull_policy: always
    depends_on:
      postgres:
        condition: service_healthy
    deploy:
      resources:
        limits:
          cpus: '8'
          memory: 16G
    volumes:
      - ./infra/aidbox/initbundle.json:/tmp/initbundle.json
    environment:
      JAVA_OPTS: "-XX:MaxRAMPercentage=80 -XshowSettings:vm"
      BOX_ADMIN_PASSWORD: secret
      BOX_CACHE_REPLICATION_DISABLE: true
      BOX_BOOTSTRAP_FHIR_PACKAGES: hl7.fhir.r4.core#4.0.1
      BOX_DB_DATABASE: aidbox
      BOX_DB_HOST: postgres
      BOX_DB_PASSWORD: postgres
      BOX_DB_USER: postgres
      BOX_WEB_THREAD: 16
      BOX_DB_POOL_MAXIMUM__POOL__SIZE: 32
      BOX_FHIR_COMPLIANT_MODE: true
      BOX_FHIR_CORRECT_AIDBOX_FORMAT: true
      BOX_FHIR_CREATEDAT_URL: https://aidbox.app/ex/createdAt
      BOX_FHIR_SCHEMA_VALIDATION: true
      BOX_FHIR_SEARCH_AUTHORIZE_INLINE_REQUESTS: true
      BOX_FHIR_SEARCH_COMPARISONS: true
      BOX_FHIR_TERMINOLOGY_SERVICE_BASE_URL: https://tx.health-samurai.io/fhir
      BOX_METRICS_PORT: 8379
      BOX_INIT_BUNDLE: file:///tmp/initbundle.json
      BOX_ROOT_CLIENT_SECRET: secret
      BOX_SEARCH_INCLUDE_CONFORMANT: true
      BOX_SECURITY_DEV_MODE: true
      BOX_SETTINGS_MODE: read-write
      BOX_WEB_BASE_URL: http://localhost:8080
      BOX_WEB_MAX_BODY: 209715200
      BOX_WEB_PORT: 8080
      BOX_FHIR_SEARCH_DEFAULT_PARAMS_TOTAL: none
    healthcheck:
      test: curl -f http://localhost:8080/health
      interval: 30s
      start_period: 30s
      retries: 10
    ports:
      - "13080:8080"

{
  "resourceType": "Bundle",
  "type": "transaction",
  "entry": [
    {
      "request": {
        "method": "POST",
        "url": "/AccessPolicy",
        "ifNoneExist": "_id=perf"
      },
      "resource": {
        "id": "perf",
        "engine": "allow"
      }
    },
    {
      "request": {
        "method": "POST",
        "url": "AidboxMigration",
        "ifNoneExist": "id=perf-indexes"
      },
      "resource": {
        "resourceType": "AidboxMigration",
        "id": "perf-indexes",
        "action": "aidbox-migration-run-sql",
        "status": "to-run",
        "params": {
          "resourceType": "Parameters",
          "parameter": [
            {
              "name": "sql",
              "valueString": "
              CREATE INDEX IF NOT EXISTS claim_resource_idx ON Claim USING GIN (resource jsonb_path_ops);

              CREATE INDEX IF NOT EXISTS encounter_resource_idx ON Encounter USING GIN (resource jsonb_path_ops);
              
              CREATE INDEX IF NOT EXISTS explanation_of_benefit_resource_idx ON ExplanationOfBenefit USING GIN (resource jsonb_path_ops);
              
              CREATE INDEX IF NOT EXISTS location_resource_idx ON Location USING GIN (resource jsonb_path_ops);
              
              CREATE INDEX IF NOT EXISTS medication_request_resource_idx ON MedicationRequest USING GIN (resource jsonb_path_ops);
              
              CREATE INDEX IF NOT EXISTS observation_resource_idx ON Observation USING GIN (resource jsonb_path_ops);
              
              CREATE INDEX IF NOT EXISTS organization_resource_idx ON Organization USING GIN (resource jsonb_path_ops);
              
              CREATE INDEX IF NOT EXISTS patient_resource_idx ON Patient USING GIN (resource jsonb_path_ops);
              
              CREATE INDEX IF NOT EXISTS patient_name_param_knife_string_trgm ON patient USING gin ((aidbox_text_search(knife_extract_text(resource, '[[\"name\",\"family\"],[\"name\",\"given\"],[\"name\",\"middle\"],[\"name\",\"text\"],[\"name\",\"prefix\"],[\"name\",\"suffix\"]]'))) gin_trgm_ops);
              
              CREATE INDEX IF NOT EXISTS patient_name_param_knife_string ON patient USING gin ((knife_extract_text(resource, '[[\"name\",\"family\"],[\"name\",\"given\"],[\"name\",\"middle\"],[\"name\",\"text\"],[\"name\",\"prefix\"],[\"name\",\"suffix\"]]')));
              
              CREATE INDEX IF NOT EXISTS patient_given_param_knife_string_trgm ON patient USING gin ((aidbox_text_search(knife_extract_text(resource, '[[\"name\",\"given\"]]'))) gin_trgm_ops);
              
              CREATE INDEX IF NOT EXISTS patient_given_param_knife_string ON patient USING gin ((knife_extract_text(resource, '[[\"name\",\"given\"]]')));\nCREATE INDEX IF NOT EXISTS patient_birthdate_param_knife_date_min_tstz ON patient USING btree ((knife_extract_min_timestamptz(resource, '[[\"birthDate\"]]')));
              
              CREATE INDEX IF NOT EXISTS patient_birthdate_param_knife_date_max_tstz ON patient USING btree ((knife_extract_max_timestamptz(resource, '[[\"birthDate\"]]')));
              
              CREATE INDEX IF NOT EXISTS practitioner_resource_idx ON Practitioner USING GIN (resource jsonb_path_ops);"
            }
          ]
        }
      }
    }
  ]
}


Aidbox

Per-container CPU / memory / I/O metrics. Talks to dind's containerd via the explicitly mounted socket.

cadvisor:
    container_name: perf-cadvisor
    image: gcr.io/cadvisor/cadvisor:latest
    pull_policy: always
    privileged: true
    command:
      - --containerd=/var/run/docker/containerd/containerd.sock
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
      - /dev/disk/:/dev/disk:ro

cAdvisor

Dashboards over Prometheus. Anonymous Admin access enabled in dev.

grafana:
    container_name: perf-grafana
    image: grafana/grafana:13.0
    pull_policy: always
    environment:
      GF_AUTH_ANONYMOUS_ORG_ROLE: Admin
      GF_AUTH_ANONYMOUS_ENABLED: true
      GF_AUTH_BASIC_ENABLED: true
      GF_SECURITY_ADMIN_PASSWORD: admin
      
    healthcheck:
      test: curl http://localhost:3000/api/health
      interval: 5s
      start_period: 30s
    ports:
      - "13000:3000"
    volumes:
      - ./infra/grafana:/etc/grafana/provisioning:ro

Grafana

Reference Java FHIR server. Spring Boot Actuator exposes Prometheus metrics at /actuator/prometheus.

hapi:
    container_name: perf-hapi
    image: hapiproject/hapi:latest
    pull_policy: always
    entrypoint:
      - java
      - -XX:MaxRAMPercentage=80
      - -XshowSettings:vm
      - --class-path
      - /app/main.war
      - -Dloader.path=main.war!/WEB-INF/classes/,main.war!/WEB-INF/,/app/extra-classes
      - org.springframework.boot.loader.PropertiesLauncher
    depends_on:
      postgres:
        condition: service_healthy
    deploy:
      resources:
        limits:
          cpus: '8'
          memory: 16G
    ports:
      - "13090:8080"
    volumes:
      - ./infra/hapi/application.yaml:/app/config/application.yaml:ro

hapi:
  fhir:
    graphql_enabled: true
    bulk_export_enabled: true
    enable_index_missing_fields: true
    reuse_cached_search_results_millis: 0
management:
  endpoints:
    enabled-by-default: false
    web:
      exposure:
        include: 'info,health,prometheus,metrics'
  endpoint:
    info:
      enabled: true
    metrics:
      enabled: true
    health:
      enabled: true
      probes:
        enabled: true
      group:
        liveness:
          include:
            - readinessState
    prometheus:
      enabled: true
  prometheus:
    metrics:
      export:
        enabled: true
spring:
  datasource:
    url: 'jdbc:postgresql://postgres/hapi'
    username: postgres
    password: postgres
    driverClassName: org.postgresql.Driver
    hikari:
      maximum-pool-size: 32
  jpa:
    properties:
      hibernate.dialect: ca.uhn.fhir.jpa.model.dialect.HapiFhirPostgresDialect
      hibernate.search.enabled: false

HAPI FHIR

Grafana k6 runs scenarios against each FHIR server inside the docker-compose network. Results are sent to Prometheus via remote-write.

k6:
    container_name: perf-k6
    image: grafana/k6
    pull_policy: always
    depends_on:
      aidbox:
        condition: service_healthy
      medplum:
        condition: service_healthy
      hapi-checker:
        condition: service_healthy
    profiles:
      - donotstart
    volumes:
      - ./k6:/k6
      - ./runner.sh:/runner.sh:ro

set -e

DEFAULT_TEST="/k6/prewarm.js"
ALL_SERVERS="aidbox hapi medplum"

show_usage() {
    echo "Usage: $0 [-t test] [-s server] [-id runId] [-f file1 -f file2 ...]"
    echo "       $0 bootstrap [-f file1 -f file2 ...]"
    echo ""
    echo "Commands:"
    echo "  bootstrap  Start Docker Compose services"
    echo ""
    echo "Arguments:"
    echo "  -t test    Path to test file (e.g., /k6/crud.js, /k6/search.js)"
    echo "  -s server  Target server: aidbox, hapi, medplum"
    echo "  -id runId  Custom run ID (optional - defaults to current UTC timestamp)"
    echo "  -f file    Docker Compose file(s) to use (can be specified multiple times)"
    echo "             If not specified, uses the default docker-compose.yaml"
    echo ""
    echo "Examples:"
    echo "  $0 bootstrap                                    # Start services"
    echo "  $0 bootstrap -f docker-compose.yaml -f docker-compose.prod.yaml  # Start with multiple compose files"
    echo "  $0 -t /k6/crud.js -s aidbox -id my-test-run     # Run CRUD test on Aidbox with custom ID"
    echo "  $0 -t /k6/search.js -s hapi                     # Run search test on HAPI with auto-generated ID"
    echo "  $0 -t /k6/prewarm.js                            # Run prewarm test on all servers"
    echo "  $0 -t /k6/crud.js -f docker-compose.yaml -f override.yaml  # Run test with custom compose files"
    echo "  $0                                                # Run default test on all servers"
    echo ""
    echo "Available tests:"
    echo "  /k6/prewarm.js"
    echo "  /k6/crud.js"
    echo "  /k6/search.js"
    echo "  /k6/import.js"
    echo "  /k6/import-seed.js"
    echo "  /k6/auth.js"
}

bootstrap_services() {
    local max_attempts=5
    local attempt=1

    echo "Pulling docker images..."
    echo "================================================"
    docker compose $COMPOSE_FILES pull aidbox hapi medplum

    echo "Starting Docker Compose services  (max $max_attempts attempts)..."
    echo "================================================"

    while [ $attempt -le $max_attempts ]; do
        echo "Attempt $attempt/$max_attempts: Starting services..."

        if docker compose $COMPOSE_FILES up -d --wait; then
            echo "✅ Services started successfully on attempt $attempt!"
            echo "================================================"
            return 0
        else
            echo "❌ Attempt $attempt failed. Services may still be starting up..."

            if [ $attempt -lt $max_attempts ]; then
                echo "Waiting 10 seconds before retry..."
                sleep 10
            fi

            attempt=$((attempt + 1))
        fi
    done

    echo "❌ Failed to start services after $max_attempts attempts"
    echo "================================================"
    return 1
}

validate_server() {
    local server=$1
    case " $ALL_SERVERS " in
        *" $server "*) return 0 ;;
        *) return 1 ;;
    esac
}

# … truncated (151 more lines)

k6 runner

Node.js-based FHIR server. No native Prometheus endpoint — emits OpenTelemetry metrics, which are forwarded through the OTel Collector.

medplum:
    image: medplum/medplum-server:latest
    pull_policy: always
    command:
      - file:/srv/config.json
    deploy:
      replicas: 8
      resources:
        limits:
          cpus: '1'
          memory: 2G
    depends_on:
      postgres:
        condition: service_healthy
    environment:
      OTLP_METRICS_ENDPOINT: http://otel-collector:4318/v1/metrics
    volumes:
      - ./infra/medplum:/srv
    healthcheck:
      test:
        [
          "CMD",
          "node",
          "-e",
          'fetch("http://localhost:8103/healthcheck").then(r => r.json()).then(console.log).catch(() => { process.exit(1); })',
        ]
      interval: 10s
      timeout: 1s
      retries: 10

Medplum

Receives OTLP from Medplum and re-exports as Prometheus metrics on :8889.

otel-collector:
    container_name: perf-otel-collector
    image: otel/opentelemetry-collector-contrib:latest
    pull_policy: always
    command:
      - --config=/etc/otel/config.yaml
    volumes:
      - ./infra/otel/config.yaml:/etc/otel/config.yaml:ro

receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318
      grpc:
        endpoint: 0.0.0.0:4317

processors:
  batch:
    timeout: 5s

exporters:
  prometheus:
    endpoint: 0.0.0.0:8889
    namespace: medplum
    send_timestamps: true
    metric_expiration: 5m

service:
  pipelines:
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [prometheus]

OTel Collector

Single shared instance, separate databases per FHIR server. Tuned via postgres.conf.

postgres:
    container_name: perf-postgres
    image: postgres:18
    pull_policy: always
    command: postgres -c config_file=/postgres.conf
    ports:
      - "13020:5432"
    deploy:
      resources:
        limits:
          cpus: '8'
          memory: 30G
    environment:
      PGDATA: /data/pg
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    healthcheck:
      test: pg_isready -U postgres
      interval: 3s
      start_period: 10s
    volumes:
      - pgdata:/data
      - ./infra/postgres/init:/docker-entrypoint-initdb.d
      - ./infra/postgres/postgres.conf:/postgres.conf

listen_addresses = '*'
max_connections = 1000
max_wal_size = '1GB'
shared_preload_libraries = 'pg_stat_statements'
shared_buffers = '10GB'
statement_timeout = 60000

PostgreSQL 18

Exposes PostgreSQL internals as Prometheus metrics on :9187.

postgres-exporter:
    container_name: perf-postgres-exporter
    image: quay.io/prometheuscommunity/postgres-exporter
    pull_policy: always
    depends_on:
      postgres:
        condition: service_healthy
    environment:
      DATA_SOURCE_PASS: postgres
      DATA_SOURCE_USER: postgres
      DATA_SOURCE_URI: postgres:5432/postgres?sslmode=disable
    healthcheck:
      test: wget -O - http://localhost:9187/metrics
      interval: 10s
      start_period: 10s
      timeout: 5s
      retries: 3

postgres-exporter

Scrapes /metrics endpoints from FHIR servers and exporters; receives k6 results via remote-write.

prometheus:
    container_name: perf-prometheus
    image: prom/prometheus
    pull_policy: always
    command:
      - --config.file=/etc/prometheus/prometheus.yml
      - --enable-feature=native-histograms
      - --storage.tsdb.path=/prometheus
      - --web.enable-remote-write-receiver
    healthcheck:
      test: wget -O - http://localhost:9090/-/ready
      interval: 5s
      start_period: 5s
    ports:
      - "13010:9090"
    volumes:
      - promdata:/prometheus
      - ./infra/prometheus/config.yaml:/etc/prometheus/prometheus.yml

global:
  scrape_interval: 10s
  scrape_timeout: 5s
  scrape_protocols:
  - PrometheusProto
  - PrometheusText0.0.4
  evaluation_interval: 10s
runtime:
  gogc: 75

scrape_configs:

  - job_name: aidbox
    static_configs:
      - targets: ["aidbox:8379"]

  - job_name: docker
    static_configs:
      - targets: ["host.docker.internal:9323"]

  - job_name: hapi
    metrics_path: /actuator/prometheus
    static_configs:
      - targets: ["hapi:8080"]

  - job_name: postgres
    static_configs:
      - targets: ["postgres-exporter:9187"]

  - job_name: cadvisor
    static_configs:
      - targets: ["cadvisor:8080"]

  - job_name: medplum
    static_configs:
      - targets: ["otel-collector:8889"]

Prometheus

Used by Medplum for sessions and BullMQ job queues.

redis:
    container_name: perf-redis
    image: redis:latest
    pull_policy: always
    healthcheck:
      test: [ "CMD", "redis-cli", "ping" ]
      interval: 10s
      start_period: 10s
      timeout: 5s
      retries: 5

Redis

HTTP server that downloads and serves the Synthea bundle for the import benchmark.

tgz:
    container_name: perf-tgz
    build:
      context: infra/tgz
    command:
      - "https://storage.googleapis.com/aidbox-public/synthea/performance/bulk_1k.tar.gz"
    volumes:
      - tgzdata:/data
    working_dir: /data

FROM golang:1.24.2 AS builder

WORKDIR /srv

COPY go.mod go.sum ./
RUN go mod download

COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o main

WORKDIR /data
VOLUME /data
ENTRYPOINT ["/srv/main"]
HEALTHCHECK --interval=5s --timeout=1s --retries=100 --start-period=5s CMD [ \
  "curl", "--fail", "http://127.0.0.1:8080/healthz" \
]

Infrastructure

Overview

FHIR servers under test

Aidbox

HAPI FHIR

Medplum

Architecture diagram

Monitoring stack

CI execution