About the course
Kubernetes, often called K8s, is the leading platform for automating the deployment, scaling, and management of containerised applications, serving as the foundation for modern cloud-native architectures. This comprehensive training course provides a deep dive into both the foundational concepts of Docker and the powerful orchestration capabilities of Kubernetes, equipping participants with the essential skills to build, deploy, and manage scalable, resilient applications effectively.
You will begin by building a solid understanding of Docker, covering image creation, container lifecycle, networking, volumes, and multi-container setups using docker-compose for local development. The course then transitions to Kubernetes, exploring its architecture, including Control Plane components, Worker Nodes, Container Runtimes, and common cluster provisioning methods. You will learn how to create, configure, and manage fundamental Kubernetes objects such as Pods, Deployments, ReplicaSets, and StatefulSets, understanding concepts like Namespaces, Labels, and Selectors for resource organisation.
The syllabus covers configuring your applications with ConfigMaps and Secrets, controlling workload placement and scheduling using resource requests/limits, Taints/Tolerations, and Node Affinity, and implementing robust application observability with liveness/readiness probes and logging. You will gain expertise in essential deployment strategies like rolling updates and rollbacks, with an overview of advanced techniques, and learn about batch workloads using Jobs and CronJobs.
The course delves into securing your applications and the cluster using Service Accounts, RBAC, and Network Policies, and managing networking for internal and external communication with Services and Ingress. You will also cover persistent storage using Persistent Volumes, Persistent Volume Claims, and Storage Classes, and be introduced to the Operator pattern for managing complex stateful applications. Finally, a dedicated section covers packaging and deploying your applications effectively using Helm.
Through extensive hands-on exercises integrated throughout the course, you will gain practical experience deploying, managing, scaling, and troubleshooting containerised applications on Kubernetes, preparing you for designing and operating cloud-native systems.
Instructor-led online and in-house face-to-face options are available - as part of a wider customised training programme, or as a standalone workshop, on-site at your offices or at one of many flexible meeting spaces in the UK and around the World.
-
- Understand Docker fundamentals: images, containers, networking, and volumes.
- Explain Kubernetes architecture and core components, including Control Plane and Container Runtimes.
- Create, configure, and organise core Kubernetes objects such as Pods, Deployments, ReplicaSets, Namespaces, and Labels.
- Configure applications using ConfigMaps and Secrets.
- Implement application observability using liveness/readiness probes and logging.
- Manage application lifecycle with rolling updates and rollbacks.
- Configure Kubernetes networking for internal and external communication using Services and Ingress.
- Secure Kubernetes applications and access using RBAC (Role-Based Access Control).
- Manage persistent storage and deploy stateful applications using Persistent Volumes, Persistent Volume Claims, and StatefulSets.
- Package and deploy applications using Helm.
-
This course is designed for developers, DevOps engineers, system administrators, and architects who need to build, deploy, and manage containerised applications on Kubernetes. It is particularly relevant for:
Software Developers building cloud-native applications.
DevOps Engineers responsible for deploying and managing applications on Kubernetes.
System Administrators transitioning to container orchestration.
Architects designing containerised and distributed systems.
Anyone looking to understand and work with the leading container orchestration platform.
-
Delegates should have some basic understanding of Linux and application development, and be comfortable using a command line or terminal. Basic familiarity with container concepts is beneficial, although the course will cover the fundamentals of Docker.
-
This Kubernetes course is available for private / custom delivery for your team - as an in-house face-to-face workshop at your location of choice, or as online instructor-led training via MS Teams (or your own preferred platform).
Get in touch to find out how we can deliver tailored training which focuses on your project requirements and learning goals.
-
Docker
History of Docker and Containers
Fundamental building blocks of a container
Getting your application into an image (Dockerfile basics)
Going from images to containers
Interacting with running containers
Multiple container workloads using docker-compose (for local development)
Docker networking concepts
Docker volumes for persistence
Kubernetes Fundamentals
What is Kubernetes?
What problem is Kubernetes solving (Orchestration)?
Kubernetes Architecture Overview:
Control Plane Components (API Server, etcd, Scheduler, Controller Manager)
Worker Nodes and the Kubelet
Container Runtimes (CRI, containerd, CRI-O) vs. Docker Engine (brief context)
Common Cluster Provisioning Methods (Managed cloud services, kubeadm - brief mention)
Resources for running your workloads
Core Kubernetes Objects and Concepts
Creating and editing: Pods
Replicasets: Ensuring desired number of pods
Deployments: Managing stateless applications and rolling updates
Namespaces: Logical isolation
Configuring your application:
Using Environment variables
ConfigMaps
Secrets
Placing your workload (Scheduling):
Resource requests and limits
Taints & Tolerations
Node Selectors
Node Affinity / Anti-Affinity
Multi-container pods:
initContainers
Sidecar pattern (brief mention)
Application observability in Kubernetes:
Liveness and readiness probes
Container logging
Debugging applications in pods
Pod Design Best Practices:
Labels, selectors and annotations
Rolling updates and rollbacks
Advanced Deployment Strategies (Canary, Blue/Green - brief overview)
Batch Workloads:
Jobs
Cronjobs
Application Packaging and Deployment with Helm
What is Helm? (Kubernetes Package Manager)
Helm Charts: Structure and Templating
Releasing and Managing Applications with Helm
Kubernetes Security
Service accounts: Identity for pods
RBAC (Role-Based Access Control): Authorisation within Kubernetes
Network policies: Controlling network traffic between pods
Kubernetes Networking
Services: Exposing applications inside the cluster
Ingress: Exposing applications outside the cluster (HTTP/S routing)
State Persistence in Kubernetes
Persistent Volumes (PV) and Persistent Volume Claims (PVC)
Storage Classes: Dynamic provisioning of storage
StatefulSets: Deploying stateful applications reliably
Introduction to the Operator Pattern (Custom automation for complex stateful applications)
-
Official Kubernetes Documentation - https://kubernetes.io/docs/
Docker Documentation - https://docs.docker.com/
Helm Documentation - https://helm.sh/docs/
Kubernetes GitHub Repository - https://github.com/kubernetes/kubernetes
Kubernetes Community (Slack, Discuss) - https://kubernetes.io/community/
CNCF (Cloud Native Computing Foundation) website - https://www.cncf.io/
Containerd Documentation - https://containerd.io/
CRI-O Documentation - https://cri-o.io/
Trusted by
