epinio: Open Source Build & Deployment

What is epinio?

Epinio is an opinionated platform that runs on Kubernetes and takes an application from code to a reachable URL in one step, built for developers who want PaaS-style workflows without learning Kubernetes operations.

What it is

Epinio is an open-source platform written in Go and licensed under Apache-2.0, distributed through a Helm chart and driven by a CLI or a Web UI. It lives in the Kubernetes ecosystem and adds the abstractions and tooling that let developers treat a cluster as a Platform as a Service. The project is tracked under the topics kubernetes and paas, with hacktoberfest marking it as a participant in that contribution program. Source, docs and release binaries sit around github.com/epinio/epinio, with documentation hosted at docs.epinio.io and the project homepage at epinio.io.

The concrete problem it solves is Kubernetes complexity. Developers may want Kubernetes for its benefits, or may be told to use it because their Ops team has chosen it, but working with it directly has a steep learning curve and doing it correctly is a full-time job. Epinio replaces the hand-written manifests, image builds and ingress wiring that a developer would otherwise assemble per application. It pushes code, containerizes it with Cloud Native Buildpacks and exposes it through a URL, so that deploying to production looks the same as deploying in development. Runtime operations become basic application actions rather than cluster administration.

Key capabilities

Deploy an application by pushing code directly, with Cloud Native Buildpacks handling the build and containerization step.
A TLS secured API server, reachable through Basic Authentication or an OIDC-based token.
Two first-class clients: the Epinio CLI and a Web UI.
CRUD operations over configurations, where a configuration can be a database, a SaaS service or an external component, created with the epinio configuration command.
Binding of configurations to applications, so external dependencies are attached as part of the app definition.
Basic application operations after a push, covering the lifecycle of an app already running in the cluster.
Helm-based installation into a namespace, with the deployment domain set through --set global.domain=mydomain.example.com.

Who uses it and how

Application developers whose Ops team has standardized on Kubernetes and who need to ship without writing manifests themselves.
Teams that want identical mechanics in development and production, keeping the deployment path the same across environments.
Groups running a single cluster with a defined ingress entry point, where per-app URLs are handed out by the platform rather than configured by hand.
Workloads in common buildpack-supported runtimes, with example applications published for Rails, Java (the Spring PetClinic), and the Paketo buildpack samples.
Contributors: the project tracks issues through a GitHub Project and expects changes to follow the contribution guide, with developer documentation covering how to build and run Epinio from a git checkout.

Getting started

Installation assumes an existing Kubernetes cluster plus an Ingress Controller and a Cert Manager. With those in place, and leaving DNS setup aside, the platform installs from the Helm repository with helm repo add epinio https://epinio.github.io/helm-charts, then helm install --namespace epinio --create-namespace epinio epinio/epinio --set global.domain=mydomain.example.com. The CLI comes either from the release page binary or from brew install epinio.

How it compares

This registry entry provides no list of paid products that Epinio replaces, and no directly comparable self-hosted tools are named in the supplied facts either. It therefore stands alone in this registry on the evidence available, with its positioning defined by the PaaS abstraction it layers over Kubernetes rather than by any named competitor.

When to use it — and when not to

A self-hoster must already operate a Kubernetes cluster, an Ingress Controller and a Cert Manager, and must handle DNS setup separately; Epinio does not supply those. Anyone without a cluster, or unwilling to run those three dependencies, should not start here, and teams that need fine-grained control over their own manifests may find the opinionated model restrictive. The facts also show a governance transition worth noting: copyright moved from SUSE, LLC for 2020-2024 to Krumware LLC from 2025 onward.

project readme (upstream, from github) — read inline

Epinio

Opinionated platform that runs on Kubernetes to take you from Code to URL in one step.

What problem does Epinio solve?

Epinio makes it easy for developers to develop their applications running in Kubernetes clusters. Easy means:

No experience with Kubernetes is needed
No steep learning curve
Quick local setup with minimal configuration
Deploying to production the same as deploying in development

Kubernetes is the standard for container orchestration. Developers may want to use Kubernetes for its benefits or because their Ops team has chosen it. In either case, working with Kubernetes can be complex depending on the environment. It has a steep learning curve and doing it right is a full-time job. Developers should spend their time working on their applications, not doing operations.

Epinio adds the needed abstractions and tools to allow developers to use Kubernetes as a PaaS.

Documentation

Documentation is available at docs.epinio.io.

Installation

Requires a Kubernetes cluster, an Ingress Controller and a Cert Manager as explained in the installation documentation. Once this is in place, and leaving out DNS setup, an installation reduces to:

helm repo add epinio https://epinio.github.io/helm-charts
helm repo update

helm install --namespace epinio --create-namespace epinio epinio/epinio \
  --set global.domain=mydomain.example.com

CLI installation

Installation of the Epinio CLI is by downloading a binary from the release page, or usage of brew, i.e.

brew install epinio

There is further documentation here.

Quick Start Tutorial

Our QuickStart Tutorial works through how to create a namespace and push an application.

Reach Us

Slack: #epinio on Rancher Users
Github: Discuss

Contributing

Epinio uses Github Project for tracking issues.

Find more information in the Contribution Guide.

The developer documentation explains how to build and run Epinio from a git source checkout.

Features

Security
- TLS secured API server
- Basic Authentication to access the API
- or OIDC-based token
Epinio Clients
- Web UI
- Epinio CLI
Apps
- Push code directly without further tools or steps
- Basic operation of your application once pushed
- Cloud Native Buildpacks build and containerize your code for you
Configurations
- CRUD operations on your configuration. A configuration can be a database, SaaS etc. A configuration can be an external component or can be created using epinio configuration.
- Bind configurations to apps.

Example apps

Rails: https://github.com/epinio/example-rails
Java: https://github.com/spring-projects/spring-petclinic/
Paketo Buildpack example apps: https://github.com/paketo-buildpacks/samples

License

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Breaking Changes & Migrations

1.12 to 1.13

Epinio 1.13 rehomes configurations for the staging workloads to a more standardized format that supports a larger variety of configs. These are no longer configured directly on the Epinio container via ENV variables or through Viper CLI flags but rather read from an in-cluster ConfigMap at staging time.

To summarize, version 1.12 referenced the following ENV variables:

STAGING_SERVICE_ACCOUNT_NAME
STAGING_RESOURCE_CPU
STAGING_RESOURCE_MEMORY
STAGING_RESOURCE_DISK

These ENV variables were configured directly by the Helm Chart in the deployment's env section. This is no longer the case as we push in the direction of improving configurability of these staging workloads. These configurations are now more expansive, including resource requests vs. limits, node tolerations, affinity criteria, etc. And as such, the ENV approach to this would become unruly as capabilities grew. Instead, we are conforming more closely to how Kubernetes would structure these configs directly in the Job YAML. These configurations are now read in from chart values into the stage script ConfigMaps. The contents of this ConfigMap, as far as the Epinio Server is concerned, would resemble the following (with examples):

serviceAccountName: "epinio-server"
ttlSecondsAfterFinished: 300
resources:
  requests:
    cpu: "200m"
    memory: "1Gi"
  # limits:
  #   cpu: ""
  #   memory: ""
storage:
  cache:
    emptyDir: false
    size: 1Gi
    storageClassName: ""
    volumeMode: Filesystem
    accessModes:
    - ReadWriteOnce
  sourceBlobs:
    emptyDir: true
    # size: 1Gi
    # storageClassName: ""
    # volumeMode: Filesystem
    # accessModes:
    # - ReadWriteOnce
nodeSelector: {}
  # kubernetes.io/os: linux
affinity: {}
  # nodeAffinity:
  #   requiredDuringSchedulingIgnoredDuringExecution:
  #     nodeSelectorTerms:
  #     - matchExpressions:
  #       - key: kubernetes.io/os
  #         operator: In
  #         values:
  #         - linux
tolerations: []
  # - key: "kubernetes.io/os"
  #   operator: "Equal"
  #   value: "linux"
  #   effect: "NoSchedule"

Frequently asked questions

Is epinio free to use?

epinio is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does epinio do?

Opinionated platform that runs on Kubernetes, that takes you from App to URL in one step.

What is epinio written in?

epinio is primarily written in Go. Its source is publicly available at https://github.com/epinio/epinio, and it has 606 GitHub stars.