[Sandbox] KSail

[devantler]

Application contact emails

[email protected]

Project Summary

An SDK for building GitOps enabled Kubernetes clusters.

Project Description

KSail is a CLI. It embeds a set of other popular CLI tools, and through its own API it uses these embedded CLI tools to provide a better developer experience to platform engineers seeking to build and operate their Kubernetes clusters without having to download and learn many many different tools.

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

https://github.com/devantler/ksail

Project repo URL in scope of application

https://github.com/devantler/ksail

Additional repos in scope of the application

Sub-projects

KSail is part of a larger ecosystem of projects that I maintain. These projects are designed to provide important functionality to KSail with high confidence, and without bloating the main repository. Most the projects provide extensible frameworks, so you can build your own tools on top of them, or make contributions to make KSail even more powerful.

• devantler/dotnet-cli-runner - An implementation atop CLI Wrap to support running different binaries from C# code.
• devantler/dotnet-container-engine-provisioner - Provisioners to provision resources in container engines like Docker or Podman.
• devantler/dotnet-key-manager - A key manager to guard your local Age keys.
• devantler/dotnet-keys - A library with key models, like the Age key model.
• devantler/dotnet-kubernetes-generator - Generators to create Kubernetes resources with ksail init and ksail gen.
• devantler/dotnet-kubernetes-provisioner - Provisioners to provision Kubernetes clusters and resources.
• devantler/dotnet-kubernetes-validator - A library that validates Kubernetes resources client-side or at runtime.
• devantler/dotnet-template-engine - A template engine to support code generation of non-serializable content.

CLI Wrappers

These projects are CLI wrappers that provide a C# API for the respective CLI tools. They are used in KSail to embed and interact with CLI tools in a type-safe manner.

• devantler/dotnet-age-cli - A library that embeds and provides an API for the Age CLI.
• devantler/dotnet-flux-cli - A library that embeds and provides an API for the Flux CLI.
• devantler/dotnet-k3d-cli - A library that embeds and provides an API for the K3d CLI.
• devantler/dotnet-k9s-cli - A library that embeds and provides an API for the K9s CLI.
• devantler/dotnet-kind-cli - A library that embeds and provides an API for the Kind CLI.
• devantler/dotnet-kubeconform-cli - A library that embeds and provides an API for the Kubeconform CLI.
• devantler/dotnet-kustomize-cli - A library that embeds and provides an API for the Kustomize CLI.
• devantler/dotnet-sops-cli - A library that embeds and provides an API for the SOPS CLI.

Website URL

https://devantler.github.io/ksail

Roadmap

https://github.com/devantler/ksail/blob/main/docs/7-roadmap.md

Roadmap context

I want KSail to work for small and large clusters. When building dind-based clusters there is a vertical scale limit. As such I plan to enable the use of Cluster API to spin up clusters on bare-metal and cloud on-demand for building and operating larger clusters. Right now this is not possible.

Furthermore, I want to ensure the tool is flexible towards many different use cases, as such all features are built against interfaces, which allow extending the tool with regards to:

• Contaner Engine
• Kubernetes distributions
• Deployment tool (GitOps primarily)
• Secrets Management

I am also very open to new ways to improve the developer experience for new or experienced platform engineers.

Contributing Guide

https://github.com/devantler/.github/blob/main/.github/CONTRIBUTING.md

Code of Conduct (CoC)

none

Adopters

No response

Contributing or Sponsoring Org

No response

Maintainers file

none

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?

I think CNCF should include a project that makes life easier for all the platform engineers out there. Learning Kubernetes is extremely challenging. It is both a complex task to understand what it does, but it does not help that trying it out is also quite complex.

Benefit to the Landscape

To my knowledge there is not solution that provides what KSail does. This is a all-bateries-included (or SDK) approach to building and operating Kubernetes clusters in local and dev environments.

Cloud Native 'Fit'

I am honestly not sure if there is a category for tools like this yet. Help me out here :-)

It embodies DevEx, Provisioning of clusters, Operating clusters, GitOps, Secrets Management and more.

Cloud Native 'Integration'

Kustomize, Flux, SOPS, Age, K3d, K9s, Kind, Kubeconform

Cloud Native Overlap

None to my knowledge.

Similar projects

None to my knowledge.

Landscape

No

Business Product or Service to Project separation

N/A

Project Domain Technical Review

No response

CNCF Contacts

No response

Additional information

It was presented at KCD2024: https://kcddenmark.dk/schedule/

[dims]

@devantler can you please speak a bit about the choice of framework/language used in KSail namely dotnet/csharp? Asking as we do not have that many projects of this nature.

Are all the repositories listed part of this submission?

[devantler]

@dims

can you please speak a bit about the choice of framework/language used in KSail namely dotnet/csharp? Asking as we do not have that many projects of this nature.

I choose .NET and CSharp for KSail for three reasons:

1. I wanted to provide a single releasable binary, and found that .NET and C# provided nice tooling for this. I can at build time define what binaries are embedded into the releasable binary, and I can furthermore compress this releasable binary, so its size is as small as the approach allows. Some of the benefits to this is, that KSail for e.g. arm64 will only contain the binaries for that architecture.
2. I wanted a good framework for building a cool CLI tool, and Microsoft is building one which worked super well for me: https://github.com/dotnet/command-line-api
3. I am fairly proficient In writing code in C# and .NET, and I was initially just building a project for myself and to make my own life easier. Naturally I then first looked into whether .NET and C# had any features to embed other binaries into a single releasable binary, which it had. I found the approach scaled well, and began extending the tool for more than just my own needs.

I have used a lot of hours on getting the tool to this stage, so I am a bit hesitant to revisit the decision, as it will likely require rebuilding the whole thing from scratch, which is a lot of work. However given some of the binaries that I embed actually exist as Go libraries, I do see the value, as it would provide a more native way to call into these tools. I am just not certain KSail should only work with Go libraries, and I kinda like the idea of being able to embed anything that is a binary. Furthermore I am unaware if Go is able to provide the same features with regard to embedding binaries and compressing the releasable binary.

Are all the repositories listed part of this submission?

TLDR; I am not sure. KSail requires these sub-projects to function, but me being the one having implemented them, is just because these libraries would not otherwise exist. I regard them as external libraries.

Context: I wanted to build KSail around the idea of providing abstractions on top of common Platform Engineering practices like:

• Cluster Provisioning
• GitOps,
• Client-side and Server-side validation
• Linting
• Kubernetes Distributions
• Container Engines

To do this in a manageable way, and to avoid locking these functionalities to only KSail, I created multiple repositories. Each repository contains projects of its own through .NET libraries. This means KSail imports these into its code, and uses the APIs of these libraries, to do all the underlying operations for e.g. provisioning a cluster in Kind, or installing flux.

This means the repository for KSail and its code, is mostly for providing the CLI and its configuration options. But KSail will call into the sub-projects, which implement the logic to do stuff.