Skip to content
mofcloud

Deploy MOF on Kubernetes

Last updated:

MOF, Dash and MCP in one Pod.

Linux amd64 · kubectl · External PostgreSQL · 1 Pod · 3 containers

Private network · CREATEDB permission required · TLS-only PostgreSQL unsupported.

Image source

Download mof.yaml

Docker Hub · MOF v2.0.15 · Dash v2.0.17 · MCP v2.0.3

Download mof.yaml ↓
View file
mof.yaml
# MOF v2.0.15 + Dash v2.0.17 + MCP v2.0.3
# Edit database address, user and password before applying. Keep this file private.
# Keep the Service names mof, mof-mcp and dash, all in one namespace: the components find each
# other by them (mof:8080, mof-mcp:8001). Renamed Services can't connect.
# Private-network PostgreSQL without TLS. TLS-only databases are not supported by this release.
apiVersion: v1
kind: Namespace
metadata:
  name: mof
---
apiVersion: v1
kind: Secret
metadata:
  name: mof-database
  namespace: mof
type: Opaque
stringData:
  password: "REPLACE_WITH_YOUR_DATABASE_PASSWORD"
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: mof-config
  namespace: mof
data:
  RK_POSTGRES_0_ADDR: "db.example.com:5432"
  RK_POSTGRES_0_USER: "mof"
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mof
  namespace: mof
spec:
  replicas: 1
  # First-release template: stop the old Pod before starting the new version.
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app: mof
  template:
    metadata:
      labels:
        app: mof
      # Prometheus discovery by annotation; see the monitoring guide for a PodMonitor
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "8080"
        prometheus.io/path: /internal/v1/mof/metrics
    spec:
      enableServiceLinks: false
      nodeSelector:
        kubernetes.io/arch: amd64
      terminationGracePeriodSeconds: 120
      containers:
        - name: mof
          image: mofcloud/mof:v2.0.15
          envFrom:
            - configMapRef:
                name: mof-config
          env:
            - name: RK_POSTGRES_0_PASS
              valueFrom:
                secretKeyRef:
                  name: mof-database
                  key: password
          ports:
            - name: api
              containerPort: 8080
          startupProbe:
            httpGet:
              path: /v1/mof/site-info
              port: api
            periodSeconds: 10
            failureThreshold: 60
          readinessProbe:
            httpGet:
              path: /v1/mof/site-info
              port: api
            periodSeconds: 10
            timeoutSeconds: 5
          resources:
            requests:
              cpu: "500m"
              memory: "1Gi"
          volumeMounts:
            - name: offer-cache
              mountPath: /usr/src/mof/offer-cache
      volumes:
        - name: offer-cache
          emptyDir: {}
---
apiVersion: v1
kind: Service
metadata:
  name: mof
  namespace: mof
spec:
  selector:
    app: mof
  ports:
    - name: api
      port: 8080
      targetPort: api
  type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mof-mcp
  namespace: mof
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mof-mcp
  template:
    metadata:
      labels:
        app: mof-mcp
    spec:
      enableServiceLinks: false
      nodeSelector:
        kubernetes.io/arch: amd64
      containers:
        - name: mof-mcp
          image: mofcloud/mof-mcp:v2.0.3
          ports:
            - name: mcp
              containerPort: 8001
          readinessProbe:
            exec:
              command: ["node", "/app/build/healthcheck.js"]
            periodSeconds: 10
            timeoutSeconds: 5
          resources:
            requests:
              cpu: "100m"
              memory: "128Mi"
---
apiVersion: v1
kind: Service
metadata:
  name: mof-mcp
  namespace: mof
spec:
  selector:
    app: mof-mcp
  ports:
    - name: mcp
      port: 8001
      targetPort: mcp
  type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: dash
  namespace: mof
spec:
  replicas: 1
  selector:
    matchLabels:
      app: dash
  template:
    metadata:
      labels:
        app: dash
    spec:
      enableServiceLinks: false
      nodeSelector:
        kubernetes.io/arch: amd64
      containers:
        - name: dash
          image: mofcloud/dash:v2.0.17
          ports:
            - name: web
              containerPort: 80
          readinessProbe:
            httpGet:
              path: /
              port: web
            periodSeconds: 10
          resources:
            requests:
              cpu: "100m"
              memory: "64Mi"
---
apiVersion: v1
kind: Service
metadata:
  name: dash
  namespace: mof
spec:
  selector:
    app: dash
  ports:
    - name: web
      port: 80
      targetPort: web
  type: ClusterIP

Keep the Service names mof, mof-mcp and dash, all in one namespace. The components find each other by these names (mof:8080, mof-mcp:8001), so nothing else needs configuring; renamed Services can’t connect.

Database connection

Fill in your existing PostgreSQL in mof.yaml:

RK_POSTGRES_0_ADDR
Address:port
RK_POSTGRES_0_USER
Username
stringData.password
Existing database password

Keep passwords quoted and this file private.

Deploy

Terminal
kubectl apply -f mof.yaml
kubectl -n mof rollout status deployment/mof --timeout=10m
kubectl -n mof rollout status deployment/mof-mcp deployment/dash

Once all three are rolled out, get the Admin password:

Terminal
kubectl -n mof logs deployment/mof | grep "Admin password"

Open MOF

Terminal
kubectl -n mof port-forward service/dash 8000:80

Keep this terminal running.

Adminhttp://127.0.0.1:8000/admin

Install your license and create users.

MOF Webhttp://127.0.0.1:8000

Sign in with your MOF account.

Advanced configuration

PostgreSQL TLS compatibility

MOF applies TLS settings to Mof and AsyncJobMof, but not provider databases. This template requires a trusted private network and cannot use TLS-only PostgreSQL.

Domain, HTTPS and optional OAuth

Use an existing Ingress controller and point your domain to it. Set the class, hostname and an existing TLS Secret in namespace mof.

Download ingress.yaml ↓
ingress.yaml
# Requires an installed Ingress controller and an existing TLS Secret.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: mof
  namespace: mof
spec:
  ingressClassName: nginx
  tls:
    - hosts: [mof.example.com]
      secretName: mof-web-tls
  rules:
    - host: mof.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: dash
                port:
                  number: 80
Terminal
kubectl apply -f ingress.yaml
kubectl -n mof get ingress

Enable MCP in Admin → Settings → MCP. Endpoint: /v1/mof/remote-mcp. Tokens need no OAuth; browser OAuth requires HTTPS, MOF_PUBLIC_URL and MOF_MCP_OAUTH_SECRET.

Health checks and troubleshooting
Terminal
kubectl -n mof get pods
kubectl -n mof logs deployment/mof --tail=100
kubectl -n mof logs deployment/mof-mcp --tail=60
kubectl -n mof logs deployment/dash --tail=60
kubectl -n mof exec deployment/mof -- wget -q -O - http://mof-mcp:8001/health

Expected: mof, mof-mcp and dash Running and Ready; MCP ready: true. Check image pulls, node architecture and database access if startup fails.

Template parameters
RK_POSTGRES_0_ADDRExternal PostgreSQL hostname:port, reachable from the Pod.
RK_POSTGRES_0_USERExisting database role with permission to create MOF and provider databases.
mof-database / passwordDatabase password stored in a Secret; injected only into MOF.
Services mof / mof-mcp / dashOne Deployment and Service each. They find each other by Service name; nothing to set.
replicas / strategy1 / Recreate. Upgrades briefly interrupt service; multi-replica HA is outside this template.
resources.requestsScheduling reservations, not memory limits. Size MOF for your bill volume and monitor actual usage.
offer-cache / emptyDirRebuildable public pricing cache. Lost when the Pod is replaced; billing data remains in PostgreSQL.
ingressClassName / host / tlsMatch your installed controller, public domain and TLS Secret. Optional for local port-forward checks.
Updates, data and scaling

Back up PostgreSQL, update the image versions and apply mof.yaml. Restart after ConfigMap or Secret changes. Recreate upgrades interrupt service.

Terminal
kubectl -n mof rollout restart deployment/mof
kubectl -n mof rollout status deployment/mof --timeout=10m

Single replica only; on-demand Kubernetes Jobs are not implemented. Application data stays in external PostgreSQL; the pricing cache can be rebuilt.