Kubernetes PaaS

What a Kubernetes PaaS is, and when a team needs one

A Kubernetes PaaS is a platform as a service that runs applications on a standard Kubernetes cluster, often one in your own cloud account. Developers push code and get a running application, and nobody on the team has to write Kubernetes configuration to get there. This page explains the category, compares it with the other ways teams run applications, and says when each of them is the better choice.

The category

The workflow of a PaaS on a cluster you can own

A platform as a service takes source code and returns a running application. It builds the code, releases it, gives it an address, and keeps it running. The first platforms of this kind ran everything on their own infrastructure, and the customer never saw a server.

Kubernetes changed what that infrastructure can be. It is open-source software for running containers that the large cloud providers offer as a managed service and that also runs on a single rented server. A Kubernetes PaaS keeps the workflow of a PaaS and puts it on such a cluster, so where the application runs becomes a choice the team can change.

The platform exists because a cluster alone is not something you can deploy to. Kubernetes schedules containers and restarts them when they fail. Building images, routing traffic, issuing certificates, backing up databases, separating staging from production, and upgrading the cluster are left to whoever runs it. A Kubernetes PaaS is that missing layer, delivered as a product instead of built in-house.

Two things define it

  • The workflow of a PaaS

    Developers connect a repository and get a running application with an address. Day-to-day work happens in the platform, without writing Kubernetes configuration by hand.

  • A standard cluster underneath

    The application runs as ordinary Kubernetes workloads on a cluster that can sit in your own cloud account or on your own server, instead of on a runtime only the vendor operates.

Kubernetes and PaaS are not the same thing

Is Kubernetes a PaaS?

No. Kubernetes runs containers that have already been built and described to it. It does not turn source code into a running application, and its own documentation says it is not a traditional, all-inclusive PaaS and neither deploys source code nor builds applications. What it offers is the foundation a platform can be built on.

Kubernetes vs PaaS: what is the difference?

They sit at different levels. A PaaS is a service you hand code to, and it makes the decisions about building, releasing, and running that code. Kubernetes is a system you hand finished containers and instructions to, and every one of those decisions stays with you. One gives up choice for convenience, the other keeps the choice and the work.

Is Kubernetes IaaS or PaaS?

Neither. Infrastructure as a service rents out machines, disks, and networks. Platform as a service runs applications from source code. Kubernetes sits between the two: it turns a group of machines into one place to run containers, a layer often called containers as a service. A Kubernetes PaaS adds the platform layer on top of it.

The alternatives

Four ways to run applications, and what each is good at

A team choosing how to run its applications is choosing how much of the platform to own. None of the four is wrong. They differ in who does the work between the code and the running application, and in how much say you keep over where it runs. For the operations work that is left after the choice, see what NoOps means.

A managed Kubernetes service on its own

A cluster from a cloud provider, used directly with tooling the team chooses.

What you get
A Kubernetes cluster in your cloud account. The provider runs its control plane and supplies the machines it runs on.
Good at
Control. Anything that runs in a container fits, and every part of the setup can be chosen and tuned.
The trade-off
Everything between the cluster and a release is yours to assemble: build pipelines, an image registry, traffic routing, certificates, monitoring, backups, and access for developers.
Choose it when
The team has Kubernetes experience and time to spend on it, or runs workloads unusual enough that a platform’s conventions would get in the way.

A classic PaaS that hides the infrastructure

A hosted platform that runs your code on its own infrastructure and keeps that infrastructure out of sight.

What you get
Somewhere to push code. The platform builds it and runs it, and there is no cluster or server for you to look after.
Good at
Speed at the start. A small team can ship a web application without anyone taking on operations.
The trade-off
The platform decides where the application runs, which databases come with it, and how its network is arranged. Moving away means setting up deployment again somewhere else.
Choose it when
The application fits the platform’s model, and where it runs is not a requirement from customers, auditors, or the budget.

An internal platform built from separate tools

A cluster plus tools the company selects and connects itself, usually looked after by a platform team.

What you get
A platform shaped to one organization: its pipelines, its deployment rules, its security policies, and often its own portal for developers.
Good at
Fit. Nothing is a compromise with a vendor’s opinion, and each part can be replaced without touching the others.
The trade-off
The platform becomes a product the company owns. It needs engineers to build it, to keep its parts upgraded together, and to support the developers who use it.
Choose it when
The organization is large enough for a platform team to pay for itself, or has requirements that no product meets.

A Kubernetes PaaS

A product that supplies the platform layer on top of a standard cluster.

What you get
The path from a repository to a running application, on a cluster that can stay in your own cloud account or on your own server.
Good at
Ownership without the build. The infrastructure and its bill can remain yours, while releases, routing, and upgrades arrive ready to use.
The trade-off
You accept the platform’s way of describing and deploying applications, and you still pay for a cluster and decide how large it is.
Choose it when
You want applications on infrastructure you control and do not want to staff a platform team to get there.

The decision

When a Kubernetes PaaS is the right choice, and when it is not

It fits when

  • Your applications have to run in your own cloud account or on your own servers, because of compliance, data location, cloud credits, or cost, and you have no engineers to spare for building a platform.
  • You are outgrowing a hosted platform: the bill rises faster than the traffic, or the application needs a service, a region, or a network setup the platform does not offer.
  • You already run Kubernetes, and the people who should be shipping features spend their weeks on pipelines, certificates, and upgrades.
  • You run many applications, for several products or for clients, and want all of them deployed and maintained the same way.

You do not need one when

  • You have one small application or a static site. A hosted platform or a single server is simpler and cheaper than any cluster.
  • You have a platform team and an internal platform your developers are happy with. Replacing it would buy little.
  • You need direct control over how Kubernetes itself is configured, beyond what a platform exposes. Work with the cluster directly.
  • Your application is a set of short-lived functions that should cost nothing while idle. A serverless platform matches that shape better.

Wodby

How Wodby does it

Wodby is a Kubernetes PaaS. This is the short version, and each link leads to the page that covers the subject in full.

  • You decide where the cluster lives

    Wodby creates a managed Kubernetes cluster in your own cloud account, installs Kubernetes on a server you rent or own, or operates the cluster for you on Wodby Cloud. Applications are deployed the same way on all three.

  • The platform layer comes with the cluster

    When a cluster is created, Wodby deploys what it needs to receive traffic and report metrics, and later upgrades Kubernetes and that infrastructure from the same place. Builds run in the built-in CI or in the CI service you already use.

  • Applications are described as stacks

    A stack is a blueprint listing the services an application needs, such as a runtime, a database, and a cache. Wodby publishes the stacks, services, and Helm charts it maintains on GitHub, and a service missing from the catalog can be created from a Helm chart.

Questions

Common questions about the category

Is a Kubernetes PaaS the same as managed Kubernetes?
No. Managed Kubernetes is a cluster whose control plane a cloud provider runs for you. A Kubernetes PaaS is the layer above it that builds, releases, routes, and maintains applications. Many Kubernetes PaaS products deploy to a managed Kubernetes service, so the two are used together more often than one replaces the other.
Do developers need to know Kubernetes to use one?
Not for daily work. Deploying, reading logs, adding a domain, and changing a setting all happen in the platform. It still helps when one person on the team understands the basics, such as nodes and resource limits, because those decide how large the cluster has to be and explain most capacity problems.
How is it different from an internal developer platform?
An internal developer platform is built by a company’s own platform team for its own developers. A Kubernetes PaaS fills the same role as a finished product with fixed opinions. The first fits the organization exactly and has to be maintained by it; the second is ready on the first day and asks the team to work its way.
Can a team move off a Kubernetes PaaS later?
More easily than off a platform that owns the infrastructure, in one respect: a cluster in your own account, and the data on it, stay where they are. What has to be replaced is the workflow around them. Before choosing a product, check that the cluster lives in an account you own and that the definitions it deploys from can be read outside the product.
Is there an open-source Kubernetes PaaS?
Yes. Some are open-source software that you install on your own cluster and keep running yourself. Others are hosted services that connect to your cluster, and some of those publish what they deploy, such as application templates and Helm charts, while the service itself stays closed. The first kind has no license fee and is one more system for the team to maintain; the second kind is the reverse.

Get started

Judge the workflow on a real cluster

A demo cluster on Wodby Cloud is free and temporary: enough to deploy a stack and see what the platform does for you.