OpenRun
OpenRun

Self-hosted GitOps for web apps and internal tools

Deploy to Docker, Podman or Kubernetes from one declarative config in Git. Single sign-on, access control, audit logs, TLS and scale-to-zero are built in.

open sourceApache-2.0single binarydockerpodmankubernetes
bash
# install and start the server
curl -sSL https://openrun.dev/install.sh | sh
openrun server start &

# deploy every app declared in a Git repo
openrun sync schedule --approve --promote \
    github.com/openrundev/openrun/examples/utils.star
$ 

introduction

What is OpenRun?

A platform for deploying web apps on your own infrastructure. Teams use it to run internal tools with login, access control and auditing on every app.

runs on
dockerpodmankubernetes
managed through
gitcliweb consolerest apimcp
open source

Self-hosted

An alternative to Google Cloud Run and Heroku that runs on your own servers, inside your network.

gitops

Declarative

Apps are created, configured and promoted by editing a config file in Git. OpenRun reconciles the rest.

operations

One binary

Web server, TLS, routing, auth and deployment in a single Go binary. No separate proxy or CI/CD system.

scope

Focused

Built for web apps and internal tools. A small surface keeps the platform simple to run and to learn.

platform overview

Key features

gitops

Declarative deploys

Create, configure and promote apps by editing one file in Git. No UI clicks, no deploy scripts.

auth

SSO and RBAC

OAuth, OIDC, SAML or client certificates in front of any app, with role-based access. No app code changes.

bindings

Service bindings

Each app gets its own database account. PostgreSQL, MySQL, SQLite and Redis are built in, more through providers.

scale

Scale to zero

Idle app containers stop and start again on the next request. Run many apps on small hardware.

releases

Staged releases

Changes land in a staging environment first, then promote to production with a blue-green switch.

storage

Durable SQLite

SQLite volumes replicate continuously with Litestream to S3-compatible storage and restore after node loss.

actions

Actions and MCP

Generated forms for backend operations. Actions also run from the CLI and are served as MCP tools.

audit

Audit and telemetry

Every operation and API call is recorded as an audit event. Traces and metrics export over OpenTelemetry.

system design

How it works

deploy: from git to a running app
Developercode + config
Git reposource of truth
OpenRun serverreconcile + build
Container runtimedocker / podman / k8s
Appcontainer
serve: every request passes through the server
App userbrowser / api / mcp
TLS + routingdomain or path
Auth + RBACoauth / oidc / saml
Proxystarts idle apps
Appcontainer

One Go binary

The same process reconciles state from Git and routes incoming requests.

Small footprint

A single node uses an embedded SQLite database for metadata. Kubernetes uses Postgres.

Security at the platform

Login, access rules and audit events are handled before a request reaches the app.

kubernetes deployment

OpenRun on Kubernetes

kubernetes cluster
Requestsingress / lb
OpenRun serverdeployment + service
App 1deployment + service
App 2deployment + service
Postgresmetadata, external
Container registryapp images, external
components

A standard Helm install

OpenRun runs as a Deployment with a Service. It uses Postgres for metadata and a registry for the images it builds.

routing

No per-app Ingress

Requests reach the OpenRun server, which routes to each app through its ClusterIP Service.

reconcile

Lazy creation, server-side apply

App resources are created on the first request and updated with Kubernetes server-side apply.

getting started

Three ways to install

a / single node

Linux, macOS or Windows with Docker or Podman. The quickest way to start.

curl -sSL https://openrun.dev/install.sh | sh   # or: brew install openrun
openrun server start &
b / kubernetes

A Helm chart for an existing cluster. Apps scale across nodes with the same config.

helm repo add openrun https://openrundev.github.io/openrun-helm-charts/
helm install openrun1 openrun/openrun \
    --namespace openrun --create-namespace --set registry.enabled=true
c / terraform on aws

Creates an EKS cluster, an RDS database and an ECR registry, then installs OpenRun.

cd openrun/deploy/terraform
terraform init && terraform apply --var-file terraform.tfvars

note  For production on Kubernetes, use an external Postgres database and container registry.

deployment workflow

GitOps in one command

bash
openrun sync schedule --approve --promote \
    github.com/openrundev/openrun/examples/utils.star
  • --approve  accept the permissions each app asks for
  • --promote  move staged changes to production
  • After this, a commit to the repo is the only deploy step.
what the scheduled sync does
watch

Poll the repo

Checks the Git URL for new commits to config or source.

read

Load config

Reads the app declarations and fetches each app's source.

build

Build images

Builds from an AppSpec or the app's own Dockerfile.

deploy

Apply changes

Creates new apps and updates existing ones, staging first.

secure

Enforce policy

Applies the configured login, access rules and audit logging.

simplicity first

The whole config, side by side

apps.star openrun / starlark
# Resource limits (optional)
limits = {"cpus": "1", "memory": "512m"}

# A Streamlit app, served at /misc/streamlit_example
app(path="/misc/streamlit_example",
    source="github.com/streamlit/streamlit-example",
    git_branch="master", spec="python-streamlit",
    container_opts=limits)

# A FastHTML app, served at the fasthtml subdomain
app(path="fasthtml.:",
    source="github.com/AnswerDotAI/fasthtml/examples",
    spec="python-fasthtml",
    params={"APP_MODULE": "basic_ws:app"},
    container_opts=limits)
Complete for two apps: where the source is, how to build it, how to route to it and what limits to set.
app.yaml kubernetes / yaml, 94 lines, scroll
# Deployment: runs the app container
apiVersion: apps/v1
kind: Deployment
metadata:
  name: streamlit-app
  namespace: apps
  labels:
    app: streamlit
spec:
  replicas: 1
  selector:
    matchLabels:
      app: streamlit
  template:
    metadata:
      labels:
        app: streamlit
    spec:
      containers:
        - name: streamlit
          image: registry.example.com/apps/streamlit-example:1.0.0
          ports:
            - containerPort: 8501
          resources:
            limits:
              cpu: "1"
              memory: 512Mi
          readinessProbe:
            httpGet:
              path: /_stcore/health
              port: 8501
          livenessProbe:
            httpGet:
              path: /_stcore/health
              port: 8501
---
# Service: stable address for the pods
apiVersion: v1
kind: Service
metadata:
  name: streamlit-app
  namespace: apps
spec:
  selector:
    app: streamlit
  ports:
    - port: 80
      targetPort: 8501
---
# Ingress: domain routing and TLS (needs cert-manager)
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: streamlit-app
  namespace: apps
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt
spec:
  ingressClassName: nginx
  tls:
    - hosts:
        - streamlit.example.com
      secretName: streamlit-app-tls
  rules:
    - host: streamlit.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: streamlit-app
                port:
                  number: 80
---
# Argo CD Application: sync the manifests from Git
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: streamlit-app
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/example/deploy-config
    targetRevision: main
    path: apps/streamlit
  destination:
    server: https://kubernetes.default.svc
    namespace: apps
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
One app, without RBAC or auditing. Argo CD, an IDP, SSO, cert-manager and a CI image build also need to be configured.

comparison

OpenRun and managed cloud services

compared withGoogle Cloud RunAWS App Runner
where openrun is stronger
  • Your network, your dataRuns on your own hardware or VPC, so network policy and data location stay under your control.
  • Predictable costNo per-request billing. Busy apps and custom hardware run on capacity you already pay for.
  • Login without IAM plumbingAdd SSO and role-based access to any app through config, with no sidecars or app changes.
  • Everything in GitThe deployment setup is versioned and reviewable, not spread across cloud console settings.
trade-offs
  • You run the infrastructureHardware, OS updates and uptime are yours. There is no provider SLA underneath.
  • No global edgeMulti-region failover and a worldwide CDN need to be set up separately.
  • Fewer managed servicesService bindings cover databases. Queues and other cloud services are integrated by you.

comparison

OpenRun and a DIY Kubernetes stack

compared withArgo CD / Fluxcert-manageridentity proxyCI pipelinesHelm charts
where openrun is stronger
  • One platform layerGitOps, image builds, TLS and SSO come in one tool, in place of several you integrate yourself.
  • Simple config for developersA few lines of declarative config per app, with no Kubernetes YAML or Helm charts to write.
  • Start small, grow laterRun on one node with Docker or Podman, then move to Kubernetes with the same config.
  • Ready on day oneAuth, scale-to-zero and staged releases work without building an internal developer platform.
trade-offs
  • Advanced networkingA service mesh or multi-cluster networking calls for a custom Kubernetes setup.
  • Custom operatorsApps that depend on operators and CRDs for their logic are a better fit for raw Kubernetes.
  • Fine-grained schedulingNode affinity, taints and anti-affinity rules are not exposed in the simplified config.

use cases

For teams

apps

Internal web apps

Data science and tools teams deploy framework apps with little or no config. No infrastructure setup per app.

StreamlitGradioFastHTMLNiceGUIFastAPI
ops

Operations automation

Replace Jenkins or Rundeck jobs with OpenRun Actions: scripts, maintenance tasks and runbooks behind a generated form.

runbooksmaintenanceprovisioning
apis

Secure internal APIs

Put login and audit logging in front of internal REST APIs and MCP servers without changing their code.

OAuthOIDC / SAMLaudit events
process

One way to deploy

Every team deploys through the same Git repo, so each change has history and goes through review.

pull requestsversion historystaging

use cases

For individual developers

dev

Local development

Run the same config on a laptop that runs in production. No Docker Compose files or manual networking.

localhostdev/prod parity
share

Share apps safely

Host apps for friends and family. Add a login to a hobby or AI-generated app without writing auth code.

OAuth loginside projects
homelab

Efficient homelab

Idle apps stop until the next request, which suits a Raspberry Pi or older hardware running many services.

scale to zeroRaspberry Pi
learn

Learn GitOps

Work with declarative deploys and reconciliation hands-on, without learning Kubernetes first.

declarativereconciliation

summary

Get started

openrun is a good fit when
  • You want cloud simplicity on your own hardwareContainers that build, route and scale to zero, on a server or VPS you control.
  • You prefer config in GitApps and their settings are declared in a repo and changed through commits.
  • Your apps need login and access controlSSO, RBAC and audit logs for every internal tool, without per-app work.
bash
# 1. install and start
curl -sSL https://openrun.dev/install.sh | sh
openrun server start &
# 2. sync apps from a Git repo
openrun sync schedule --approve --promote \
    github.com/openrundev/openrun/examples/utils.star
# 3. see what is running
openrun app list