Jonathan Johnson

Kubernetes for Developers - 3 Day Deep Dive

Monday, 9:00 AM EST

At the end of this workshop, you will be comfortable with designing, deploying, managing, monitoring and updating a coordinated set of applications running on Kubernetes.

Distributed application architectures are hard. Building containers and designing microservices to work and coordinate together across a network is complex. Given limitations on resources, failing networks, defective software, and fluctuating traffic you need an orchestrator to handle these variants. Kubernetes is designed to handle these complexities, so you do not have to. It's essentially a distributed operating system across your data center. You give Kubernetes containers and it will ensure they remain available.
 
Kubernetes continues to gain momentum and is quickly becoming the preferred way to deploy applications.
 
In this workshop, we’ll grasp the essence of Kubernetes as an application container manager, learning the concepts of deploying, pods, services, ingression, volumes, secrets, and monitoring. We’ll look at how simple containers are quickly started using a declarative syntax. We'll build on this with a coordinated cluster of containers to make an application. Next, we will learn how Helm is used for managing more complex collections of containers. See how your application containers can find and communicate directly or use a message broker for exchanging data. We will play chaos monkey and mess with some vital services and observe how Kubernetes self-heals back to the expected state. Finally, we will observe performance metrics and see how nodes and containers are scaled.
 
Come to this workshop the learn how to deploy and manage your containerized application. On the way, you will see how Kubernetes effectively schedules your application across its resources.

Optionally, for more daring and independent attendees, you can also replicate many of the exercises on your local laptop with Minikube or Minishift. There are other Kubernetes flavors as well. However, if during the workshop you are having troubles please understand we cannot deviate too far to meet your local needs. If you do want to try some of the material locally this stack is recommended:

• Linux, Windows 10 or MacOS laptop with 4 core processor (I7 equivalent) 16 gig memory. Ensure your CPU virtualization BIOS switch is turned on. Some company issued laptops may lock this access.
• Preinstall the latest versions of Minikube, KubeCtl, and Helm.
• Minikube works best with a recent version of VirtualBox.

Some of the topics we will explore:

• Using Minikube, KubeCtl and Helm
• Kubernetes Architecture and terminology
• Resilience with declarative states and the reconciliation loop
• Kubernetes REST API
• Components: Etcd, Scheduler, Controller, Kubelet
• Namespaces
• Kinds: Pod, Service, Deployment, ReplicaSet, Ingress
• Labels and selectors
• Etcd, ConfigMaps, Secrets
• Volumes and mounts
• Ingress
• Helm and charts
• Container patterns
• Probes, Logging, monitoring, and troubleshooting
• Scaling
• Standard and custom resources
• Operators
• Istio
• Kubernetes ecosystem for software engineers

These concepts are presented and reinforced with hands-on exercises:

• Advantages of distributed computing
• History and rise of Kubernetes
• Cloud native computing foundation
• Architecture and terms and how it works
• Deploying and running applications
• Kubernetes objects - Deployment, Pods, ConfigMaps, Jobs, Secrets, Ingress, Volumes and many more
• Container patterns
• Serverless
• Istio Meshing
• Monitoring

You will leave with a solid understanding of how Kubernetes actually works and a set of hands-on exercises your can share with your peers. Bring a simple laptop with a standard browser for a full hands-on experience.

Writing Katacoda scenarios

Tuesday, 8:30 PM EST

Explore another learning medium to add to your toolbox: Katacoda.

This is a 90-minute mini-workshop where you learn to be an author on Katacoda. Bring your favorite laptop with just a browser and a text editor.

Have a Github account and bring your laptop. Let's learn together.

We are continuously learning and keeping up with the changing landscapes and ecosystems in software engineering. Some technologies are difficult to learn or may take too much time for us to set up just to get to the key points of each technology. One of the reasons why you might be here at NFJS is to do exactly that – too learn. Great!

There are many mediums we use to learn and we often combine them for different perspectives. Books, how-to articles, GitHub readmes, blog entries, recorded talks on YouTube, and online courses. All these help us sort through the new concepts. I'm sure you have your favorites.

Katacoda is becoming a compelling platform for learning and teaching concepts. You can also author your own topics for public communities or private teams. Katacoda offers a platform that hosts live server command lines in your browser with a split screen for course material broken into easy to follow steps.

Kubernetes Koncepts

Wednesday, 9:00 AM EST

You have some modular code with a REST API. You are on your way to Microservices. Next, you package it in a container image that others can run. Simple. Now what? Your service needs to log information, needs to scale and load balance between its clones. Your service needs environment and metadata way outside its context. What about where the service will run? Who starts it? What monitors its health? What about antifragility? Updates? Networking? Oh my.

Don't get flustered. We will explore how Kubernetes simplifies the complexity of distributed computing.

This session will help you understand the terms, architecture and the mechanics of the Kubernetes tools. You will understand how to target your applications to a seemingly complex distributed compute platform.

Kubernetes Koncepts (continued)

Wednesday, 11:00 AM EST

Prerequisite: If you are unfamiliar with Kubernetes be sure to attend: Kubernetes Koncepts (1 of 2)

Aha moments with apps in containers can be quite liberating. The mobile space is saturated with “there's an app for that”. For us, we now expect “there's a container for that”. “Write once, run anywhere” (WORA) has changed to “Package once, run anywhere” (PORA). The growing community of containers is riding up the hype curve. We will look at many ways to assemble pods using architecture patterns you already know.

Your software package delivery and installation is no longer an rpm, deb, dmg, jar, war, native executable or a run script, it is simply an image that has a common run container command.

During the presentation, we will explore some examples on Katacoda.

Kubernetes Operator Pattern

Wednesday, 1:30 PM EST

Kubernetes is a strong platform for running and coordinating large collections of services, containers, and applications, but even with all of its standard resources, Kubernetes can't do everything. Fortunately, Kubernetes is highly configurable and extensible. The Operator pattern has emerged as an important extension technique.

We’ll break down what this pattern is all about. There are public operators, there are operator registries, and there are frameworks so you can write your own operators. Beyond the Hello World examples, you'll soon realize Operators are important and how you can get started with them.

Konsumer Driven Kontracts

Wednesday, 3:15 PM EST

Prerequisite: If you are unfamiliar with Kubernetes be sure to attend: Kubernetes Koncepts

At the 2009 Agile conference, J.B.Rainsberger declared “Integration tests are a scam”. I agree. Come see some compelling reasons why consumer-driven contract testing is a much better approach. Particularly for microservices.

We will explore different testing techniques on Kubernetes, including an important one called “Consumer-Driven Contracts”.

After a brief overview of the concepts a live demonstration will show you how to:

1. set up a Pact Broker on Kubernetes
2. write a consumer that defines and publishes Pact contracts
3. deploy and run a few Spring Boot microservices on Kubernetes
4. connect microservices to a database and public data source
5. verify the consumer pacts against a producer
6. find API defects and fix them

Serverless Madness on Kubernetes

Wednesday, 5:00 PM EST

Prerequisite: If you are unfamiliar with Kubernetes be sure to attend: Kubernetes Koncepts.

From operating system on bare metal, to virtual machines on hypervisors, to containers orchestration platforms. How we run our code and bundle our applications continues to evolve. Serverless computing continuous our evolutionary path for our architectures.

Kubernetes provides an ideal, vendor-agnostic platform for serverless computing. Serverless promises to developers that we can worry less about the cluster and focus more on their logic. Based on your Kubernetes knowledge we will discover the various contributors of serverless frameworks on Kubernetes. Specifically, we will unpack how two open source serverless frameworks, Kubeless and OpenFaaS, leverage Kubernetes to achieve their promises. We will explore how Knative is helping the serverless providers evolve to the next levels sophistication.

Kontinuous Pipelines on K8s

Thursday, 9:00 AM EST

Prerequisite: If you are unfamiliar with Kubernetes be sure to attend: Kubernetes Koncepts.

Kubernetes is a powerful platform for running containers and distributing computation workloads across resources. A significant question is how do you get all your code to this platform, continuously.

In 2019 our community is bursting with new solutions to assist our delivery pipelines. While Jenkins is a dominant player, there is a growing array of new ideas and choices. From coding at your laptop to building containers to deployments, we will explore the various tools and techniques to reduce the delivery frictions.

Kubernetes is also a fitting platform for hosting your continuous tools, pipeline engines, registries, testing, code analysis, security scans, and delivery workflows.

From this session, you will understand the latest tools and techniques for pipelining on Kubernetes. Let's up the game on your Maturity Model.

Meshing Around with Service Traffic

Thursday, 10:45 AM EST

Kubernetes out of the box is a strong platform for running and coordinating large collections of services, containers, and applications. As is, Kubernetes is powerful for many solutions.

Remember Underdog? He was a mild-mannered dog, but when stress and conflict were introduced to the plot he took a magic pill, he became a superhero. Istio is a superhero for Kubernetes.

Istio is an open, platform-independent service mesh that manages communications between services in a transparent way. With a distributed architecture many things can fail, slow down and become less secure. Istio provides solutions to those stresses in our plot toward this architecture style:

• Traffic management
• Observability
• Policy enforcement
• Service identity and security

We will explore these benefits with Istio through some working examples on Kubernetes. The key point is this meshing solution allows your Java code to be less coupled to the inherent weaknesses of a distributed platform.

Meshing Around with Observability

Thursday, 1:30 PM EST

Prerequisite: If you are unfamiliar with Kubernetes or Istio meshing be sure to attend: Understanding Kubernetes: Fundamentals or Understanding Kubernetes: Meshing Around with Istio.

Kubernetes is a complex container management system. Your application running in containers is also a complex system as it embraces the distributed architecture of highly modular and cohesive services. As these containers run, things may not always behave as smoothly as you hope. Embracing the notions of antifragility and designing a system to be resilient despite the realities of resource limitations, network failures, hardware failures and failed software logic. All of this demands a robust monitoring system to open views into the behaviors and health of your applications running in a cluster.

Three important aspects to observe are log streams, tracing, and metrics.

In this session, we look at some example microservices running in containers on Kubernetes. We add Istio to the cluster for meshing. We observe how logs are gathered, We see transactions are traced and measured between services. We inspect metrics and finally add alerts when metrics are indicating a problem.

• Log aggregation with an EFK stack
• Istio metrics gathering
• Transaction tracing with correlation IDs
• Prometheus
• Grafana
• Alertmanager

Distilling Java Containers

Thursday, 3:15 PM EST

Three evolutionary ecosystems work well together Java, Containers, and Kubernetes.

Past versions of Java were never designed to be “container aware”. This has led some to stray away from the JVM and consider other shiny languages. But wait, before you go, let's discover what Java 9, 10, 11, 12, 13 (…) has done to get our applications into efficiently distilled containers that pack nicely into Kubernetes.

Topics covered:

• Microframeworks
• Java9+, advancing beyond the troubled past
• Java runtime to container runtime - a paradigm shift for “run anywhere”
• Distillation pattern · small containers with a reduced attack vector
• Multi-stage Dockerfile
• JLink, JDeps
• GraalVM
• Hands on example