Certified Kubernetes Application Developer (CKAD) Prep Course

Video description

Microservices architecture is one of the hottest areas of application development today, particularly for cloud-based enterprise-scale applications. The benefits of building applications using small, single-purpose services are well documented and include the ability to implement Continuous Integration/Continuous Delivery pipelines. But, managing what can sometimes be enormous numbers of services is no easy task and requires the addition of an “orchestrator” to keep it all together. Kubernetes is among the most popular and broadly used tools for this job. So it’s no surprise that the ability to use, troubleshoot, and monitor Kubernetes as an application developer is in high demand. To help job seekers and employers have a standard means to demonstrate and evaluate proficiency and value in a Kubernetes environment, the Cloud Native Computing Foundation (CNCF) developed the Certified Kubernetes Application Developer (CKAD) certification. And to achieve this certification, you need to pass an exam.

In this video course, your host, trainer and CKAD Ben Muschko, explores the topics covered in the CKAD exam to fully prepare you to pass the certification exam. You’ll look at determining when and how you should apply the core concepts of Kubernetes to manage an application. You’ll also examine the kubectl command-line tool, a mainstay of the Kubernetes engineer. Ben also offers tips to help you better prepare for the exam and shares his personal experience with getting ready for all aspects of the exam. The CKAD is different from the typical multichoice format of other certifications. It’s completely performance based and requires deep knowledge of the tasks at hand under immense time pressure. Are you ready to pass the test on the first go?

What you'll learn — and how you can apply it

By the end of this live, hands-on, online course, you’ll understand:

  • When and how to apply Kubernetes concepts to manage an application
  • Objectives, abilities as well as tips and tricks (like time management, navigating the exam environment and the type of questions to expect) needed to pass the CKAD exam
  • The ins and outs of the kubectl command-line tool

And you’ll be able to:

  • Demonstrate competency to perform the responsibilities of Kubernetes application developers
  • Solve real-world Kubernetes problems in a hands-on, command-line environment
  • Effectively navigate and solve questions during the CKAD exam

This training is for you because...

  • You’re a developer using Kubernetes to configure, manage, and rollout applications, and you want to obtain CKAD certification
  • You want to understand the basics of Kubernetes by solving hands-on problems
  • You want to become a Certified Kubernetes Application Developer


  • You should have experience working with containers, in particular Docker
  • You should possess beginner-level understanding of Kubernetes concepts and the resources API
  • You should have familiarity with a Unix environment and Bash commands as well as with command-line-based text editors (optimally vim) and the YAML format

Recommended preparation:

Recommended follow-up:

  • Introduction to Kubernetes (live online training)
  • Kubernetes Patterns (book)
    • Common misunderstandings:

      • Learners might understand the basic Kubernetes ideas and concepts but aren’t able to apply them in practice
      • Format, time management, and shell environment of the CKAD exam which leads to candidates failing when taking the test
      • Ability to troubleshoot and debug Kubernetes setups by using appropriate kubectl commands under pressure

Table of contents

  1. Introduction
    1. Introduction
  2. Module 1
    1. Module 1: Exam Details and Resources
    2. Exam Objectives and Curriculum
    3. Candidate Skills and Exam Environment
    4. Module 1: Summary
  3. Module 2
    1. Module 2: Core Concepts
    2. Kubernetes Object Creation and Management
    3. Understanding Pods
    4. Inspecting and Configuring Pods
    5. Demo: Creating a Pod and Inspecting it
    6. Module 2: Summary
  4. Module 3
    1. Module 3: Configuration
    2. Centralized Configuration Data
    3. Creating and Mounting ConfigMaps
    4. Demo: Configuring a Pod to Use a ConfigMap
    5. Creating and Mounting Secrets
    6. Demo: Configuring a Pod to Use a Secret
    7. Understanding Security Contexts
    8. Demo: Creating a Security Context for a Pod
    9. Declaring Resource Boundaries
    10. Demo: Defining a Pod’s Resource Requirements
    11. Declaring Service Accounts
    12. Demo: Using a Service Account
    13. Module 3: Summary
  5. Module 4
    1. Module 4: Multi-Container Pods
    2. Defining and Running Multiple Containers in a Pod
    3. Multi-Container Patterns
    4. Understanding Init Containers
    5. Understanding the Sidecar Pattern
    6. Understanding the Adapter Pattern
    7. Understanding the Ambassador Pattern
    8. Demo: Implementing the Adapter Pattern
    9. Module 4: Summary
  6. Checkpoint
    1. Checkpoint
  7. Module 5
    1. Module 5: Observability
    2. Understanding and Defining Readiness Probes
    3. Understanding and Defining Liveness Probes
    4. Demo: Defining a Pod's Readiness and Liveness Probe
    5. Debugging Existing Pods
    6. Demo: Fixing a Misconfigured Pod
    7. Module 5: Summary
  8. Module 6
    1. Module 6: Pod Design
    2. Understanding and Querying Labels
    3. Understanding Annotations
    4. Demo: Defining and Querying Labels and Annotations
    5. Understanding and Creating Deployments
    6. Scaling a Deployment
    7. Demo: Performing Rolling Updates and Scaling a Deployment
    8. Understanding and Creating Jobs
    9. Understanding and Creating CronJobs
    10. Demo: Creating a Scheduled Container Operation
    11. Module 6: Summary
  9. Module 7
    1. Module 7: Services Networking
    2. Understanding and Creating Services
    3. Services and Deployments
    4. Demo: Routing Traffic to Pods from Inside and Outside of a Cluster
    5. Understanding and Creating Network Policies
    6. Demo: Restricting Access to and from a Pod
    7. Module 7: Summary
  10. Module 8
    1. Module 8: State Persistence
    2. Understanding and Creating Volumes
    3. Understanding and Creating PersistentVolumes
    4. Demo: Defining and Mounting a PersistentVolume
    5. Module 8: Summary
    6. Conclusion

Product information

  • Title: Certified Kubernetes Application Developer (CKAD) Prep Course
  • Author(s): Benjamin Muschko
  • Release date: July 2019
  • Publisher(s): O'Reilly Media, Inc.
  • ISBN: 9781492061038