Kubernetes introduction

Introduction to Kubernetes Master the technology powering modern application deployment — from first principles to hands-on practice

Have you ever wondered how companies like Google, Spotify, and Airbnb deploy hundreds of updates every day without their applications ever going down?

The answer is Kubernetes. Originally developed inside Google to manage billions of containers running across its global infrastructure, Kubernetes is now the industry standard for deploying, scaling, and managing containerised applications — and it has fundamentally changed the way modern software is built and operated.

Today, Kubernetes runs in virtually every major organisation on the planet. It is the backbone of cloud-native architecture, the foundation of DevOps engineering, and one of the most in-demand technical skills in the entire technology industry. Professionals who understand it are among the most sought-after in the market.

This course is where that journey starts.

What this course is about

Kubernetes can feel intimidating at first. The terminology is dense, the architecture is complex, and the learning curve is real. But underneath the complexity is a set of powerful, elegant concepts — and once those concepts click, everything else falls into place.

This course cuts through the complexity and builds your understanding of Kubernetes from the ground up. Whether you have never heard of a container before or you have been working with Docker for years, this programme gives you the clear, structured foundation you need to work with Kubernetes confidently in real environments.

You will learn how Kubernetes works, why it was built the way it was, and how to use it to deploy, manage, and scale applications in practice — with hands-on experience throughout.

No prior Kubernetes experience is required. However, some basic knowledge of general IT protocols and Linux systems is preferred.

Why Kubernetes skills matter right now

The shift to cloud-native architecture is one of the most significant transformations in the history of software engineering — and Kubernetes is at the centre of it. Every major cloud provider offers a managed Kubernetes service: Amazon EKS on AWS, Google Kubernetes Engine on GCP, and Azure Kubernetes Service on Microsoft Azure. Organisations that have moved to the cloud are building on Kubernetes. Organisations that haven't moved yet are planning to.

The result is a global skills shortage in Kubernetes expertise that is showing no signs of closing. Employers across every sector — from financial services and healthcare to retail, media, and government — are actively hiring engineers, architects, and DevOps professionals who can work with Kubernetes in production.

Understanding Kubernetes is no longer optional for anyone who wants to work at the cutting edge of modern technology.

What you will learn

• What Kubernetes is, where it came from, and why it has become the standard for container orchestration
• The core architectural components of a Kubernetes cluster — control plane, worker nodes, and how they interact
• The fundamental Kubernetes objects: Pods, Deployments, Services, ConfigMaps, Secrets, and Namespaces — what each one does and when to use it
• How to deploy and manage containerised applications on Kubernetes using real, hands-on exercises
• How Kubernetes handles scaling — automatically adjusting the number of running instances based on demand
• How Kubernetes manages application availability — detecting failures and recovering from them without manual intervention
• How networking works inside a Kubernetes cluster — routing traffic between services and exposing applications to the outside world
• How to manage application configuration and sensitive data securely within Kubernetes
• How to use persistent storage within Kubernetes for applications that need to retain data
• How Kubernetes fits into the broader cloud-native ecosystem — including Docker, Helm, and managed services like Amazon EKS, Google GKE, and Azure AKS
• How to approach the Kubernetes ecosystem with the confidence to continue learning independently after this course

How you will learn it

Kubernetes is not a subject you can learn by reading alone — you need to use it. This course is hands-on from the very first session. You will work directly with real Kubernetes clusters throughout your training, deploying applications, configuring workloads, troubleshooting issues, and exploring the platform in a way that builds genuine, transferable skills.

Every session is delivered by an active industry professional with real-world Kubernetes experience across enterprise environments.

Flexible delivery — designed around your life

We offer multiple training formats so you can learn in the way that works best for you:

One-to-one (1:1) Private, personalised sessions scheduled around your availability.

Group training (cohort) Prefer to learn alongside others? Our weekend cohort sessions bring motivated learners together in a structured, collaborative environment — ideal if you enjoy working through complex technical concepts with a group and want to build connections with like-minded professionals along the way.

What's included

• Personalised Introduction to Kubernetes training plan
• Hands-on labs working with real Kubernetes clusters throughout
• Access to an expert trainer before, during, and after every session
• Guidance on study materials, practice environments, and next steps
• A clear pathway toward advanced Kubernetes and cloud-native certifications

Who this is for

This course is designed for anyone who wants to understand and work with Kubernetes — whether you are just starting out in cloud and DevOps or you are an experienced engineer looking to fill a critical gap in your skill set. It is particularly well suited to:

Developers moving into cloud-native development If you build applications and want to understand how they are deployed and operated in modern cloud environments, Kubernetes is the single most important technology to learn — and this course gives you that foundation in the most direct and practical way possible.

IT professionals and system administrators moving into DevOps If you have a background in infrastructure, networking, or system administration and want to transition into cloud-native operations and DevOps engineering, Kubernetes is the core technology that role is built around. This course bridges that gap clearly and practically.

Cloud engineers expanding their skill set If you already work with AWS, Azure, or Google Cloud and want to add container orchestration to your capabilities, this course gives you the Kubernetes knowledge that complements and extends everything you already know.

DevOps engineers and platform engineers If you work in DevOps or platform engineering and have been working around Kubernetes without fully understanding it, this course gives you the structured foundation to work with it properly — and to take your skills to the next level.

Anyone preparing for Kubernetes or cloud-native certifications This course provides the foundational knowledge required before pursuing certifications such as the Certified Kubernetes Administrator (CKA), Certified Kubernetes Application Developer (CKAD), or cloud provider Kubernetes certifications on AWS, GCP, or Azure.

Recommended prior experience: A basic understanding of what containers are and how Docker works is helpful, but not essential. If you have completed any of our cloud architecture or DevOps programmes, you are well prepared to begin. If you are unsure, speak to one of our advisers and we will give you an honest assessment.

Where this course can take you

Kubernetes is a foundation, not a destination. Once you have completed this introduction, a range of advanced and highly valued paths open up directly from here:

Certified Kubernetes Administrator (CKA) The industry-standard certification for Kubernetes operations — validating your ability to install, configure, manage, and troubleshoot Kubernetes clusters in production environments.

Certified Kubernetes Application Developer (CKAD) Focused on deploying and managing applications on Kubernetes — ideal for developers who want to work with the platform at the application layer.

AWS Certified DevOps Engineer — Professional Extend your Kubernetes knowledge into the full AWS DevOps ecosystem — CI/CD pipelines, infrastructure automation, Amazon EKS, and enterprise-scale delivery.

Google Cloud Professional DevOps Engineer Apply your Kubernetes skills within the Google Cloud ecosystem — working with Google Kubernetes Engine (GKE) and the full Google Cloud operations and delivery toolchain.

Advanced container and cloud-native architecture Deepen your knowledge with our advanced programmes covering Helm, service meshes, GitOps, and cloud-native architecture patterns for production Kubernetes environments.

Your outcome

You will complete this course with a genuine, practical understanding of Kubernetes — not just the theory, but the hands-on confidence to work with it in real environments. You will understand how modern applications are deployed and operated, know how Kubernetes fits into the cloud-native ecosystem, and have a clear and well-structured path toward the advanced certifications and specialisations that build on this foundation.

In a technology landscape where Kubernetes expertise is one of the most in-demand skills available, this course is the starting point that everything else can be built on.

Not sure if this is the right starting point, or want to understand how it fits into your broader learning goals? Speak to one of our advisers — no commitment, no pressure, just an honest conversation about where you want to go and the best way to get there.

Course curriculum

Introduction to Kubernetes

The problem Kubernetes solves: from traditional infrastructure to containers

Before writing a single kubectl command, you need to understand why Kubernetes exists — and the real-world challenges it was built to address. This module sets the context for everything that follows, giving you the foundational understanding that makes every subsequent concept click into place.

You will start by examining how applications have traditionally been deployed — on physical servers, then virtual machines — and why those approaches create problems at scale. You will learn what a container is, how it differs from a virtual machine, and why containers have become the default way to package and run modern applications. The module covers the Docker fundamentals every Kubernetes practitioner needs to know: what container images are, how they are built, how containers are run from them, and why the consistency and portability of containers make them so powerful in cloud environments.

From there the module introduces the core challenge that Kubernetes was designed to solve — what happens when you need to run not one container, but hundreds or thousands of them, across multiple machines, reliably and at scale. You will learn where Kubernetes came from, what Google built it to do inside its own infrastructure, and how it became the open-source industry standard it is today.

By the end of this module you will have a clear mental model of why Kubernetes exists — and that understanding will underpin everything you learn for the rest of the day.

Kubernetes architecture: understanding the cluster

With the context established, this module opens up the Kubernetes architecture — explaining how a Kubernetes cluster is structured and how its components work together to keep your applications running reliably, automatically, and at scale.

You will begin with the two fundamental parts of every Kubernetes cluster: the control plane and the worker nodes. The control plane is the brain of the cluster — you will learn what each of its components does, including the API server, the scheduler, the controller manager, and etcd, the distributed key-value store that holds the entire state of the cluster. Worker nodes are where your applications actually run — you will learn how the kubelet, kube-proxy, and container runtime work together on each node to receive instructions from the control plane and keep workloads running.

The module then introduces the Kubernetes object model — the way Kubernetes represents the desired state of your cluster. You will learn how to read and write YAML manifests, understand the structure that every Kubernetes object shares, and develop the mental model of declarative configuration that is central to how Kubernetes works. You tell Kubernetes what you want — and Kubernetes figures out how to make it happen and keep it that way.

By the end of this module you will be able to describe a Kubernetes cluster from the inside out and understand what is happening behind the scenes every time you interact with it.

Core Kubernetes objects: the building blocks of every application

Kubernetes is built around a set of objects that represent different aspects of how applications run. This module introduces the most important of those objects — giving you the practical knowledge to deploy, manage, and expose applications in a real Kubernetes environment.

Pods The Pod is the smallest deployable unit in Kubernetes — a wrapper around one or more containers that share the same network and storage context. You will learn what Pods are, how they work, when to use single-container versus multi-container Pods, and why you almost never manage Pods directly in production.

Deployments Deployments are the primary way to run and manage stateless applications in Kubernetes. You will learn how to create a Deployment, how Kubernetes uses ReplicaSets behind the scenes to maintain the desired number of running Pod replicas, and how to perform rolling updates and rollbacks — updating your application without any downtime.

Services Pods come and go — their IP addresses change every time they restart. Services provide a stable network endpoint that other parts of your application can rely on. You will learn the four types of Kubernetes Service — ClusterIP, NodePort, LoadBalancer, and ExternalName — and when to use each one to expose applications within the cluster or to the outside world.

ConfigMaps and Secrets Hard-coding configuration and credentials into container images is one of the most common mistakes in early Kubernetes usage. You will learn how to use ConfigMaps to separate application configuration from application code, and how to use Secrets to manage sensitive information — passwords, API keys, and certificates — securely within your cluster.

Namespaces As clusters grow, organisation becomes critical. You will learn how Namespaces divide a cluster into logical partitions — isolating teams, environments, and applications from each other within a single physical cluster.

Hands-on exercise: Deploying an application using Deployments, Services, ConfigMaps, and Secrets

Scheduling, scaling, and self-healing

One of the most powerful things about Kubernetes is its ability to manage the lifecycle of your applications automatically — placing workloads intelligently, scaling them in response to demand, and recovering from failure without manual intervention. This module covers the mechanisms that make all of that possible.

You will begin with the Kubernetes scheduler — learning how it decides which node to place each Pod on, based on resource requirements, node capacity, affinity rules, and taints and tolerations. Understanding how scheduling works gives you the ability to influence placement decisions and ensure your workloads land in the right place.

From there the module covers scaling — both manual and automatic. You will learn how to scale a Deployment manually and how the Horizontal Pod Autoscaler (HPA) automatically adjusts the number of running Pods based on CPU utilisation or custom metrics, ensuring your application can handle varying levels of demand without wasting resources.

The module then covers one of Kubernetes' most celebrated features — self-healing. You will learn how Kubernetes continuously monitors the state of your cluster against your declared desired state, automatically restarting failed containers, replacing Pods that have been terminated, and rescheduling workloads away from nodes that have gone down. You will see this in action in the hands-on exercise, deliberately breaking things and watching Kubernetes fix them.

Finally the module introduces resource requests and limits — the mechanism by which you tell Kubernetes how much CPU and memory each container needs, and the maximum it is allowed to use. Getting these right is one of the most important skills for running stable, cost-efficient Kubernetes environments in production.

Networking in Kubernetes

Networking in Kubernetes is one of the topics that confuses new practitioners most — and one of the most important to understand correctly. This module demystifies how traffic flows inside and outside a Kubernetes cluster, giving you the knowledge to design and troubleshoot networking configurations with confidence.

You will start with the Kubernetes networking model — the set of rules that governs how Pods communicate with each other across nodes, why every Pod gets its own IP address, and why Kubernetes networking behaves differently from traditional server networking. Understanding these fundamentals makes everything else in this module fall into place.

The module then covers Service networking in depth — how kube-proxy implements Service routing, how DNS works inside a cluster using CoreDNS, and how applications discover each other by name rather than by IP address. You will learn how ClusterIP Services route internal traffic and how NodePort and LoadBalancer Services expose applications to external clients.

From there the module introduces Ingress — the Kubernetes resource for managing external HTTP and HTTPS access to services within your cluster. You will learn what an Ingress controller is, how Ingress rules route traffic to different backend services based on hostname and path, and when to use Ingress rather than a LoadBalancer Service.

The module closes with an introduction to Network Policies — the Kubernetes mechanism for controlling which Pods are allowed to communicate with which other Pods and external endpoints. In a production environment, Network Policies are a critical security tool, and understanding them is essential for anyone working with Kubernetes beyond the basics.

Storage, configuration, and stateful workloads

Most introductory Kubernetes content focuses on stateless applications — and for good reason. But real-world applications often need to persist data, and understanding how Kubernetes handles storage is essential for anyone working with databases, file storage, or any application that needs to retain state between restarts.

You will begin with the core storage concepts: Volumes, PersistentVolumes, and PersistentVolumeClaims. You will learn the difference between ephemeral storage that lives and dies with a Pod and persistent storage that outlives it — understanding how PersistentVolumes represent storage resources in the cluster and how PersistentVolumeClaims allow Pods to request and use that storage in a decoupled, portable way.

The module introduces StatefulSets — the Kubernetes workload type designed for applications that require stable network identities, ordered deployment and scaling, and persistent storage per instance. You will understand when to use a StatefulSet instead of a Deployment and what guarantees StatefulSets provide that Deployments do not.

The module also revisits ConfigMaps and Secrets in a storage context — covering how to mount configuration files and sensitive data directly into a container's filesystem rather than passing them as environment variables, a pattern that is often more practical for complex application configurations.

Observability, troubleshooting, and production readiness

A Kubernetes cluster you cannot observe is a cluster you cannot operate. This final module brings the day together by covering the monitoring, logging, and troubleshooting skills that every Kubernetes practitioner needs to work effectively in a real environment — and the production readiness practices that separate learning environments from systems that organisations depend on.

You will start with the core kubectl commands for observability — learning how to inspect the state of every object in your cluster, read logs from running and failed containers, describe resources to understand their configuration and recent events, and use kubectl exec to connect directly to a running container for live troubleshooting. These skills are the first line of diagnosis for almost every issue you will encounter in a real cluster.

The module then covers Kubernetes events — the audit trail of everything that has happened in your cluster — and how to read them to understand why a Pod failed to schedule, why a container keeps crashing, or why a deployment is not progressing as expected.

From there the module introduces health checks — liveness probes and readiness probes — explaining what each one does, how Kubernetes uses them to determine whether a container is healthy and ready to serve traffic, and how to configure them correctly to prevent common production issues like traffic being routed to Pods that are not yet ready or containers that have deadlocked.

The module closes with an overview of production readiness considerations: resource requests and limits, Pod disruption budgets, horizontal scaling, multi-zone deployments, and the broader Kubernetes ecosystem — including Helm for package management, and the managed Kubernetes services available across AWS (EKS), Google Cloud (GKE), and Microsoft Azure (AKS) for teams that want to run Kubernetes without managing the control plane themselves.

What you will be able to do by the end of the day

By the time you complete this one-day programme you will be able to explain what Kubernetes is and why it was built, describe the architecture of a Kubernetes cluster and how its components interact, deploy and manage containerised applications using core Kubernetes objects, configure scaling, networking, and persistent storage for real-world workloads, troubleshoot common issues using kubectl and Kubernetes observability tools, and speak confidently about how Kubernetes fits into the broader cloud-native ecosystem.

A note on certification

This course is designed to give you introduction to Kubernetes — building the foundational knowledge and hands-on confidence you need to work with the platform in real environments. However, this ntroduction is not sufficient preparation for a professional Kubernetes certification exam on its own.

Certifications such as the Certified Kubernetes Administrator (CKA) and Certified Kubernetes Application Developer (CKAD) require a significantly deeper level of knowledge, extensive hands-on practice, and dedicated exam preparation beyond what a single day can provide. This course gives you the foundation those programmes build on — but they require their own structured preparation to pass with confidence.

If certification is your goal, speak to one of our advisers. We will map out the full learning path you need — from this introduction through to the advanced programmes and exam preparation that will get you there.

What comes next

This course is the recommended starting point for the following certifications and advanced programmes:

Certified Kubernetes Administrator (CKA) — the industry-standard certification for professionals who install, configure, manage, and troubleshoot Kubernetes clusters in production environments.

Certified Kubernetes Application Developer (CKAD) — focused on designing, building, and deploying applications on Kubernetes, ideal for developers who want to work with the platform at the application layer.

AWS DevOps Engineer — Professional — extend your Kubernetes knowledge into the full AWS ecosystem including Amazon EKS, CI/CD pipelines, and enterprise-scale infrastructure automation.

Google Cloud Professional DevOps Engineer — apply your Kubernetes skills within Google Cloud using Google Kubernetes Engine and the full Google Cloud operations toolchain.

Introduction to Google Kubernetes Engine (GCP-GSGKE) — if you want to go deeper into running Kubernetes specifically on Google Cloud, this one-day course builds directly on today's foundations.