Openrun
Internal tools deployment made easy. Deploy web apps declaratively, on a single-node or on Kubernetes.
Install / Use
/learn @openrundev/OpenrunREADME
Menu
Overview
OpenRun is an Apache-2.0 licensed open source web app deployment platform, with a focus on deploying internal tools. OpenRun makes it easy to declaratively deploy containerized web apps. OpenRun can deploy apps on a single-node or onto a Kubernetes cluster. OpenRun provides declarative GitOps based blue-green deployment, OAuth/OIDC/SAML access controls, TLS certs & secrets management. OpenRun is built for teams to easily deploy internal tools, with full RBAC support. OpenRun apps are deployed directly from the git repo, no build server required. OpenRun scales idles apps down to zero and supports atomic updates across multiple apps.
Some of the unique features of OpenRun are:
- Create and manage apps declaratively, through GitOps
- Easily upgrade from single-node to Kubernetes, with no config changes required
- Domain based or path based routing, with auto-TLS
- OAuth/OpenID/SAML/Cert based auth
- RBAC for admin operation and for app access
- Scales idle apps down to zero
- Staged deployment, for code and config changes
- Atomic (all or nothing) updates across apps
This repo hosts the source code for OpenRun. The source for the documentation site openrun.dev is in the docs folder. App specifications, which are templates to create apps, are defined in the appspecs repo. Sample apps are in the apps repo.
<img alt="OpenRun intro gif" src="https://openrun.dev/intro_dark_small.gif"/>FAQ
<details open> <summary><b>How does OpenRun compare to other deployment solutions like Coolify/Dokku/CapRover etc?</b></summary></details> <details> <summary><b>Why is declarative configuration useful?</b></summary>The main differences are:
- OpenRun is declarative. After initial OpenRun setup. Instead of using CLI commands or UI operations, all operations including creating new app and updating config for existing apps can be doing by updating a config file in Git. With most other solution, app creation/update is done manually through CLI or UI. Only app source code update can be done through Git.
- OpenRun can deploy apps on a single machine with Docker/Podman or it can deploy apps onto a Kubernetes cluster. Most other solutions do not support deployment to Kubernetes.
- OpenRun is implemented as a web server, it does not depend on external web server like Nginx/Traefik. This simplifies end-user usage and allows OpenRun to implement features like scale down to zero (for app containers) and OAuth/SAML/Cert based auth with RBAC.
- OpenRun supports features like staged deployment and automatic dev env setup which are not available in other solutions.
</details> <details> <summary><b>What types of apps can be deployed with OpenRun?</b></summary>Imperative CLI or UI operation are easy to start with, but they make it difficult to track changes and rollback updates. With a declarative config, all changes are version controlled. It is easy to create a new environment, since everything is in Git. If multiple folks are making config changes in a team, declarative systems are easier to manage.
Declarative configuration is what makes Kubernetes and Terraform useful. OpenRun brings declarative configuration to web app deployment. Instead of writing pages of YAML, each app is specified as a couple of lines of Starlark (python-like) config. For example, see utils.star.
</details> <details> <summary><b>Does OpenRun support deployment of internal tools by teams?</b></summary>OpenRun can deploy any web app which runs in a single container. OpenRun supports AppSpecs which allow zero-config deployment of frameworks like Streamlit/Gradio/FastHTML/NiceGUI/Shiny/Reflex based apps. For frameworks which have a AppSpec, no Dockerfile is required, no code changes are required in the app source code. For frameworks which do not have an AppSpec defined, a Dockerfile needs to be present in the app source repo.
OpenRun does NOT support apps which require multiple containers using Docker Compose. The target use case is internal tools talking to existing API endpoints and web apps where the database is externally managed.
</details> <details> <summary><b>How is OpenRun deployed?</b></summary>Yes, deployment of internal tools by teams is a target use case. Features which are built for this use case include:
- Declarative Config: Manage apps by declaratively in git, allowing team to do follow regular SDLC for config
- OAuth/OIDC/SAML with RBAC: Manage who can access which app using RBAC
- Audit Logs: All operations and API calls are automatically logged in audit trail
</details>OpenRun can be deployed on a single node easily (Linux, Windows or OSX), using a SQLite database for storing metadata. Docker/Podman is the only dependency. OpenRun can be deployed across multiple machines, using an external Postgres database for storing metadata.
OpenRun can also be deployed on Kubernetes using a Helm chart. On Kubernetes, OpenRun will avoid the need to setup a build system like Jenkins, CD with ArgoCD and an IDP like BackStage. Apps deployed using OpenRun are deployed as Kubernetes services, with OpenRun running as the api server/request router.
Architecture Overview
Single-Node Architecture
architecture-beta
service client(internet)[Client]
group host(server)[Node]
service openrun(server)[OpenRun Server] in host
service sqlite(database)[SQLite Metadata] in host
group cm(server)[Docker or Podman] in host
junction split in cm
service app1(server)[App1] in cm
service app2(server)[App2] in cm
client:R --> L:openrun
openrun:B --> T:sqlite
openrun:R -- L:split
split:T --> B:app1
split:B --> T:app2
Kubernetes Architecture
architecture-beta
service client(internet)[Client]
service postgres(database)[Postgres Metadata]
service registry(server)[Container Registry]
group k8s(server)[Kubernetes]
service openrun(server)[OpenRun] in k8s
group apps(server)[Deployed Apps] in k8s
junction split in apps
service app1(server)[App1] in apps
service app2(server)[App2] in apps
client:R --> L:openrun
postgres:R <-- T:openrun
registry:R <-- B:openrun
openrun:R -- L:split
split:T --> B:app1
split:B --> T:app2
Features
OpenRun can be used to:
- Deploy containerized applications, OpenRun will build and manage the container lifecycle
- Automatically generate a form based UI for backend actions
- Add OAuth/OIDC/SAML based auth and RBAC for app access
OpenRun supports the following for all apps:
- Declarative app deployment
- Atomic updates (all or none) across multiple apps
- Staging mode for app updates, to verify whether code and config changes work on prod before making them live.
- Preview app creation support, for trying out code changes.
- Support for github integration, apps being directly deployed from github code.
- Automatic SSL certificate creation based o
