278 karma · joined March 27, 2011
OpenRun allows defining your web app configuration in a declarative config using Starlark (which is like a subset of Python). Setting up a full GitOps workflow is just one command:
openrun sync schedule --approve --promote github.com/openrundev/openrun/examples/utils.star
This will set up a scheduled sync, which will look for new apps in the config and create them. It will also apply any config updates on existing apps and reload apps with the latest source code. After this, no further CLI operations are required, all updates are done declaratively. For containerized apps, OpenRun will directly talk to Docker/Podman to manage the container build and startup.
There are lots of tools which simplify web app deployment. Most of them use a UI driven approach or an imperative CLI approach. That makes it difficult to recreate an environment. Managing these tools when multiple people need to coordinate changes is also difficult.Any repo which has a Dockerfile can be deployed directly. For frameworks like Streamlit/Gradio/FastHTML/Shiny/Reflex/Flask/FastAPI, OpenRun supports zero-config deployments, there is no need to even have a Dockerfile. Domain based deployment is supported for all apps. Path based deployment is also supported for most frameworks, which makes DNS routing and certificate management easier.
OpenRun currently runs on a single machine with an embedded SQLite database or on multiple machines with an external Postgres database. I plan to support OpenRun as a service on top of Kubernetes, to support auto-scaling. OpenRun implements its own web server, instead of using Traefik/Nginx. That makes it possible to implement features like scaling down to zero and RBAC. The goal with OpenRun is to support declarative deployment for web apps while removing the complexity of maintaining multiple YAML config files. See https://github.com/openrundev/openrun/blob/main/examples/uti... for an example config, each app is just one or two lines of config.
OpenRun makes it easy to set up OAuth/OIDC/SAML based auth, with RBAC. See https://openrun.dev/docs/use-cases/ for a couple of use cases examples: sharing apps with family and sharing across a team. Outside of managed services, I have found it difficult to implement this type of RBAC with any other open source solution.
For the use case of network routing for services running in containers, OpenRun provides a simpler abstraction. It does the container management and the network proxying.
Clace is built for the use case of deploying internal tools, so it comes out of the box with CI/CD, auditing, OAuth etc. With Kubernetes, you need to glue together ArgoCD, an IDP etc to get the same.
The authorization and auditing features are designed for internal tools, any app can be deployed otherwise.
There are many deployment tools focussed on simplifying containerized apps deployment. Most of them are built as wrappers on top of Nginx/Traefik/Caddy etc. Clace is a single binary which implements a web server and an app server. This allows Clace to implement features like OAuth and atomic updates which are not possible for other solutions. Clace focuses on making it easy for teams to deploy Streamlit/Gradio/FastHTML type apps with no config required.
Clace has a imperative CLI and it has a declarative GitOps interface. For example https://github.com/claceio/clace/blob/main/examples/utils.st... is a config which defines seven apps. Using Starlark (pythonic syntax) allows easy config without the YAML insanity.
Running a command like
clace sync schedule --approve --promote github.com/claceio/clace/examples/utils.star
is all it takes to setup full GitOps, starting a background sync which creates new apps and updates existing apps with three way merge.There are many deployment tools focussed on simplifying containerized apps deployment. Most of them are built as wrappers on top of Nginx/Traefik/Caddy etc. Clace is a single binary which implements a web server and an app server. This allows Clace to implement features like OAuth and atomic updates which are not possible for other solutions. Clace focuses on making it easy for teams to deploy Streamlit/Gradio/FastHTML type apps with no config required.
Clace has a imperative CLI and it has a declarative GitOps interface. For example https://github.com/claceio/clace/blob/main/examples/utils.st... is a config which defines seven apps. Using Starlark (python like) for config allows easy config without the YAML insanity.
Running a command like
clace sync schedule --approve --promote github.com/claceio/clace/examples/utils.star
is all it takes to setup full GitOps, starting a background sync which creates new apps and updates existing apps with three way merge.Clace uses Starlark for defining apps, instead of something like YAML. https://github.com/claceio/clace/blob/main/examples/utils.st... is a config file which defines around seven apps (apps are downloaded and deployed directly from git).
Clace uses Starlark for defining app level routing rules also. This avoids the need to use a nginx like DSL for routing.
The Hypermedia based app support was added to be able to build a management dashboard for Clace itself, without going down the SPA route. It made sense to expose that for end uses to be able to build their own apps.
It has some unique features like supporting OAuth authentication for the apps, staging env for each app (code and config changes are staged before deployment), supporting declarative update, supporting hypermedia based apps natively etc.
The advantage is that new app installations cannot interfere with an existing app. I wrote more about this approach at https://clace.io/blog/webserver/
Since Clace is built for internal tools, even new app installation can be done by regular users. If the namespace is available, a new app can use that without conflicting with other apps.
This presents an alternate approach for handling web server config, providing app-level isolation.
Join Adam Jacobs, founder of System Initiative, as he explores an innovative approach to open source software (OSS) licensing and monetization. This session will dive into:
The limitations of traditional OSS licensing models
Introduction to Fair Source licensing and its principles
Balancing open collaboration with sustainable commercialization
Potential impacts on developer communities and business models
Real-world applications and case studies of Fair Source in action
Learn how Fair Source licensing aims to create a middle ground between fully open and proprietary software, potentially reshaping the OSS landscape. This presentation is essential for developers, project maintainers, business leaders, and anyone interested in the future of open source sustainability.
The solution here is more oriented towards glue code, code which strings together multiple API calls. The attempt is to provide a set -e type error handling for such code.
What I have seen is that some error handling, even if it not perfect, is better than letting errors be ignored.
Starlark has been great to build with. You get the readability of having a simple subset of python, without python's dependency management challenges. It is easily extensible with plugin APIs. Concurrent API performance is great without the python async challenges.
One challenge wrt using Starlark as an general purpose embedded scripting language is that it does not support usual error handling features. There are no exceptions and no multi value return for error values, all errors result in an abort. This works for a config language, where a fail-fast behavior is good. But for a general purpose script, you need more fine grained error handling. Since I am using Starlark for API logic only, I came up with a user definable error handling behavior. This uses thread locals to keep track of error state [2], which might not work for more general purpose scripting use cases.
[1] https://github.com/claceio/clace
[2] https://clace.io/docs/plugins/overview/#automatic-error-hand...
Settled on using Go HTML templates, Starlark and HTMX. Go has a great track record of not breaking backward compatibility. Go templates are widely used by ops teams, any breaking changes there will cause ops teams to revolt. Starlark is somewhat widely used by build systems (like Bazel), any breaking changes there will cause build engineers to rise up in arms. The HTMX 1.9 to 2.0 upgrade was also painless, no changes required in my test apps. Only change required was to update the way the websocket extension is resolved.
Allow internal tools to be built with regular frameworks, while making it easy to add gitops, SSO, secrets management etc which are required for internal tools.
I do plan to add specs for other languages. New specs have to be added here https://github.com/claceio/appspecs. New specs can be created locally also in the config, see https://clace.io/docs/develop/#building-apps-from-spec
Since HTMX was mentioned, Clace also makes it easy to build Hypermedia driven apps.