[Sandbox] k0s

[randybias]

Application contact emails

[email protected], [email protected]

Project Summary

k0s is a CNCF-certified lightweight, Kubernetes distribution with zero dependencies and zero opinion.

Project Description

k0s is a fully conformant, CNCF-certified Kubernetes distribution that offers a zero-dependency, statically compiled, vanilla Kubernetes experience. Designed to run anywhere—from bare metal to cloud environments—k0s provides a minimal footprint with a low attack surface. It enforces a strong separation between controllers and workers, enhancing security and operational efficiency.

k0s aligns with the CNCF mission by fostering an open-source, vendor-neutral Kubernetes distribution that emphasizes choice and flexibility within the cloud-native ecosystem. By providing diversity of choice, k0s encourages innovation and collaboration, strengthening the Kubernetes community.

Org repo URL (provide if all repos under the org are in scope of the application)

https://github.com/k0sproject

Project repo URL in scope of application

https://github.com/k0sproject/k0s

Additional repos in scope of the application

https://github.com/k0sproject/k0sctl

Website URL

https://k0sproject.io/

Roadmap

https://github.com/k0sproject/k0s/milestones

Roadmap context

In our monthly office hours and community channels, we openly discuss roadmap items, gathering input and prioritizing items through collaborative discussions. Our approach is strongly oriented towards fostering a thriving ecosystem, and we actively seek opportunities for interoperability with CNCF projects and other open-source initiatives. This commitment helps us better address the interests and needs of our community.

We are working towards a more formal roadmap.

Contributing Guide

https://github.com/k0sproject/k0s/blob/main/docs/contributors/overview.md

Code of Conduct (CoC)

https://github.com/k0sproject/k0s/blob/main/CODE_OF_CONDUCT.md

Adopters

https://github.com/k0sproject/k0s/blob/main/ADOPTERS.md

Contributing or Sponsoring Org

https://mirantis.com

Maintainers file

https://github.com/k0sproject/k0s/blob/main/MAINTAINERS.md

IP Policy

• If the project is accepted, I agree the project will follow the CNCF IP Policy

Trademark and accounts

• If the project is accepted, I agree to donate all project trademarks and accounts to the CNCF

Why CNCF?

k0s seeks to apply to CNCF in order to find a vendor-neutral home. The k0s community has seen significant adoption and has matured rapidly, recently adding additional non-Mirantis maintainers from Replicated.com. With over 7,500 weekly active clusters in the wild that average over 300+ days in age, we believe the time is right to become an official project of the CNCF.

We want to demonstrate our commitment to managing expansion in an open-source manner and ensure neutral governance for our growing community of users and contributors. The CNCF platform will serve as an additional catalyst for community adoption and encourage contributions from developers. Additionally, being a part of CNCF allows k0s to learn from other projects and actively contribute back to the cloud-native community, aligning with the maintainer's ethos.

k0s wants to establish itself as a clear alternative k8s distribution for those who want an ultra lightweight, secure, vanilla distribution that supports all x86 and ARM platforms.

Benefit to the Landscape

The CNCF ecosystem would benefit from having additional conformant k8s distributions, especially ones with a specific niche, such as k0s: lightweight, no opinion, works anywhere and on any platform.

Key Features Include:

• Different installation methods: single-node, multi-node, airgap and Docker
• Automatic lifecycle management with k0sctl: upgrade, backup and restore
• Modest system requirements (1 vCPU, 1 GB RAM)
• Vanilla upstream Kubernetes (with no changes)
• Available as a single binary with no external runtime dependencies besides the kernel
• Flexible deployment options with control plane isolation as default
• Scalable from a single node to large, high-available clusters
• Supports custom Container Network Interface (CNI) plugins (Kube-Router is the default, Calico is offered as preconfigured alternative)
• Supports custom Container Runtime Interface (CRI) plugins (containerd is the default)
• Supports all Kubernetes storage options with Container Storage Interface (CSI)
• Supports a variety of datastore backends: etcd (default for multi-node clusters), SQLite (default for single node clusters), MySQL, and PostgreSQL
• Supports x86-64, ARM64 and ARMv7
• Konnectivity service, CoreDNS, Metrics Server

Cloud Native 'Fit'

k0s is about as cloud-native as you can get, given it is basically the purest and simplest form of a k8s distribution.

Cloud Native 'Integration'

Nothing besides core Kubernetes.

Cloud Native Overlap

There is some overlap with k3s, but ultimately, we believe there is a enough difference in approach to allow both distributions in the Kubernetes ecosystem.

Here are some different perspectives from around the web for this year, comparing k0s and k3s:

• https://medium.com/@thakur.ajay/kubernets-vs-k3s-vs-k0s-32f1da81a306
• https://shipyard.build/blog/k0s-k3s-k8s/
• https://www.nops.io/blog/k0s-vs-k3s-vs-k8s/

Perhaps more importantly, here are a couple of k0s users explaining why they preferred k0s over k3s:

• Future of k0s, a CNCF project? k0sproject/k0s#3248 (comment)
• Future of k0s, a CNCF project? k0sproject/k0s#3248 (comment)

Similar projects

k3s

Landscape

Yes, k0s is listed in the landscape.

Business Product or Service to Project separation

Some Mirantis products do leverage k0s, but the project is maintained completely separately from our products and has been since inception. Originally Mirantis products used other k8s distributions, but recently migrated to k0s. A close inspection of GitHub issues will show you that there is a clear firewall between k0s and our enterprise products. Putting k0s into the CNCF will further help maintain it's independence.

Project presentations

Runtime TAG in 2021:

https://www.youtube.com/watch?v=5Hja-cGXZ5Q&ab_channel=CNCFTAGRuntime

Edge/IoT WG in 2022:

https://youtu.be/L5jWfM6kn5M?t=1695

Project champions

TBD

Additional information

We collect anonymous usage data. Attached is a screenshot of our k0s dashboard with some detailed statistics showing our accelerated growth over the past year.

k0s Dashboard.pdf

[chris-sanders]

As a representative of Replicated, I'd like to express our support for the k0s project's application to join the CNCF as a sandbox project.

1. At Replicated, we have carefully evaluated and selected k0s for our needs, and it has become an integral part of our technology stack.

2. During our selection process, we reviewed several available projects. What truly sets k0s apart is its commitment to a zero-ops approach. While there are other easy-to-install distributions like k3s, k0s uniquely defines installing, upgrading, and maintaining the cluster as core features within its scope. The built-in Autopilot feature is a prime example of this philosophy, demonstrating a distinctive approach to handling upgrades that's integrated directly into the distribution. This aligns perfectly with our goals of simplifying Kubernetes operations for our users.

3. We have already implemented k0s in production environments and are seeing great results. Our intention is to continue expanding its use within our infrastructure. We would be delighted to see k0s become part of the CNCF, as we believe this would ensure its continued growth as an open-source community project.

Given our positive experience with k0s and its unique features, we strongly support its inclusion in the CNCF and look forward to its continued development and adoption within the wider community.

[caniszczyk]

Do you have a list of third party dependencies for k0s?

[jnummelin]

@caniszczyk I'm not sure what you mean here by 3rd party dependencies?

As for any Golang project, our Golang dependencies are managed via go modules: https://github.com/k0sproject/k0s/blob/main/go.mod

The components we embed as binaries are: runc, containerd, Kubernetes (api-server, controller-manages, scheduler, kubelet), kine, etcd, iptables and keepalived
All the embedded bins are statically compiled so we can run them on all Linux OSes and thus have no separate builds or packaging for each distro. The versions for these embedded bins are declared at https://github.com/k0sproject/k0s/blob/main/embedded-bins/Makefile.variables

We also produce SBOM for all the releases: https://github.com/k0sproject/k0s/releases/download/v1.30.4%2Bk0s.0/spdx.json

As for Kubernetes itself, it still has some "3rd party" dependencies, i.e. it does call some tools on the host like mount for example.

[caniszczyk]

@jnummelin this is exactly what I need, essentially we need the runtime dependencies and their associated licenses to ensure they are compliant with CNCF's IP Policy: https://github.com/cncf/foundation/blob/main/allowed-third-party-license-policy.md

[jnummelin]

ok, I've checked the dependency data (attached in CSV format). All the golang modules adhere to the CNCF policy. Some of the embedded binaries, iptables and keepalived, are GPLv2, but IMO they go into this category from the policy:

It is either (A) stored unmodified in a designated third-party folder, or (B) not stored in the CNCF project repository and instead retrieved at installation or build time from the upstream third party repository or package repository

In this case we get the sources for those components directly from upstream repos, build them and "just" include the binary. Here is an example how we do it for iptables, all other components follow the same pattern.

k0s dependencies - Sheet1.csv

[randybias]

Per @jnummelin:

On Oct 27th k0s crossed another threshold in adoption. We crossed the threshold of seeing 400k unique¹ clusters throughout the telemetry collection period starting March 2021. Couldn't be more proud of the k0s team for making k0s what is is today and the dedication to make it better every day.

Onwards and upwards!

Footnotes

1. We determine unique clusters based on kube-system UUID as k8s uses type 4 UUIDs which makes them globally unique, or at least the chance for collisions is extremely low. ↩

[randybias]

Replicated recently shared a YouTube video with more details on their use case as well as additional k0s proof points.

https://youtu.be/95LhxbmH-t0?si=4ScS3jDQBRErX1MP

[dims]

@randybias and team, thanks for your submission! I have a couple of questions:

• Has there been organized efforts to broaden the set of folks who are regular committers? (looking at https://github.com/k0sproject/k0s/graphs/contributors?from=12%2F16%2F2023)
• Has there been examples of good back-and-forth between k0s and its upstream (k8s) on issues that matter to your end users?

thanks!