Cloud Development Kit for Kubernetes

cdk8s is an open-source software development framework for defining Kubernetes applications and reusable abstractions using familiar programming languages and rich object-oriented APIs. cdk8s apps synthesize into standard Kubernetes manifests which can be applied to any Kubernetes cluster.

cdk8s is a Cloud Native Computing Foundation Sandbox Project, built with ❤️ at AWS. We encourage you to try it out, leave feedback, and jump in to help!

Contents:

• Repositories
• Overview
• Getting Started
• Help & Feedback
• Documentation
• Examples
• Roadmap
• Community
• Contributing
• CDK8s.io website
• License

Repositories

This project consists of multiple packages, maintained and released via the following repositories:

• cdk8s - Core library. For historical reasons note that the cdk8s package is maintained in the cdk8s-team/cdk8s-core repository.
• cdk8s-cli - Command-Line interface.
• cdk8s-plus - High-Level constructs for Kubernetes core.

The current repository acts as an umbrella repository for cross module concerns, as well as the deployment of…

Kubectl

The k8s.io/kubectl repo is used to track issues for the kubectl cli distributed with k8s.io/kubernetes. It also contains packages intended for use by client programs. E.g. these packages are vendored into k8s.io/kubernetes for use in the kubectl cli client. That client will eventually move here too.

Contribution Requirements

• Full unit-test coverage.

• Go tools compliant (go get, go test, etc.). It needs to be vendorable somewhere else.

• No dependence on k8s.io/kubernetes. Dependence on other repositories is fine.

• Code must be usefully commented Not only for developers on the project, but also for external users of these packages.

• When reviewing PRs, you are encouraged to use Golang's code review comments page.

• Packages in this repository should aspire to implement sensible, small interfaces and import a limited set of dependencies.

Community, discussion, contribution, and support

See this document for how to reach the maintainers of this…

Kubernetes Operator

Open Source Tools on autopilot

Getting started »

Explore our website »

GitHub Docker Hub Artifact Hub LinkedIn

⭐️ Why Glasskube?

Turn on autopilot and deploy and manage Open Source Tools fully automated on Kubernetes. Our Open Source Glasskube Operator is the simplest and fastest way to manage all your favorite Open Source Tools and the related infrastructure components like databases, caches, and keep them up to date without manual hassle.

✨ Features

• 👌 Easy installation with little to no configuration
• ✅ Automatic setup of databases and caches
• 🔄 Automate and schedule version updates and patches
• 🗓️ Scheduled database backups
• ⚙️ Interface for simple SMTP configuration

🗄️ Table Of Contents

• Quick Start
• Supported Tools
• Screencast
• Need help?
• Related projects
• How to Contribute
• Supported by

🚀 Quick Start

The Glasskube operator is simply deployed via Helm. To install the Open Source Tool simply apply the Custom…

Helm

Helm is a tool for managing Charts. Charts are packages of pre-configured Kubernetes resources.

Use Helm to:

• Find and use popular software packaged as Helm Charts to run in Kubernetes
• Share your own applications as Helm Charts
• Create reproducible builds of your Kubernetes applications
• Intelligently manage your Kubernetes manifest files
• Manage releases of Helm packages

Helm in a Handbasket

Helm is a tool that streamlines installing and managing Kubernetes applications Think of it like apt/yum/homebrew for Kubernetes.

• Helm renders your templates and communicates with the Kubernetes API
• Helm runs on your laptop, CI/CD, or wherever you want it to run.
• Charts are Helm packages that contain at least two things
  • A description of the package (Chart.yaml)
  • One or more templates, which contain Kubernetes manifest files
• Charts can be stored on disk, or fetched from remote chart repositories (like Debian or RedHat packages)

Install

Binary downloads of the…

kustomize

kustomize lets you customize raw, template-free YAML files for multiple purposes, leaving the original YAML untouched and usable as is.

kustomize targets kubernetes; it understands and can patch kubernetes style API objects. It's like make, in that what it does is declared in a file and it's like sed, in that it emits edited text.

This tool is sponsored by sig-cli (KEP).

• Installation instructions
• General documentation
• Examples

kubectl integration

To find the kustomize version embedded in recent versions of kubectl, run kubectl version:

> kubectl version --short --client
Client Version: v1.26.0
Kustomize Version: v4.5.7

The kustomize build flow at v2.0.3 was added to kubectl v1.14. The kustomize flow in kubectl remained frozen at v2.0.3 until kubectl v1.21 which updated it to v4.0.5. It will be updated on a regular basis going forward, and such updates will be reflected in the Kubernetes release…

Flux version 2

Flux is a tool for keeping Kubernetes clusters in sync with sources of configuration (like Git repositories and OCI artifacts) and automating updates to configuration when there is new code to deploy.

Flux version 2 ("v2") is built from the ground up to use Kubernetes' API extension system, and to integrate with Prometheus and other core components of the Kubernetes ecosystem. In version 2, Flux supports multi-tenancy and support for syncing an arbitrary number of Git repositories, among other long-requested features.

Flux v2 is constructed with the GitOps Toolkit, a set of composable APIs and specialized tools for building Continuous Delivery on top of Kubernetes.

Flux is a Cloud Native Computing Foundation (CNCF) project, used in production by various organisations and cloud providers.

Quickstart and documentation

To get started check out this guide on how to bootstrap Flux on Kubernetes and deploy a…

Releases:

Code:

Social:

Argo CD - Declarative Continuous Delivery for Kubernetes

What is Argo CD?

Argo CD is a declarative, GitOps continuous delivery tool for Kubernetes.

Why Argo CD?

1. Application definitions, configurations, and environments should be declarative and version controlled.
2. Application deployment and lifecycle management should be automated, auditable, and easy to understand.

Who uses Argo CD?

Official Argo CD user list

Documentation

To learn more about Argo CD go to the complete documentation Check live demo at https://cd.apps.argoproj.io/.

Community

Contribution, Discussion and Support

You can reach the Argo CD community and developers via the following channels:

• Q & A : Github Discussions
• Chat : The #argo-cd Slack channel
• Contributors Office Hours: Every Thursday | Agenda
• User Community meeting: First Wednesday of the month | Agenda

Participation in the Argo CD project is governed by the CNCF Code of Conduct

Blogs and Presentations

1. Awesome-Argo: A Curated List of…

timoni

Timoni is a package manager for Kubernetes powered by CUE and inspired by Helm.

The Timoni project strives to improve the UX of authoring Kubernetes configs Instead of mingling Go templates with YAML like Helm or layering YAML on top of each-other like Kustomize, Timoni relies on cuelang's type safety, code generation and data validation features to offer a better experience of creating, packaging and delivering apps to Kubernetes.

Get Started

To get started with Timoni please visit the documentation website at timoni.sh.

Concepts

• Module - App definition containing Kubernetes CUE templates and configuration schema, distributed as OCI artifacts.
• Instance - App instantiation referencing the module and workloads deployed on a Kubernetes cluster.
• Bundle - App composition bundling multiple modules and…

Carvel

Carvel provides a set of reliable, single-purpose, composable tools that aid in your application building, configuration, and deployment to Kubernetes.

This is a list of repos associated with the Carvel project.

• ytt - Template and overlay Kubernetes configuration via YAML structures, not text documents
• kapp - Install, upgrade, and delete multiple Kubernetes resources as one "application"
• kbld - Build or reference container images in Kubernetes configuration in an immutable way
• imgpkg - Bundle and relocate application configuration (with images) via Docker registries
• kapp-controller - Capture application deployment workflow in App CRD. Reliable GitOps experience powered by kapp.
• vendir - Declaratively state what files should be in a directory.
• secretgen-controller - Provides CRDs to specify what secrets need to be on a cluster (generated or not).

Experimental:

• kwt
• terraform-provider-carvel

Installation:

• homebrew
• docker-image
• asdf
• setup-action

Plugins:

• ytt.vim
• vscode-ytt

Examples:

• simple-app-on-kubernetes
• ytt-library-for-kubernetes
• ytt-library-for-kubernetes-demo
• guestbook-example-on-kubernetes

See what's planned in our backlog.

Join

Pulumi's Infrastructure as Code SDK is the easiest way to build and deploy infrastructure, of any architecture and on any cloud, using programming languages that you already know and love. Code and ship infrastructure faster with your favorite languages and tools, and embed IaC anywhere with Automation API.

Simply write code in your favorite language and Pulumi automatically provisions and manages your resources on AWS Azure Google Cloud Platform Kubernetes, and 120+ providers using an infrastructure-as-code approach. Skip the YAML, and use standard language features like loops, functions, classes, and package management that you already know and love.

For example, create three web servers:

const aws = require("@pulumi/aws");
const sg = new aws.ec2.SecurityGroup("web-sg", {
    ingress: [{ protocol: "tcp", fromPort: 80, toPort: 80, cidrBlocks: ["0.0.0.0/0"

Terraform

• Website: https://www.terraform.io
• Forums: HashiCorp Discuss
• Documentation: https://www.terraform.io/docs/
• Tutorials: HashiCorp's Learn Platform
• Certification Exam: HashiCorp Certified: Terraform Associate

Terraform is a tool for building, changing, and versioning infrastructure safely and efficiently. Terraform can manage existing and popular service providers as well as custom in-house solutions.

The key features of Terraform are:

• Infrastructure as Code: Infrastructure is described using a high-level configuration syntax. This allows a blueprint of your datacenter to be versioned and treated as you would any other code. Additionally, infrastructure can be shared and re-used.

• Execution Plans: Terraform has a "planning" step where it generates an execution plan. The execution plan shows what Terraform will do when you call apply. This lets you avoid any surprises when Terraform manipulates infrastructure.

• Resource Graph: Terraform builds a graph of all your resources, and parallelizes the creation and modification of any non-dependent resources. Because of this, Terraform builds…

Website · Installation · Tutorial

Grafana Tanka

The clean, concise and super flexible alternative to YAML for your Kubernetes cluster

• 💥 Clean: The Jsonnet language expresses your apps more obviously than YAML ever did
• 📚 Reusable: Build libraries, import them anytime and even share them on GitHub!
• 📌 Concise: Using the Kubernetes library and abstraction, you will never see boilerplate again!
• 🎯 Confidence: Stop guessing and use tk diff to see what exactly will happen
• 🔭 Helm: Vendor in, modify, and export Helm charts reproducibly
• 🚀 Production ready: Tanka deploys Grafana Cloud and many more production setups

Let's kill some YAML together  ▶

🚀 Getting started

To get started, install Tanka first, and then follow the tutorial. This should get you on track quickly.

👥 Community

There are several places to connect with the Tanka community:

• GitHub Discussions: Primary support channel
• #tanka…

dhall-kubernetes

dhall-kubernetes contains Dhall bindings to Kubernetes so you can generate Kubernetes objects definitions from Dhall expressions This will let you easily typecheck, template and modularize your Kubernetes definitions.

Why do I need this

Once you build a slightly non-trivial Kubernetes setup, with many objects floating around, you'll encounter several issues:

1. Writing the definitions in YAML is really verbose, and the actually important things don't stand out that much
2. Ok I have a bunch of objects that'll need to be configured together, how do I share data?
3. I'd like to reuse an object for different environments, but I cannot make it parametric..
4. In general, I'd really love to reuse parts of some definitions in other definitions
5. Oh no, I typoed a key and I had to wait until I pushed to the cluster to get an error back :(

The natural tendency is to reach for a templating language…