DEV Community: Gianni Carafa

Kubero vs Coolify

Gianni Carafa — Mon, 20 Jan 2025 16:08:24 +0000

In the evolving landscape of Platform as a Service (PaaS) solutions, developers seek platforms that streamline application deployment and management. Coolify and Kubero are both open-source, self-hosted PaaS platforms catering to this need. While both offer robust features, Kubero distinguishes itself with several advanced capabilities that provide a competitive edge.

Kubero

Kubero is a PaaS tailored specifically for Kubernetes environments, emphasizing simplicity and scalability for deploying 12-factor applications. It supports multiple languages and frameworks through buildpacks, including PHP, Ruby, Golang, Rust, Node.js, and Deno. Kubero offers seamless GitOps integration with various repositories, built-in CI/CD pipelines, and a comprehensive CLI for cluster management. Notably, it provides features like autoscaling, vulnerability scanning with Trivy, a web console for application maintenance, and customizable notifications.

https://www.kubero.dev

Coolify

Coolify positions itself as an open-source alternative to platforms like Heroku, Netlify, and Vercel. It supports a wide range of programming languages and frameworks, enabling developers to deploy static websites, APIs, backends, databases, and various services. Deployment is flexible, accommodating any server with SSH access, including personal servers, VPS, Raspberry Pi, and cloud providers like AWS and DigitalOcean. Key features include push-to-deploy via Git integration, automatic SSL certificate management, real-time terminal access, and monitoring capabilities.

https://www.coolify.io

Key Differences

Infrastructure

Kubero is inherently designed for Kubernetes, leveraging its orchestration capabilities for scalability and resilience. In contrast, Coolify currently lacks native Kubernetes support, which limit scalability for enterprise applications.

Autoscaling and Resource Management

Kubero's autoscaling features allow applications to scale horizontally and vertically based on demand, optimizing resource utilization. Additionally, it offers "sleeping containers" that pause inactive pods to conserve resources. Coolify does not provide comparable autoscaling capabilities.

Metrics and Monitoring

Kubero excels in providing detailed application-level metrics, giving developers real-time insights into the performance and behavior of their deployed apps. This includes data such as response times, request counts, and resource usage specific to applications. In contrast, Coolify limits its monitoring capabilities to system-level metrics, such as server resource utilization (CPU, RAM, and disk). For teams requiring deeper application performance insights to optimize and troubleshoot effectively, Kubero stands out as the superior choice.

Security and Compliance

Security Measures: With integrated vulnerability scanning using Trivy, Kubero proactively identifies security issues in images and repositories, enhancing application security. Coolify lacks a built-in vulnerability scanning feature.

Enterprise grade Add-ons

Both Coolify and Kubero provide a variety of addons, allowing developers to integrate essential services such as databases and caching systems. However, Kubero goes a step further by deploying these addons as highly available clusters, ensuring redundancy and resilience. For example, services like Redis-Cluster, PostgreSQL, and Elasticsearch can be deployed with built-in high availability, making Kubero a more reliable choice for mission-critical applications. In contrast, Coolify's one-click service deployments are limited to standalone instances, which may not meet the demands of enterprise-level applications.

Community and Ecosystem

Coolify boasts a significantly larger and more active community, offering developers access to a wealth of shared knowledge, quick responses to questions, and collaborative support. This vibrant community can be a valuable resource, especially for smaller teams or individual developers.

However, Kubero leverages the vast and well-established Kubernetes ecosystem, which provides unparalleled flexibility, scalability, and a wealth of tools, plugins, and integrations. By being Kubernetes-native, Kubero allows developers to tap into a broader ecosystem of expertise and innovation that aligns with industry standards for cloud-native development. While Coolify’s community is an advantage, Kubero’s alignment with Kubernetes ensures it benefits from a much larger and continually evolving ecosystem.

	Kubero	Coolify
User Interface	✅	✅
CLI	✅	✅
API	✅	✅
Multi user	✅	✅
Teams	❌	✅
SSO Oauth2	✅	✅
Role Based Permissions	❌	✅
Vertical Scaling	✅	❌
Horizontal Scaling	✅	❌
Autoscaling	✅	❌
Sleeping Dynos/Pods	✅	❌
Cronjobs	✅	✅
Dark/White Mode	✅	❌
Environment variables	✅	✅
Application Metrics	✅	❌
Basic Auth	✅	❌
Writable Volumes	✅	✅
DB-Backups	❌	✅
Free SSL Issuing	✅	✅
Web Console Access	✅	✅
Web Logs Access	✅	❌
Push to Deploy	✅	✅
Pull-Request-Apps	✅	✅
Run Container Images	✅	✅
CI/CD	✅	✅
Buildpacks	✅	✅
Dockerfiles	✅	✅
Nixpacks	✅	✅
Runpacks	✅	❌
Activity Logs (Audit)	✅	✅
Realtime App Logs	✅	✅
Historic Metrics	✅	✅
Webhooks	✅	✅
Notification	✅	✅
Vulnerability scans	✅	❌
Templates (16.01.25)	155	216
GitOps with Github	✅	✅
GitOps with GitLab	✅	✅
GitOps with Bitbucket	✅	✅
GitOps with Gitea	✅	✅
GitOps with Gogs	✅	✅
Add-On PostgreSQL	✅	✅
Add-On MySQL	✅	✅
Add-On RabbitMQ	✅	❌
Add-On MongoDB	✅	✅
Add-On ElasticSearch	✅	❌
Add-On Memcached	✅	❌
Add-On Kafka	✅	❌
Add-On CouchDB	✅	❌
Add-On CockroachDB	✅	❌
Add-On Clickhouse	✅	✅
Add-On DragonFly	❌	✅
Add-On MariaDB	❌	✅
Add-On KeyDB	❌	✅

Conclusion

Coolify and Kubero are both similar open-source PaaS solutions. With its seamless Kubernetes integration, robust CI/CD pipelines, advanced autoscaling, enhanced security through vulnerability scanning, and support for highly available clusters, Kubero delivers the scalability, reliability, and flexibility modern developers need. Its ability to provide detailed application metrics and deploy high-availability addons ensures a superior experience for teams handling complex or mission-critical projects. For those seeking a future-proof platform tailored to enterprise-grade needs, Kubero might be the better fit.

How to deploy your App to Kubernetes in 14 seconds

Gianni Carafa — Mon, 09 Jan 2023 06:47:56 +0000

Sounds crazy, right? At the end of this article, I will prove with a video that this is possible. What we want to achieve is to see our code as fast as possible running in Kubernetes after we've pushed it to our GIT-Repository.

But let's first have a look at a traditional deployment:

➡️ Push your changes to the repository to trigger a build job
1) Buildcontainer starts and installs all requirements
2) Fetch the code on the Buildcontainer
3) Build the actual software
4) Build the Docker image
5) Push the Docker image
6) Trigger an update on Kubernetes (ArgoCD or similar)
7) Pull the new build Image
8) Run the new image and wait for the health check to come up.

Seems like a lot of work. This means a lot of time passing by and a lot of potential failures in this chain.

How about just keeping the essential steps:
➡️ Push your changes to the repository to trigger a webhook
1) Fetch the Code
2) Build the actual software
3) Run the Code.

That's exactly how Kubero works.

Kubero is an free and open-source PaaS for Kubernetes. It comes with a UI, API, and CLI and connects directly to your GIT repository. Therefore it is also possible to automatically start a preview instance within 14 seconds.

But there are even more benefits: Kubero uses official maintainer images to build and run the code. No need to write and maintain a Dockerfile.

The maintenance of the CI/CD pipeline is also eliminated since all these tasks are performed by Kubero. Kubero itself is automatically maintained as it is an operator with a single UI-Container.

But you might be wondering what happens when there are hundreds of pods running in production. Building the app for every running pod is not efficient. Thats why Kubero supports running pre built images too.

And finally the proof:

The simplest way to run your own Heroku on Kubernetes

Gianni Carafa — Mon, 28 Nov 2022 09:06:09 +0000

In this tutorial, we will spin up a Kubernetes Kind Cluster and install Kubero on it. Kind is an easy way to build knowledge in the field of Kubernetes and since it runs on your local machine it does not incur any costs.

Kubero is a PaaS for Kubernetes, which claims to have the most similar workflows to Heroku.

It comes with a UI, API, and CLI
It is 100% open source.
It has automatic deployments and reviewapps
Supports any language and framework

You will find a detailed explanation of Kubero in the first part here

What you will need for this tutorial:

kubectl installed
kind installed

1) Install the Kubero CLI

Download, unpack and install the Kubero CLI binary from the Github release Page

2) Run the install command



kubero install

You will now be guided thru the installation steps:

Install Kind (or Linode, GKE, DigitalOcean, Scaleway)
Install OLM
Install Ingress
Install Kubero

If it fails at some point, don't worry. Just restart the installer and skip the first step "Kubernetes Installation" part.

This is an image of the full installation process.

But let's walk thru the single steps.

The green value is the suggested default. If this fits your needs and preferences, just hit "enter".

2.1 Binaries check

The installer will first check if the required binaries are available.

2.2 Kind installation

For this tutorial we want to install Kind. So we need to say "y" here. But if you already have a cluster you want to use, just skip this part. Make sure you have selected the right context.
-> select "y"
-> name your cluster
-> select an available HTTP Port
-> select an available HTTPS Port

The Kind installation may take about a minute or two. The kubectl connection information and credentials are being exported by kind automatically.

2.3 Check the Kubernetes Cluster

Just to be sure for the next steps, let's check which Kubernetes context is selected.

2.3 Install OLM

OLM (Operator Lifecyle Manager) is a component of the Operator Framework, an open source toolkit to manage Kubernetes native applications, called Operators, in a streamlined and scalable way.
-> select the latest release "0.22.0"

2.4 Install NginX Ingress

Our new Kind cluster needs Ingress to expose running services in our cluster. We now need to select the provider. For this tutorial, is "kind" the right choice.
-> select "y"
-> select "kind"

2.5 Install Kubero Operator

Now we need our Operator. The Operator is required to deploy all Kubero pipelines and apps.
-> select "y"

2.6 Install the Kubero UI

We need this since the CLI talks to the API, which is installed with the UI. You don't need the UI Container if you plan to deploy your apps only by kubectl, which is possible, since every pipeline and app is a common Kubernetes Custom Resource Definitions.
-> select "y"
-> add a random string for the webhook secret. This will be used, to make sure only your webhooks are allowed to talk with your Kubero.
-> add a random string for the session key.
-> Add your github personal access token. We ned this create webhooks and add deployment credentials.

3) Accessing the UI

You should now be able to access the Kubero UI with the provided URL and credentials. The misspelled lacolhost.com domain points always to your localhost.

Let me know here in the comments if something fails or open issue in the main Kubero repository.

Comparing selfhosted Heroku alternatives

Gianni Carafa — Mon, 07 Nov 2022 09:50:02 +0000

First a disclaimer: I have built my own alternative, Kubero, which is part of this article.

Heroku is a well known and solid PaaS provider. It is very easy to deploy a web application and the pricing starts very low (they just canceled the free plan tough). Not so well known are their enterprise and private space plans which can become quite pricy.

But the good thing is that some open-source projects were launched during the last few years to replace Heroku on a self-managed infrastructure, like Google, AWS, or an even server rack in your basement.

There are already excellent articles to list and introduce these projects. But they are not comparing them against each other.

It is important to point out, that a missing feature does not always have to be negative but in many cases, this comes with less complexity. And it is not my intent to rate any of these great projects.

Not part of this comparison are the hosted PaaS competitors of Heroku like netlify or platform.sh and licenced/closed source projects.

I did not install all the tools but did my best to look up the docs, issues, and roadmaps. If I misinterpreted something, please let me know in the comments, and point me to where you have found the information.

These projects are being compared

Kubero https://github.com/kubero-dev/kubero
Coolify https://coolify.io/
Caprover https://caprover.com/
Dokku https://dokku.com/
Piku https://github.com/piku/piku
Cuber https://cuber.cloud/
Acorn https://github.com/acorn-io/acorn

Scroll right to see the full list

	Heroku Private Space	Kubero	Coolify	Dokku	Caprover	Piku	Cuber	Acorn
User Interface	✅	✅	✅	❌ PRO	✅	❌	❌	❌
Multi User	✅	✅	✅	✅	❌	N/A	N/A	N/A
Kubernetes	N/A	✅	❌	❌	❌	❌	✅	✅
Multi Kubernetes	N/A	✅	❌	❌	❌	❌	❌	❌
Scaling	✅	✅	❌	❌	✅	vertically	❌	❌
Autoscaling	✅	✅	❌	❌	❌	❌	❌	❌
Cronjobs	✅	✅	❌	✅	❌	✅	✅	✅
CLI	✅	✅	❌	✅	✅	✅	✅	✅
API	✅	✅	❌	❌ PRO	✅	❌	❌	✅
Autodeployment	✅	✅	✅	❌	✅	❌	❌	❌
Pull-Request-Apps	✅	✅	✅	❌	❌	❌	❌	❌
Dataclips	✅	❌	❌	❌	❌	❌	❌	❌
CI/CD	✅	✅	✅	✅	❌	✅	❌	❌
Builtin Addons	✅	✅	✅	plugin	✅	❌	❌	❌
Builtin Services	✅	❌	✅	❌	✅	❌	❌	❌
Any language	✅	✅	✅	✅	✅	✅	✅	✅

User interface

The app needs to be easy to use. It should be possible to deploy an app with a view clicks. The user should be able to see the status of the app and the logs.

Multi User

The app should be able to handle multiple users. Each user should be able manage applications.

Kubernetes

Kubernetes has benefits like metrics, logmanagement, autoscaling and immutable infrastructure (restarts when the app crashes).

Multi Kubernetes

It should be possible to deploy its apps to multiple different Kubernetes clusters.

Scaling

The app should be able to scale apps horizontally and vertically.

Auto scaling

The app should be able to auto scale apps horizontally and vertically based on the load.

Cron jobs

The app should be able to run timed cron jobs periodically.

CLI

The app should have a CLI to manage the running applications.

API

The app should have an API to manage the running applications.

CI/CD

The app should be able to deploy apps from git repositories.

Autodeployment

The app should listen to git pushes on a branch (webhooks)

Pullrequest Apps

Tha app should automaticly start a new app for every pull request.

Built in addons

The app should have built in addons like databases, caches, queues, etc.

Built in Services

The app should have built in services like Wordpress, Nextcloud, CachetHQ, etc.

Any language

The app should be able to build and run any language.

Replace Heroku with Kubero on Kubernetes (part 1)

Gianni Carafa — Mon, 31 Oct 2022 12:04:32 +0000

Hi my name is Gianni and I built another open source replacement for Heroku.

As a developer i fell in love with Heroku many years ago (2012). It was always easy to use, flexible, feature complete an had a very low price tag. But in may 2022 they had this major incident, which blocked all dev teams in our company.

Short after, Bob Wise, announced to discontinue the free tier on their platform.

All this led me, to start my own project and build a Heroku clone for Kubernetes. Yes, I know, there are already a lot other very nice tools in this spot. But I wanted a more developer friendly approach with a nice UI, CLI (Work in progress) and most important Kubernetes native.

Kubernetes has already everything builtin related to scalability(HPA) and resilience. The concept of Operators is similar to the Heroku addons. But a new App should be configured and deployed within minutes not days. Writing stable Helm charts requires a deep understanding of Kubernetes.

Another important part was the workflow: We all want to push our work, wait a moment, and see how our work runs in the cloud. So we want to connect our app with a repository and listen to git pushes and pull-requests.

What is Kubero

https://github.com/kubero-dev/kubero

Kubero is basically an operator with a UI and API. There are 2 Custom resources, which are necessary for your app:

Pipelines, defines namespaces and git repository connection
Apps, defines your application and addons

The Kubero UI is a single container application, storing all data in the Kubernetes API. Therefore it is possible to modify all resources directly with the your kubectl without having any conflicts.

Kubero is able to deploy prebuilt images, but the bigger benefit comes with the integrated build pipeline. The deployment has 3 stages: fetch -> build -> run. I call them buildpacks, although no images are build, to keep the analogy to Heroku. Every step has a public image maintained by the publisher. These "buildpacks" are easy customizable and extendable for special requirements. Due to this flexibility it is possible to deploy every code, framework and language, which runs in a single container.

We are a Github company, so we had no issue with the fact, that Heroku connects only to Github. But why not connect to other great repositories? So I added Gitea and soon Gitlab, Bitbucket and OneDev.

Authentication

Same with authentication: there is built in method for very small teams. But it is also possible to use oAuth2 and Github.

Addons

When it comes to Addons, things are getting a bit more complicated: Every Addon has its own complexity when running on a Kubernetes cluster. Some require to deploy several CRD's. Others have finalizers to handle when deleted.

What about more complex application or missing addons? Since it is plain Kubernetes, it possible to use traditional Helm or Operator deployments within your Kubero managed namespace.

Whats next in Kubero

I am currently working on the stability of Kubero. I run it on my local Kind cluster and GKE.
There is a documentation, but far from complete.
A CLI, written in Golang and comparable with Heroku-CLI, is on the way. But this will still take some time.
I will add some more simple addons to the Operator, which are not clustered but easier to handle.

So if you want to use it, I am more than happy help. Don't hesitate to open issues or discussions. Ideas, feature requests and contributions are very welcome.

My next posting (Part 2) will guide you through the Kubero Kubernetes installation. Leave in the comments if you prefer GKE oder Digital Ocean