Cloud Native Computing Foundation / Kubernetes Community Days (KCD) Chennai 2022

As the discipline of machine learning operations (MLOps) matures, it’s becoming clear that, in practice, building and deploying ML models pose additional challenges compared to the traditional software development lifecycle. The development and deployment of ML models require certain features such as reproducibility, recoverability, maintainability, audibility, scalability, and compute management, among others. Using Flyte, a data- and machine-learning-aware open source orchestration tool, we’ll see how to address these challenges and abstract them out to provide a broader understanding of how to surmount them.

In this talk, Samhita Alla:
● Presents the challenges in the context of ML model development and deployment
● Introduces Flyte and dive into the ways through which it provides solutions
● Elaborates on the ML-specific features offered by Flyte
● Does a best practices walk-through to develop models fast and productionize ML code effectively

Cloud-native applications comprise various components, including data services, storage systems, and related Kubernetes objects. Each component requires its own data protection tools, strategy, and domain expertise. A robust solution aligned with business requirements often involves complex workflows. What if there was a way to coordinate the implementation of these workflows while optimizing how backups are moved into storage? During this talk, Prasad will demonstrate how two open-source tools, Kanister and Kopia, work together to optimize backup and recovery for Kubernetes applications.

KEDA is a single-purpose and lightweight component that can be added into any Kubernetes cluster. KEDA works alongside standard Kubernetes components like the Horizontal Pod Autoscaler and can extend functionality without overwriting or duplication. With KEDA you can explicitly map the apps you want to use event-driven scale, with other apps continuing to function. This makes KEDA a flexible and safe option to run alongside any number of any other Kubernetes applications or frameworks. In this short talk you will learn the following: (i) Why KEDA? (ii) What is KEDA? (iii) Virtual Kubelets (iv) Helm Charts (v) Demo.

Helm charts have been the most popular way of deployment in the Kubernetes ecosystem. Although the Helm CLI is powerful and robust, it becomes challenging when it comes to debugging your microservices deployed with Helm. This talk addresses the challenges faced by the Helm users when deploying, updating and debugging their microservices in a Kubernetes cluster.

Though containers offer the same application portability and scaling capability when deployed on VMs or BareMetal servers, it is proven to be more performance effective on baremetals. However, there are several challenges to manage the lifecycle of bare metal nodes and Kubernetes under a single umbrella. There are many use cases, for example latency-sensitive applications like CDN, where application providers are made to tradeoff cloud agility with performance-oriented bare metal hosting. With the help opensource CNCF approach, we'll explain bridging this gap with services around dynamic bare metal provisioning, on-demand seamless Kubernetes cluster installation and application deployment orchestrator. With this feature, once can bring cloud-like agility to manage bare metal servers like virtual machines. We are managing 100’s of baremetal nodes distributed across different geo locations across world. Although we have validated the solution around baremetal, same can also be reused to private and public cloud deployments. This enables customers to avail best of both worlds without any tradeoffs, be it on infra flexibility or application performance or security. Also with the application orchestrator, one can easily adapt to distributed application deployment across clouds.

Serverless has become one of the most used terms for cloud computing. In a Serverless 1.0 world, cloud vendors created independent products without concern for portability or migration. This problem was solved with Serverless 2.0 which made workloads far more portable. Enterprises have started to adopt and maintain several open-source projects which tend to bring all the advantages of serverless to the way applications are deployed on Kubernetes currently. Cloud-native CI/CD tools are one of the best choices as they can fully exploit the inherent benefits of the cloud, making solutions efficient, resilient, dynamically scalable, and always available. GitOps has become increasingly popular in the DevOps space. Teams have been adopting GitOps in order to better deploy, manage and monitor Kubernetes clusters and applications. This presentation would demonstrate how to create Cloud-Native CI/CD Pipelines for deploying serverless applications on Kubernetes following GitOps Practices.

Crossplane: Build and Manage Infrastructure using Kubernetes. In this presentation, we will be exploring Crossplane and understand how we can make use of a Kubernetes cluster and the all too familiar Kubernetes YAML definition files to manage and compose resources on all major cloud providers. We will first go through the Crossplane concepts such as providers, managed resources, composite resources and understand how Crossplane extends the functionality of Kubernetes beyond objects such as pods and deployments to provision and manage external infrastructure using CRDs. Towards the end of the presentation, we will see a short demo where we will deploy resources on the AWS cloud with the standard Kubernetes Cluster API by making use of Crossplane.

Any managed Kubernetes is basically a bunch of VM's..no magic. Kubernetes networking is basically interfaces and routing rules (mostly IP tables). Come and Join us to learn about the fundamentals of Containers and Kubernetes networking.

Opensource Kube-router supports only IPv4 address. Due to less availability of IPv4 address, the kubernetes community and industry is moving towards dual-stack (IPv4 along with IPv6). Also, there is a need for direct server return with dual-stack. Now-a-days video streaming, online gaming is increasing day to day. So, streaming those application requires direct server return method on CNI for dual-stack. So, I will present about how we can achieve dual-stack. Also, I will present what is direct server return and the need for DSR approach in the present situation.

Any mission-critical workloads require full lifecycle security coverage. A zero-trust security approach can proactively protect your pipeline, supply chain, test environments and the critical production runtime environment. Container applications, the Kubernetes platform (API service, plugins, service mesh, etc.) and hosts themselves also need to be secured as a full cloud-native stack. This session will focus on open, comprehensive, secure and interoperable solutions designed for any Kubernetes environment. In this session we will explore: (i) Securing the Kubernetes Infrastructure, (ii) Supply Chain Security & (iii) Run-Time Security.

GitOps is an approach to having git as a single source of truth for the application that needs to be deployed on Kubernetes. In this session, the speaker will discuss GitOps principles and introduce projects - Argo and FluxCD, the Kubernetes native GitOps tools. These are the two most popular CNCF incubating projects in the CD ecosystem that let you define the state of your application in git and sync with the Kubernetes cluster where it gets deployed. Agenda (i) What is GitOps (ii) GitOps Principles (iii) ArgoCD introduction (iv) FluxCD introduction (v) Demo (vi) Comparison between the tools.

Kubernetes was started inside Google to provide a layer of abstractions with containers for the modern infrastructure. Now, the technology is adopted by the masses and has become a de-facto standard for any cloud-native application. The open-source system provides management, deployment, and scaling of your containers. Kubernetes is hard to beat in orchestration, but one of the most significant drawbacks is its lack of reproducibility. Here comes Helm: A package manager for Kubernetes and a CNCF Graduate Project. But how will you get started with Helm? The answer is by clearing the basics. This talk will help describe the importance of Helm in the current landscape and give you details on the why and how Helm is used.

Natan will present robusta.dev - a new and rapidly growing open source platform for Kubernetes monitoring and troubleshooting. Robusta sits on top of your existing monitoring tools (i.e. Prometheus) and tells you why alerts happen and how to fix them. It makes root cause analysis easier and gives you better manual troubleshooting tools for looking inside microservices when automated analysis fails.

eBPF has been called “Superpowers for Linux”, and in this talk Liz discusses why it’s a foundational technology for a new generation of cloud native networking, security and observability tools. The questions this talk answers include: (i) What is eBPF? (ii) How does eBPF enable the instrumentation of applications, without having to modify applications or their configuration in any way? (iii) What can we do with eBPF in the cloud today? Even if you’re not a Linux kernel aficionado you’ll leave this talk with an understanding of how eBPF enables high-performance tools that will help you connect, manage and secure applications in the cloud.

Over the last few years, the microservice architecture has become an increasingly popular framework for Kubernetes-based containerized applications. In this session, we will see how Open Service Mesh makes it effortless to enable the most sought-after features and functionality that organizations look for in an SMI-compliant service mesh. Topics (i) To Mesh or Not to Mesh (ii) OSM- Features, Components & Interactions (iii) Managed OSM (iv) Roadmap and integration with other services.

Cloud native DevOps has emerged as a prominent sub segment of the legacy DevOps. CNCF and Kubernetes have been at the center of this transition. This transition has helped find many new best practices for cloud native developers and SREs. One such best practice is to take service reliability into consideration while the applications are designed and developed that leads to more reliable cloud native services and reduces the overall TCO. In this session, Uma Mukkara will discuss the evolution of chaos engineering in cloud native DevOps, its current state and how all the personas from CIOs to developers should be looking at taking advantage of the recent advancements in this chaos engineering space in cloud native.

(i) What are the key trends in 2022 that are driving Kubernetes adoption? (ii) What kinds of challenges are enterprises facing? (iii) What’s the current state of the Kubernetes project? (iv) What’s new in Kubernetes 1.24 and what new features are in progress for future releases? We’ll answer all these questions and more. We will also celebrate the work done by Indian contributors in Kubernetes! This talk is geared towards everyone from Kubernetes newbies to advanced users.

Otomi is an open-source, cloud-agnostic, Kubernetes application configuration and automation platform. Under the hood, Otomi leverages several OSS and CNCF projects like Calico, OPA Gatekeeper, Istio, Harbor to enhance security. Security is an ever-growing concern for organizations. Gartner predicts that 99% of all security incidents by 2025 will be due to misconfigurations. This talk will demonstrate, how teams can use Otomi to manage container and network security policies with sane defaults on Kubernetes through an intuitive web interface, thereby avoiding the need to write any YAML configurations that are prone to errors. A recorded video/demo is used to showcase a couple of use-cases using the integrated security best practices in Otomi to reduce the attack surface when running applications on Kubernetes.

While Kubernetes is primarily thought out as a container orchestration platform, Kubernetes' inherent extensibility makes it a great choice to orchestrate any infrastructure. In this session, we will dive deep into how we can leverage Crossplane (https://crossplane.io/) and custom Kubernetes Operators to provision and manage Cloud Services (such as Amazon S3, RDS) in a Kubernetes native way.

Data science, machine learning (ML), and artificial intelligence have exploded in popularity in the last few years, with companies building out dedicated ML teams. Kubeflow is an OpenSource, ML toolkit for Kubernetes which provides useful components resolving problems in multiple areas. In this hands on demo we will discuss about how you can make a scalable architecture for ML training and inference at scale using a distributed storage in a backend (Amazon EFS) and Kubeflow (on Amazon EKS).

Software is not the same as it used to be; Many of us remember the days when building an application involved only writing code to solve a business problem and having it properly run on a single device. These days, however, applications need to run across machines and with distributed systems come distributed system problems. Even before we consider solving the actual business problem, we have to chart out the entire operational architecture: mode of communication between microservices: sync or async, worry about things like retries and backpressure, transactional logic and recovery from failure. We end up in a situation where the core business logic takes fewer days to develop than all the surrounding plumbing code and then also setup the build pipelines, deployment and auto-scaling. What if there was a better way to build fault tolerant applications that also took care of its own infrastructure in a programmatic way: A self-deploying, auto-scaling, resilient application.

DevSecOps for Kubernetes: With the increasing adoption of Kubernetes, the universal control plane, its complex architecture and default insecure configurations establish a strong foothold for multi-layer hardening. This requires a good understanding of the attack surface and security aspects of Kubernetes components as even a small misconfiguration may lead to a serious attack with huge impact to the organization. In this session, Kavya Rengaraj will discuss on understanding multi-layer hardening, the industry standards to follow and toolsets (KubeScore, KubeScape, Kubebench, KubeLinter, Falco) to the rescue aiming to improve the overall security posture by adopting DevSecOps practices like shift left, right and both. A reference DevSecOps pipeline with a unified view of the toolchains will be discussed.

Open-Source Contribution helps in being prepared for the industry. Open-Source contribution helps in writing cleaner code and gain recognition in the community. We'll give you a brief into how to dive into Open-source world and start contributing to awesome community. You'll also learn about Kubernetes concepts which would help you to deploy your applications at scale. What we are going to talk about: (i) What is open-source? (ii) How to get started with open-source? (iii) Open-Source communities and events (iv) Get involved in Kubernetes community and SIG + Basic Kubernetes concept (v) Kubernetes components (vi) Deploy your first Kubernetes Cluster (vii) Deploy demo application on Kubernetes cluster.

Now that you have your applications running on kubernetes, wondering how to get the response time that you need? Tuning applications to get the performance that you need in kubernetes can be challenging. At the same time, there are a number of kubernetes features that, when used in the right way can go a long way to get the most of the underlying hardware resources. This talk looks into each and every aspect of optimizing a kubernetes cluster, starting from the most basic node affinities to advanced methods such as tuning microservices, each with examples and a demo. We will also be specifically looking at tools that help to not only right size your containers but also optimize the runtimes.

Although some of today’s cloud properties, like elasticity, scalability, self-healing, durability, DR, etc. seemed revolutionary during the pre-cloud days, Cassandra had many of these properties already. With the ever growing popularity of Kubernetes, the k8ssandra open source project is intended to bring Cassandra's advantages to the cloud and help simplify operations. The biggest challenge in the Kubernetes world today is multi-cloud. Althoug easy to conceptualize, it is hard to implement. After a quick overview of Cassandra, k8ssandra, you will see how the worlds of Cassandra and Kubernetes on the cloud collide in a remarkably cohesive way to incorporate the best of both. In this primarily demo driven session, demoed at Kubecon, attendees will walk away with a good understanding of the k8ssandra project, support multi-region and multi-cloud. Along this journey we will look at one-off deployments on GKE, EKS including multi-cloud (GKE and EKS). On EKS, we leverage EKS Kubefed.

Stateful workloads have always been a challenge in the Kubernetes ecosystem. Kafka one of the most used event-driven systems is becoming the backbone system and with most of the infrastructure workloads now on Kubernetes, we need a robust and native way to communicate with Kafka inside Kubernetes. In this talk, I would like to introduce a Kafka Operator for Kubernetes which allows ease of deployment and management of the Kafka workloads.

With maturity of CI/CD, monitoring and networking ecosystem - progressive delivery has become possible and much easier to implement. In this talk we will understand what it takes to do progressive delivery so that you can prepare your organisation and teams to get progressive delivery right. We will also cover some best practices we learnt when implementing progressive delivery for a healthcare company and talk about various OSS technologies we evaluated in the journey.

Software developers bring highly valuable skills and experience to an Organisation. Typically, software developers analyze customer needs and then develop and test software to meet those requirements. But, it is also vital for software developers to meet the needs and requirements of their co-workers. Gone are the days when the only expectations from developers were centered around their software development skills and technical skills. As the software industry becomes integrated with business, the expectations from developers evolve. Engaging in meaningful interactions and forming strong professional relationships is vital. That element of a developer’s professional life requires a range of soft skills. This talk will focus on: (i) the state of software development in today’s highly distributed work environment (ii) the challenges organisations and developers face (iii) the importance of soft skills for developers (iv) useful soft skills developers can build.

Kube-scheduler is the brains behind managing node assignment to pods in a K8s cluster. And inside a Kubernetes cluster there are lot of things happening in the form of various api-calls at a given instance of time which makes it hard to visualize how pods are actually assigned to nodes. But, what if I tell you that there's a way to visualize and actually experience how the pods are getting assigned to a node and other resources like Nodes, Persistent volumes, Storage Classes are getting created with the help of a simulator. Cool right? Kube-scheduler-simulator is a new project under kubernetes-sigs scheduling which is also a web based simulator. On the simulator, you can create/edit/delete resources like Pods, Nodes, Persistent Volumes, Storage Classes to simulate a K8s cluster. It works as a web application which can either be deployed with Docker or can be run locally on supported machine.

Chaos engineering has come a long way from its early days at Netflix. While companies are widely adopting Kubernetes for their microservice architecture solutions, for the much-required competitive edge, it is important to ensure the resiliency of these systems for ensuring reliable services for everyone. As a large number of systems are moving towards the Kubernetes-Native approach, an important problem arises, testing these applications the right way to prevent outages in production. In this talk, we will introduce LitmusChaos and how we can leverage GitOps to increase the system resiliency. Further, we'll talk about how GitOps can be used by engineers and SREs to automate Chaos in their applications.

In this talk, we will discuss about the challenges with respect to multi-tenancy in Kubernetes and see how the open source project "vcluster" looks promising to address those. We will also deep dive into vcluster's architecture that explains how it could able to run multiple (virtual) kubernetes clusters within a single K8s cluster with a DEMO. Finally, we will also look into various use cases where "vcluster" could be used.

eBPF - Game changer technology to program the Linux Kernel dynamically. Using eBPF, we can now program Linux Kernel dynamically and get insights, which were not possible earlier or were very expensive . It is changing the game in the system's side the way JavaScript helped us bring everything on the browser. There are now many emerging use-cases of this technology. In this talk we'll discuss about its background, uses cases in security/tracing/networking/observability with some hands-on demo.

Infrastructure as code (IaC in short) is one of the critical parts of DevOps and Terraform is one such tool to help spin-up infra as code. In this workshop we will discuss, IaC overview, Terraform introduction and demo. As part of Demo, we will create AWS infrastructure using terraform.

Running Application Containers on Kubernetes (i) Introduction to pod and manifests (ii) Pod states and probes (iii) Live Lab - Deploying an application as pod Scaling and Deploying Applications, Observability (i) Pod controllers - replicaset, deployments, statefulsets (ii) Live Lab - Replicas and HA, services and port forwarding (iii) Logging, Metrics and Troubleshooting (iv) Metrics management using Prometheus.

Developers spend numerous days onboarding applications to Kubernetes, automating end-to-end DevOps pipelines by integrating with multiple tools and implementing monitoring, logging and alerting to simplify the application maintenance. Setting up a simple CI/CD pipeline requires configuring and maintaining separate build environments. Developers configure different tools like prometheus, Grafana and elastic search to setup a logging and monitoring framework. In this session, we will be discussing the gopaddle lite – a life time free zero cost solution on microk8s for end-to-end modernization and automation. At the end of this session, developers will be able to enable gopaddle lite add-on in microk8s, containerise, build docker images, deploy applications to their local microk8s environments and setup CI/CD pipeline in minutes. They will be able to monitor applications and get notification on slack for various cluster and application events with minimal configuration.