example.yaml

# example.yaml — a runnable showcase of every kind this chart supports.
#
# Install (from chart root):
#   helm template -f example.yaml demo-persist .   # renders only persist-context resources
#   helm template -f example.yaml demo-core    .   # renders only core-context resources
#
# This file is referenced from docs/ — snippets there are copied from here, so
# every fragment you read in the docs renders in the context of this file.
# Read the docs (start at docs/README.md) for the tutorial-shaped walkthrough;
# this file is the "all kinds at once" reference.

# ----------------------------------------------------------------------------
# Globals — see docs/globals.md
# ----------------------------------------------------------------------------

xDeployment:
  persist: demo-persist   # data + databases — install first, never re-install
  core:    demo-core      # services — install once persist is up

xValidKinds: [deployment, ballancer, pvc, configmap, secret, pg-database, pg-backup, ray]

xCommonStorageClass: &global-storage
  class: standard

xEnvGlobal: &global-env
  HTTPS_PROXY: ""

xWaitDependencyImage: cerit.io/rationai/production/wait-for-200:v0.0.1

xNetworkPolicy:
  enabled: false
  name: kube-system

xAdditionalNoProxy:
  - localhost

xGlobalUser:    1000
xGlobalGroup:   1000
xGlobalFsGroup: 1002


# ----------------------------------------------------------------------------
# Persist context — PVCs and databases. Survives across app re-installs.
# ----------------------------------------------------------------------------

# A shared persistent volume mounted by the app — see docs/pvc.md
sharedData:
  kind: pvc
  context: persist
  name: shared-data
  specs:
    <<: *global-storage
    size: 5Gi

# A Postgres cluster (CloudNativePG) — see docs/pg-database.md
appDb:
  kind: pg-database
  context: persist
  name: app-db
  specs:
    <<: *global-storage
    image: ghcr.io/cloudnative-pg/postgresql:15
    instances: 1
    username: appuser
    dbname: appdb
    storage: 2Gi

# A scheduled volume-snapshot backup of appDb — see docs/pg-database.md
appDbBackup:
  kind: pg-backup
  context: persist
  name: app-db-backup
  specs:
    backupSchedule: "0 0 3 * * *"
    referencedCluster: demo-persist-app-db-postgres


# ----------------------------------------------------------------------------
# Core context — applications. Install once persist is up.
# ----------------------------------------------------------------------------

# A configmap mounted as a file into the api pod — see docs/configmap.md
appConfig:
  kind: configmap
  context: core
  name: app-config
  content: |
    log_level: info
    feature_flags:
      experimental_api: false

# A second configmap in the same context — see docs/configmap.md
# Each `configmap` entry renders one ConfigMap with one data key; declare as many
# as you need and mount them side by side.
gatewayConfig:
  kind: configmap
  context: core
  name: gateway.conf
  content: |
    listen 8080;
    admin_listen 9901;
    upstream api;

# A secret — see docs/secret.md
# Two forms: a literal value, and a computed value (`uri.internal` returns a
# bare string; helpers that return YAML fragments are NOT usable in data:).
apiSecret:
  kind: secret
  context: core
  name: api-secret
  data:
    API_TOKEN: "replace-me-with-a-real-token"
    WORKER_HOST:
      function: uri.internal
      args: [worker, host]

# The api deployment — see docs/deployment.md
# Talks to the database (via env.postgress.*), to the worker (via env.serviceUri),
# mounts the shared PVC and the appConfig configmap, and is exposed via ingress.
api:
  kind: deployment
  context: core
  name: api
  port: 8000
  pod:
    image: ghcr.io/example/api:v1
    imagePullPolicy: IfNotPresent
    replicas: 2
    targetPort: 8080
    requests:
      cpu: 200m
      memory: 256Mi
    limits:
      cpu: 1
      memory: 1Gi
    heartbeat: /healthz
    pvc:
      - name: data
        target: sharedData
        mount: /data
      - name: config
        target: appConfig
        mount: /etc/app
    awaitEnv:
      function: env.serviceUri
      args: [worker, health]
  env:
    <<: *global-env
    APP_LOG_LEVEL: info
    DB_HOST:
      function: env.postgress.host
      args: [appDb]
    DB_PASSWORD:
      function: env.postgress.secret
      args: [appDb]
    DB_NAME: appdb
    DB_USER: appuser
    API_TOKEN:
      function: env.secret
      args: [apiSecret, API_TOKEN]
    WORKER_URL:
      function: env.serviceUri
      args: [worker, url]
    NO_PROXY:
      function: env.noproxy
      args: [worker]
  ingress:
    domainname: demo.example.com
    pathprefix: /api
  api:
    health: /healthz
    metrics: /metrics

# The worker deployment — see docs/deployment.md
# Internal-only (no ingress). The api waits for it via awaitEnv.
worker:
  kind: deployment
  context: core
  name: worker
  port: 9000
  pod:
    image: ghcr.io/example/worker:v1
    replicas: 1
    targetPort: 9000
    requests:
      cpu: 100m
      memory: 128Mi
    limits:
      cpu: 500m
      memory: 512Mi
    heartbeat: /health
  env:
    <<: *global-env
    DB_HOST:
      function: env.postgress.host
      args: [appDb]
    DB_PASSWORD:
      function: env.postgress.secret
      args: [appDb]
    DB_NAME: appdb
    DB_USER: appuser
  api:
    health: /health

# A multi-port deployment behind an ingress — see docs/deployment.md#multiple-ports
# Uses the named-ports form: the public traffic port is named `http`, which is what
# the ingress backend and the NetworkPolicy resolve to. The `admin` port is reachable
# only in-cluster, at <release>-<name>:9901 — the ingress never sees it.
gateway:
  kind: deployment
  context: core
  name: gateway
  ports:
    http:
      port: 8080
      targetPort: 8080
    admin:
      port: 9901
      targetPort: 9901
  pod:
    image: ghcr.io/example/gateway:v1
    replicas: 1
    requests:
      cpu: 100m
      memory: 128Mi
    limits:
      cpu: 500m
      memory: 512Mi
    pvc:
      - name: gateway-conf
        target: gatewayConfig
        mount: /etc/gateway/gateway.conf
        subPath: gateway.conf
    # the named-ports form has no single implied HTTP path, so string-form
    # `heartbeat` is replaced by an explicit probe here
    livenessProbe:
      tcpSocket:
        port: 8080
  ingress:
    domainname: demo.example.com
    pathprefix: /gateway
  env:
    <<: *global-env
    ADMIN_PORT:
      function: env.namedPort
      args: [gateway, admin, service]

# A load-balancer service — see docs/deployment.md#ballancer
# `ballancer` differs from `deployment` only by emitting `type: LoadBalancer`.
edgeProxy:
  kind: ballancer
  context: core
  name: edge-proxy
  port: 80
  pod:
    image: ghcr.io/example/edge-proxy:v1
    replicas: 1
    targetPort: 8080
    requests:
      cpu: 50m
      memory: 64Mi
    limits:
      cpu: 200m
      memory: 128Mi

# A small Ray service — see docs/ray.md
mlServe:
  kind: ray
  context: core
  name: ml-serve
  image: rayproject/ray:2.24.0
  serveConfigV2: |
    applications:
      - name: hello
        route_prefix: /
        import_path: hello:app
  head:
    requests:
      cpu: 500m
      memory: 1Gi
    limits:
      cpu: 1
      memory: 2Gi
  workers:
    - name: cpu-worker
      replicas: 1
      resources:
        requests:
          cpu: 500m
          memory: 1Gi
        limits:
          cpu: 1
          memory: 2Gi