An overview of Containers, Docker, Kubernetes, Istio, Helm, Kubernetes Operators and GitOps
A container is a software unit that packages up code, dependencies, configuration and environments as a self-contained application that is portable and runs with minimal overhead across different computing platforms. This class will guide students through a survey of the most common technologies in use today around containers. It will cover what you need to know for containers — Docker, Kubernetes, Helm, Istio, and Kubernetes Operators — and help you navigate your journey through the maze of terms, concepts, and functionality. You’ll get basic hands-on experience with each of these technologies as well as understanding how to leverage each for typical applications. You’ll come away with a good understanding of what these technologies can do, how to use them at a high level and what they can do for you.
In this class led by expert Brent Laster, we’ll do an overview of containers, Docker, Kubernetes, Helm, Istio, and Kubernetes Operators. And we’ll give you hands-on practice with each. We’ll work with a simple application (webapp frontend/database backend) and see how we can leverage each of these technologies to provide their core functionality around it. This will provide guidance around how you can utilize these technologies in a functional manner with your own applications to be cloud-friendly and provide increased value to your customers while simplifying your release and deployment processes.
What you'll learn-and how you can apply it
By the end of this live, hands-on, online course, you’ll understand:
- The basics (terminology, functions, use cases) for containers, Docker, Kubernetes, Helm, Istio, and Kubernetes Operators
- How these technologies can be applied to a simple example app
- How these technologies fit in with a cloud-first strategy
And you’ll be able to:
- Explain the core concepts and terms associated with containers, Docker, Kubernetes, Helm, Istio, and operators
- Apply each technology to an example application
- Execute and examine the example application executing with each of these technologies
This training course is for you because...
- You’re an IT professional who needs to understand one or more of these technologies
- You’re an IT professional who needs to understand how to use containers overall in a cloud-friendly way
- You want to be well-versed in the current industry-standard technologies around containers
- You want to learn how to make apps function in a container ecosystem such as a cloud
- Familiarity with basic computer systems, simple programming, and cloud awareness
- Setup instructions: https://github.com/brentlaster/safaridocs/blob/master/caz-setup.pdf
- Download, install, and run VirtualBox on your local machine.
- Download the preconfigured Virtual Machine image: https://www.dropbox.com/s/ppi6yy7z6nge0b0/caz-class.ova?dl=0
- Take Introduction to Docker Images (live online training course with Sean Kane)
- Take Introduction to Kubernetes (live online training course with Sébastien Goasguen)
- Take 9 Steps to Awesome with Kubernetes (live online training course with Burr Sutter)
- Take Istio on Kubernetes (live online training course with Burr Sutter)
About your instructor
Brent Laster is a global trainer, author, and speaker on open source technologies as well as a Director R&D manager at a top technology company. He has been involved in the software industry for more than 25 years, holding various technical and management positions.
Brent has always tried to make time to learn and develop both technical and leadership skills and share them with others. He believes that regardless of the topic or technology, there’s no substitute for the excitement and sense of potential that come from providing others with the knowledge they need to accomplish their goals.
The timeframes are only estimates and may vary according to how the class is progressing
Part 1: Containers, Images, and Docker (30 minutes)
- Presentation: Instructor will describe and present the basic concepts, intents, and functionality around containers, images, and Docker. Students will learn what each of these really is, how images are created and transformed into containers, and how Docker leverages existing Linux technologies to create and manage containers.
Lab 1: Building Docker Images (10 minutes)
- Purpose: In this lab, students will build Docker images from Dockerfiles.
Part 2: Using multiple containers together (10 minutes)
- Presentation: Instructor will describe how we can use Docker to create and run containers and how we can leverage another tool (docker-compose) to run containers together and allow them to easily interact with each other. Instructor will also discuss the format of a docker compose YAML file and how that feeds in to the process.
Lab 2: Running images together (10 minutes)
- Purpose: In this lab, students will make multiple containers execute together with docker compose and use the docker inspect command to get information to see our running app.
- Break (5 minutes)
Part 3: Naming and storing images (10 minutes)
- Presentation: Instructor will describe how we can tag Docker images, and the basics of Docker registries for storing images. Instructor will cover commands to use with images and registries and the differences between public and private, secure and insecure registries.
Lab 3: Tagging and pushing images (10 minutes)
- Purpose: Prior to working with Kubernetes, we want to push our images into a registry where Kubernetes can access them. To get them into a specific registry, we need to tag them with the location of the registry. Then we can push them. In this lab, students will successfully tag and push Docker images.
Part 4: Surveying Kubernetes - Part 1 (30 minutes)
- Presentation: Instructor will provide an overview of Kubernetes, and how it uses Docker images. Instructor will describe the main functions and motivations for using Kubernetes, the architecture of a cluster, the command line interface, and the major types of objects used in a cluster, such as pods, services, and deployments. The instructor will also cover the basic YAML file format for specifying Kubernetes objects.
Lab 4: Exploring and Deploying into Kubernetes (15 minutes)
- Purpose: In this lab, students will learn about Kubernetes and its object types, such as nodes and namespaces. We’ll also deploy a version of our app that has had Kubernetes YAML files created for it.
- Break (5 minutes)
Part 5: Surveying Kubernetes - Part 2 (20 minutes)
- Presentation: Instructor will provide an introduction to other key Kubernetes objects and functionalities including secrets, configmaps, ports, and persistent storage. Instructor will describe the purpose of each of these, how they are described, and how they are used in a Kubernetes environment.
Lab 5: Leveraging additional Kubernetes objects (15 minutes)
- Purpose: In this lab, students will explore additional key Kubernetes objects, create instances of each, and tie them in to the previous objects they created.
Day 1 wrap-up (10 minutes)
- Summarize what we’ve covered today and discuss what will be covered in Day 2.
Review: Day 1 key concepts (10 minutes)
Part 6: Helm basics and deploying charts (20 minutes)
- Presentation: Instructor will introduce Helm, an orchestration application for Kubernetes. Instructor will describe the purpose and intent and highlight the major functionality including the templates for Kubernetes manifests (charts), the templating language and available functions. Instructor will provide an overview of basic Helm commands.
Lab 6: Working with Helm - Part 1 (15 minutes)
- Purpose: In this lab, students will get familiar with Helm and deploy a set of Helm charts for our example application to create a release in our Kubernetes cluster.
Part 7: Helm: managing application releases in a cluster (10 minutes)
- Presentation: Instructor will explain how we can use Helm to get the history of releases in Kubernetes, upgrade to a new release, and rollback to a previous release.
Lab 7: Working with Helm - Part 2 (10 minutes)
- Purpose: In this lab, students will practice upgrading to new versions of an app in Kubernetes and switching between previous releases using Helm.
- Break (5 minutes)
Part 8: Istio (20 minutes)
- Presentation: Instructor will provide an overview of Istio and service meshes. Instructor will provide an explanation of the key components of Istio, including the control plane and data plane, Envoy proxy, and sidecar containers. Instructor will also provide an overview and description of how Istio can leverage Kubernetes objects like Virtual Services to do traffic-shifting, inject faults and delays for testing and similar functionality.
Lab 8: Working with Istio (15 minutes)
- Purpose: In this lab, students will use Istio with their Kubernetes cluster and our example app to do traffic-shifting between two versions of our app. They will also use Istio to inject periodic error conditions and delay for testing.
Part 9: Kubernetes Operators (15 minutes)
- Presentation: Instructor will describe the use case and motivation for creating and using operators in Kubernetes. Instructor will describe what a Kubernetes Custom Resource is and how those interact with operators and how we can use these to manage objects that might not otherwise be a good fit for Kubernetes. Instructor will survey the Operator SDK for coding and developing operators and show the Go code for an operator to work with the example app used in the class. Instructor will also introduce Kubernetes Role-Based Access Controls (RBAC) as needed for providing access for operators to work.
Lab 9: Working with Kubernetes Operators (15 minutes)
- Purpose: In this lab, students will deploy a custom resource definition and a related Kubernetes operator built for the example app used in the class. They will then scalethe custom resource and see how the operator handles the needed changes. They will also then explore the code that implements the operator.
- Break (5 minutes)
Part 10: Monitoring (10 minutes)
Presentation: Instructor will provide a brief overview of several tools that can be used to gather and visualize information about Kubernetes clusters and objects running within them. These tools include the Kubernetes dashboard (a visual interface for Kubernetes), Prometheus (for gathering and monitoring time-series data and metrics), and Grafana (for creating graphs and dashboards to display performance metrics).
Lab 10: Monitoring (10 minutes)
- Purpose: In this lab, students will launch and briefly explore the Kubernetes dashboard, Prometheus, and Grafana using data obtained from their Kubernetes cluster on the class VM.
Part 11: GitOps (10 minutes)
- Presentation: Instructor will provide a brief overview of GitOps and how it can leverage Git instead of the traditional Kubernetes interfaces to better manage the cluster and the lifecycle of objects in the cluster. Instructor will describe advantages of GitOps and how it can be implemented in a standard Kubernetes environment.
Part 12: Wrap-up and additional resources (10 minutes)
- Presentation: Instructor will summarize the overall content, provide suggested resources for further learning, and answer any remaining questions.