Kubernetes for Developers - 3 Day Deep Dive

Monday, 9:00 AM EST - SEA WATCH

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:

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.

Video Preview

Workshop Requirements

This session is a workshop. Please come prepared.

  • Some knowledge of building and using containers, such as Docker.
  • A basic laptop with a browser.
  • No other software installation is needed as we will rely on the Katacoda servers.
  • Some knowledge of building and using containers, such as Docker.
  • No previous knowledge of Kubernetes is expected or needed.

About Jonathan Johnson

Jonathan Johnson

Jonathan Johnson is an independent software architect with a concentration on helping others unpack the riches in the cloud native and Kubernetes ecosystems.

For 30 years Jonathan has been designing useful software to move businesses forward. His career began creating laboratory instrument software and throughout the years, his focus has been moving with industry advances benefitting from Moore’s Law. He was enticed by the advent of object-oriented design and applied it to financial software. As banking moved to the internet, enterprise applications took off and Java exploded onto the scene. Since then, he has inhabited that ecosystem. After a few years, he returned to laboratory software and leveraged Java-based state machines and enterprise services to manage the terabytes of data flowing out of DNA sequencing instruments. As a hands-on architect, he applied the advantages of microservices, containers, and Kubernetes with a laboratory management platform.

Today he enjoys sharing his experience with peers. He provides perspective on ways to modernize application architectures while adhering to the fundamentals of modularity - high cohesion and low coupling.microservices, containers, and Kubernetes to their laboratory management platform.

More About Jonathan »