Hello and welcome to KubeCon.
We hope you're learning a lot
about the Kubernetes ecosystem.
We thought we'd share some open-source tools to
help you on your Cloud-native adventure.
Let's start with a graduated CNCF project.
Helm is the package manager for Kubernetes,
it's one of the most frequently used CNCF projects,
and you can use it to install and manage
software on your Kubernetes clusters
with a single command.
Lots of exciting news in Helm ecosystem right now.
Lots of changes, and you don't want
any interruption in your availability.
All Helm users should look at the Helm blog today.
The Krustlet project launched
a few months ago with two goals.
One, make it easy to deploy
WebAssembly workloads on Kubernetes,
and two, show how to build
an architectural pieces of Kubernetes in other languages.
Most programs written for Kubernetes are written in Go,
Krustlet is written in Rust.
The result, cleaner and
more manageable and easily extensible code
with Rust compiler safety benefits.
Krustlet is not intended to
replace the Kubelet, when run together,
clients can run both
traditional Linux container workloads
and WebAssembly workloads in the same cluster.
Applications written in WebAssembly
can communicate with applications
compiled in Linux containers and both types
of workloads can interact with the rest of the cluster.
Dogs, cats living together,
hopefully no mass hysteria.
This is Akri,
think of it as a plug-and-play for Kubernetes.
You name it, Akri finds it, you use it.
I'm interested in what kind
of exciting edge conditions,
no pun intended we can uncover.
The ever-popular service mesh,
everyone wants one and then they
realize how much work it might be.
There's a complexity tax.
OSM is a lightweight service mesh built
on envoy that implements SMI.
It's a CNCF sandbox Project.
It ships with a CLI.
You can install very simply,
onboard your applications and
see what service mesh can do for you.
Service Mesh Interface,
also a CNCF sandbox project,
is the specification that provides
a standard interface for service meshes and Kubernetes,
with a basic feature set for
the most common service mesh use cases.
The flexibility to support
new service meshes and
room for the ecosystem to innovate.
If you're looking for tooling like
the progressive deployment tool flagger,
it uses SMI under the hood,
to program all these different service meshes.
Mesh interoperability, gives end users more choices.
Next up we have Gatekeeper,
It's a tool for those who want to
build policy on Kubernetes,
built on open policy agent.
Gatekeeper allows you to create user-defined policy,
to ensure that Kubernetes resources are compliant.
Like restricting
which container images can be launched,
or ensuring that resources have memory and CPU limits,
or that your load balancers have only
local IPs instead of being on the public Internet.
Gatekeeper v3 is at
a stable release and is recommended for production use.
Open policy Agent,
the parent project for Gatekeeper,
is a CNCF graduated project,
so pretty well established.
There are other great tools in
this project like Comp Tensed,
great for your CI/CD pipelines
and an OPA plugin for VS Code.
Next up we have Porter,
the friendlier Cloud Installer.
Which allows you to declaratively define
an application and its dependencies
into one bundle for installation.
Porter makes application reuse and distribution easier.
Porter is an implementation of CNAB
which is a spec for packaging distributed Apps,
bundling, installing and
managing of container-native apps,
and their coupled services.
Cloud-agnostic, Airgap systems,
cryptographically verified,
everything, you need to ensure it's trustworthy.
KEDA is a really cool project
that allows you to scale up from zero.
KEDA enables functions runtimes like
Azure Functions, Knative, and others.
It provides a Kubernetes native way
to do event-driven auto-scaling,
and supports multiple back-ends.
The interesting thing about dapr is it
provides a different take or microservices.
You may have event streams and other backing services,
and dapr exposes those as sidecars.
You can have these integrations natively
without needing to implement them in your source code.
Moving the logic around into the Lego pieces,
the classic conservation of complexity.
Brigade is great when you're
configuration needs go beyond YAML,
because you can write JavaScript and have it
run arbitrary pipelines as needed,
to carry out tasks in your cluster.
You may have heard of cluster API,
or cluster API for Azure.
It allows you to declaratively build Kubernetes clusters.
Think of the YAML file that defines
how your Kubernetes cluster is to be built.
CAPI implements that with a series of controllers.
CAPZ is the Azure to provider to cluster API.
It's turtles all the way up.
Instead of choosing between Kubernetes and serverless,
virtual kubelet says, why not both?
VK gives you a kubelet
which schedules Kubernetes workloads.
This replacement kubelet behaves
just as the workloads expect,
but it's scheduling to alternate runtimes.
There's a plug-in for Azure Container Instances
for AWS firegate and more.
You can schedule those Serverless backends and
scale in different resource usage properties.
One of my personal favorite tools is
the Kubernetes extension for VS Code.
I like how it lets you do so
much without leaving your IDE.
You could introspect everything
running in your Kubernetes cluster.
Look at logs, right-click exec into
a container or a pod, and operate in there.
Search a home library for different applications,
you might want to install,
scaffold out YAML file for
Kubernetes resources and half tab completion.
It's a great tool for those who
don't want to use Kube-control,
and instead want
a Kubernetes native experience in their IDE,
regardless of where the Kubernetes is running.
This Kubernetes extension does so much.
It just might convert me from VI to VS Code.
But I'm keeping my kube-cuttle though.
We look forward to chatting with you
during KubeCon and going forward,
on GitHub and in the community.
Thanks so much for joining us
for this Cloud-native sampler.
Looking at open source tools you
can use on your Cloud-native journey.