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.
# 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.
Self-hosted
An alternative to Google Cloud Run and Heroku that runs on your own servers, inside your network.
Declarative
Apps are created, configured and promoted by editing a config file in Git. OpenRun reconciles the rest.
One binary
Web server, TLS, routing, auth and deployment in a single Go binary. No separate proxy or CI/CD system.
Focused
Built for web apps and internal tools. A small surface keeps the platform simple to run and to learn.
platform overview
Key features
Declarative deploys
Create, configure and promote apps by editing one file in Git. No UI clicks, no deploy scripts.
SSO and RBAC
OAuth, OIDC, SAML or client certificates in front of any app, with role-based access. No app code changes.
Service bindings
Each app gets its own database account. PostgreSQL, MySQL, SQLite and Redis are built in, more through providers.
Scale to zero
Idle app containers stop and start again on the next request. Run many apps on small hardware.
Staged releases
Changes land in a staging environment first, then promote to production with a blue-green switch.
Durable SQLite
SQLite volumes replicate continuously with Litestream to S3-compatible storage and restore after node loss.
Actions and MCP
Generated forms for backend operations. Actions also run from the CLI and are served as MCP tools.
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
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
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.
No per-app Ingress
Requests reach the OpenRun server, which routes to each app through its ClusterIP Service.
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
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 &
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
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
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.
Poll the repo
Checks the Git URL for new commits to config or source.
Load config
Reads the app declarations and fetches each app's source.
Build images
Builds from an AppSpec or the app's own Dockerfile.
Apply changes
Creates new apps and updates existing ones, staging first.
Enforce policy
Applies the configured login, access rules and audit logging.
simplicity first
The whole config, side by side
# 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)
# 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
comparison
OpenRun and managed cloud services
- 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.
- 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
- 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.
- 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
Internal web apps
Data science and tools teams deploy framework apps with little or no config. No infrastructure setup per app.
Operations automation
Replace Jenkins or Rundeck jobs with OpenRun Actions: scripts, maintenance tasks and runbooks behind a generated form.
Secure internal APIs
Put login and audit logging in front of internal REST APIs and MCP servers without changing their code.
One way to deploy
Every team deploys through the same Git repo, so each change has history and goes through review.
use cases
For individual developers
Local development
Run the same config on a laptop that runs in production. No Docker Compose files or manual networking.
Share apps safely
Host apps for friends and family. Add a login to a hobby or AI-generated app without writing auth code.
Efficient homelab
Idle apps stop until the next request, which suits a Raspberry Pi or older hardware running many services.
Learn GitOps
Work with declarative deploys and reconciliation hands-on, without learning Kubernetes first.
summary
Get started
- 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.
# 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