Kubernetes - Simply Explained
Kubernetes is the world's most popular container orchestration platform, designed to automate the deployment, scaling, management, and recovery of containerized applications. Instead of manually managing hundreds or thousands of containers across multiple servers, Kubernetes continuously ensures that your applications are running, healthy, and available. Think of it as an intelligent operations manager that automatically places workloads, replaces failed containers, balances traffic, and scales applications based on demand.
In this episode of Microsoft Knowledge Nuggets, Mirko Peters explains Kubernetes in plain English without assuming prior DevOps knowledge. You'll learn why containers alone aren't enough for modern cloud applications and how Kubernetes solves the challenges of running distributed systems at scale. The episode introduces core concepts including clusters, nodes, pods, deployments, services, and ingress, showing how they work together to create resilient, self-healing applications.
The discussion also explores real-world scenarios where Kubernetes shines, from hosting microservices and APIs to powering enterprise applications and AI workloads across on-premises environments and public clouds such as Microsoft Azure. You'll discover how Kubernetes integrates with Azure Kubernetes Service (AKS), supports rolling updates with minimal downtime, automatically recovers from failures, and enables organizations to build highly scalable cloud-native applications.
Whether you're an IT professional, developer, architect, or business leader trying to understand why Kubernetes has become the industry standard for modern application deployment, this episode provides a practical introduction to its architecture, benefits, common use cases, and challenges. By the end, you'll understand why Kubernetes is considered one of the foundational technologies behind today's cloud-first and AI-powered infrastructure.
Kubernetes - Simply Explained is an open-source platform that automates the deployment, scaling, and management of containerized applications. It plays a crucial role in container management, helping you streamline your development and deployment processes. As organizations increasingly adopt cloud-native technologies, Kubernetes has become a key player—93% of surveyed organizations now use it. This rapid growth allows teams to deploy applications multiple times a day, compared to the slower quarterly releases of the past.
Whether you're a developer, IT professional, or cloud architect, this blog aims to simplify the complexities of Kubernetes - Simply Explained. You’ll find straightforward explanations that make understanding this powerful tool much easier.
Key Takeaways
- Kubernetes automates the deployment and management of containerized applications, making it easier to release updates frequently.
- It provides consistent environments for applications, reducing errors and improving team collaboration.
- Kubernetes enhances operational resilience with self-healing capabilities, ensuring applications remain available even during failures.
- Using Kubernetes can significantly lower infrastructure costs by optimizing resource utilization based on demand.
- It allows for multi-cloud flexibility, enabling applications to run across different cloud providers without vendor lock-in.
- Kubernetes simplifies scaling operations, automatically adjusting resources to handle traffic spikes effectively.
- Getting started with Kubernetes involves containerizing applications, defining manifests, and setting up CI/CD pipelines.
- Engaging with hands-on projects and utilizing available resources can help you master Kubernetes and improve your application management skills.
Kubernetes Overview
Key Features
Kubernetes is a powerful tool for managing containerized applications. It automates the deployment, scaling, and operation of application containers across clusters of hosts. This orchestration simplifies the complexities of managing applications in a cloud environment.
In the world of cloud computing, Kubernetes plays a vital role. It allows you to run applications in a consistent environment, whether on-premises or in the cloud. This flexibility means you can deploy your applications anywhere, avoiding vendor lock-in and optimizing resource allocation.
One of the standout features of Kubernetes is its automation capabilities. Here’s how it enhances your workflow:
- Faster deployments: Automation removes delays caused by manual tasks, enabling rapid and frequent releases.
- Consistent environments: Kubernetes ensures the same deployment process is followed across staging, testing, and production.
- Fewer errors: It reduces the chance of mistakes caused by manual configuration or deployment steps.
- Scalable operations: You can easily handle deployment across multiple services and clusters without extra manual effort.
- Improved team collaboration: Shared, version-controlled pipelines increase visibility and coordination among teams.
- Quick rollbacks: Automated tracking of deployments makes it easier to revert to a known good state when needed.
Kubernetes also supports Infrastructure as Code (IaC), allowing you to define and manage your infrastructure through declarative configuration files. This approach makes provisioning Kubernetes clusters and necessary cloud resources automated and repeatable.
When it comes to scalability and reliability, Kubernetes shines. Its architecture supports modularity, which is crucial for maintaining high availability in production environments. Here are some key points:
- Kubernetes provides flexibility and options for scaling deployments effectively.
- It integrates with CI/CD processes to enhance operational efficiency.
- Automatic pod restarts and workload migration ensure that your applications remain available, even during failures.
- Health checks for nodes and pods help the system recover from issues without manual intervention.
- The Horizontal Pod Autoscaler (HPA) adjusts the number of replicas based on real-time demand, helping your applications handle sudden traffic spikes.
Why Kubernetes Matters
In today's fast-paced tech landscape, traditional deployment methods often struggle to keep up. You might find yourself dealing with long release cycles, manual configurations, and a lack of flexibility. These challenges can lead to downtime, increased costs, and frustrated teams. But Kubernetes changes the game.
Benefits of Using Kubernetes
Kubernetes offers a range of benefits that can transform how your organization deploys and manages applications. Here are some key advantages:
Accelerated Time-to-Market: With Kubernetes, you can automate your deployment pipelines. This means you can release updates multiple times a day, just like Netflix, which deploys over 1,000 changes daily. This speed gives you a competitive edge.
Improved Operational Resilience: Kubernetes has self-healing capabilities. If a container fails, Kubernetes automatically restarts it, ensuring your applications stay available. Organizations have reported a 99.9% uptime improvement and a 75% reduction in incident response time.
Cost Optimization: Kubernetes optimizes resource utilization. It scales applications based on demand, which can significantly reduce infrastructure costs. For instance, Spotify managed to cut costs by 40% after adopting Kubernetes.
Multi-Cloud Flexibility: Kubernetes allows you to run applications consistently across various cloud providers. This flexibility prevents vendor lock-in and supports hybrid cloud strategies, giving you more control over your infrastructure.
To illustrate these benefits further, take a look at the table below:
| Benefit | Description | Measurable Impact |
|---|---|---|
| Accelerated Time-to-Market | Enables continuous deployment through automated pipelines, allowing multiple releases daily. | Netflix deploys over 1,000 changes daily. |
| Improved Operational Resilience | Self-healing capabilities maintain application availability, with automatic restarts of failed containers. | 99.9% uptime improvements, 75% reduction in incident response time. |
| Cost Optimization | Optimizes resource utilization and scales applications based on demand, reducing infrastructure costs. | Spotify reduced costs by 40%. |
| Multi-Cloud Flexibility | Consistent operations across various cloud providers, preventing vendor lock-in. | Enables hybrid cloud strategies. |
Kubernetes also enhances service reliability compared to legacy deployment solutions. It minimizes downtime risks and simplifies rollbacks. Here’s how different strategies stack up:
| Strategy | Downtime Risk | Rollback Complexity | Cost Impact | Best Use Cases |
|---|---|---|---|---|
| Recreate | High | Simple | Low | Internal apps, noncritical systems, maintenance windows |
| Rolling Update | Low | Moderate | Medium | Most web apps and APIs with backward-compatible changes |
| Blue/Green | Very Low | Very Simple | High | High-stakes releases, compliance-heavy environments |
| Canary | Very Low | Complex | Medium–High | Gradual, metric-driven rollouts to reduce blast radius |
| A/B Testing | Low | Complex | Medium–High | Product experiments tied to business metrics |
| Shadow | None | Simple | High | Testing with real traffic before serving user responses |
By adopting Kubernetes, you can standardize environments across development, staging, and production. This standardization accelerates onboarding and reduces debugging time. Plus, Kubernetes integrates seamlessly with DevSecOps practices, embedding security into your delivery workflows.
How Kubernetes Works
Kubernetes operates through a well-defined architecture that consists of clusters and nodes. A Kubernetes cluster is a set of nodes that run containerized applications. Each cluster has a control plane that manages the cluster's state and worker nodes that run the applications.
Control Plane Functionality
The control plane is the brain of your Kubernetes cluster. It manages the entire system and ensures everything runs smoothly. Here’s a quick overview of its main components:
| Component | Description |
|---|---|
| Control Plane | Hosts components used to manage the Kubernetes cluster. |
| Worker Nodes | Can be VMs or physical machines that host pods running containers. |
| API Server | Serves as the front end of the control plane, handling requests and processing them. |
| Scheduler | Assigns pods to nodes based on resource requirements and other conditions. |
| Controller Manager | Monitors and regulates the state of the cluster, ensuring it matches the desired state. |
| etcd | A distributed key-value store that maintains cluster state and configuration data. |
| Cloud Controller Manager | Connects the Kubernetes cluster with cloud provider APIs, managing cloud-specific control logic. |
The control plane communicates with worker nodes using the kubelet, an agent on each node. When you deploy applications, the control plane schedules the containers to run on the nodes. It continuously checks the actual state against the desired state, ensuring your applications run smoothly.
The Role of Pods in Application Management
Kubernetes pods are the smallest deployable units in the system. Each pod can contain one or more containers that share storage and network resources. Pods play a crucial role in scaling applications. For instance, the Horizontal Pod Autoscaler (HPA) automatically adjusts the number of pods based on CPU usage. This means when demand increases, Kubernetes adds more pods, and when demand decreases, it reduces them.
Here’s how different scaling methods work:
| Scaling Method | Description |
|---|---|
| Horizontal Pod Autoscaler (HPA) | Automatically adjusts the number of pods based on CPU usage thresholds. |
| Vertical Pod Autoscaler (VPA) | Adjusts resource allocations for existing pods based on workload demands. |
| Cluster Autoscaler | Works with HPA and VPA to dynamically scale the underlying infrastructure. |
Orchestrating Operations
The control plane orchestrates operations by maintaining the desired state of the cluster. It determines where and when to scale containers. Kubernetes uses schedulers to allocate workloads to appropriate nodes and controllers to ensure configurations match reality. This orchestration allows you to focus on building applications rather than managing infrastructure.
Automated Deployments and Scaling
Kubernetes simplifies deployments through automation. Here are some features that enable this:
- CI/CD Pipelines: Automate the building, testing, and deployment of code changes.
- Infrastructure as Code (IaC): Codifies the deployment process, allowing for reproducibility.
- GitOps: Uses Git as a single source of truth for managing deployments.
With these features, you can ensure that your applications are always up-to-date and running efficiently.
Kubernetes vs. Docker
When diving into the world of containerization, you’ll often hear about Kubernetes and Docker. While they both play crucial roles in modern application development, they serve different purposes. Let’s break it down.
Understanding the Technologies
- Docker is primarily a platform for creating and running containers. It packages applications and their dependencies into a single unit, making it easy to deploy across different environments.
- Kubernetes, on the other hand, is a container orchestration tool. It manages the deployment, scaling, and operation of those containers across clusters of machines.
In essence, Docker handles the "what" of containerization, while Kubernetes takes care of the "how" in managing those containers.
When to Use Kubernetes Over Docker
You might wonder when it’s best to opt for Kubernetes instead of just using Docker. Here are some scenarios where Kubernetes shines:
| Scenario | Description |
|---|---|
| Load Balancing | Kubernetes efficiently allocates resources and balances loads, preventing server-level imbalances. |
| Authentication and Security | It simplifies handling security and authentication at the infrastructure level across platforms. |
| Multi-platform Deployment | Kubernetes coordinates complex tasks in multi-platform and multi-cloud environments effectively. |
If your application requires high availability, automated scaling, or complex deployments, Kubernetes is the way to go. It excels in managing large-scale applications and can handle the intricacies of microservices architectures.
How They Work Together
Docker and Kubernetes complement each other beautifully in modern DevOps workflows. Here’s how:
- Docker creates and runs containers at the application level.
- Kubernetes manages those containers at the infrastructure level, ensuring deployment, scaling, and maintenance across clusters.
- Together, they simplify development processes, accelerate deployment times, and optimize scaling in modern application environments.
By using both, you can leverage the strengths of each technology. Docker makes it easy to build and package your applications, while Kubernetes ensures they run smoothly in production.
Getting Started with Kubernetes
Getting started with Kubernetes can feel overwhelming, but it doesn't have to be! Let’s break it down into manageable steps. First, you need to understand the basic setup requirements for your Kubernetes cluster.
Basic Setup Requirements
To set up Kubernetes, you’ll need both hardware and software resources. Here’s a quick overview of what you’ll need:
| Component | Requirements |
|---|---|
| Stateless Nodes | 1–2 TB SSDs for OS and container space |
| Shared Storage | NFS, iSCSI, or SAN for persistent data |
| Scale-Out Hardware | 8–16 cores, 64-128 GB RAM |
| Networking | At least 10 Gbps |
For the nodes themselves, here are some minimum specifications:
- Master node: 2 GB RAM, 1.5 CPU cores
- Worker node: 700 MB RAM, 0.5 CPU cores
With these requirements in mind, you can start planning your Kubernetes deployment.
First Steps for Deployment
Now that you have your setup ready, let’s dive into the initial steps for deploying your first application using Kubernetes. Follow these steps to get started:
- Containerize your application: Write a Dockerfile to package your application and its dependencies. Build and push the image to a container registry.
- Define Kubernetes manifests: Create YAML files for Kubernetes objects like deployments and services. You can use tools like Helm or Kustomize to manage these files.
- Set up a CI/CD pipeline: Choose a CI/CD platform and define a pipeline that includes building, testing, and deploying your application.
- Store configuration in version control: Keep all deployment-related files in a Git repository. This helps with auditing and collaboration.
Common Challenges
As you embark on your Kubernetes journey, you might face some challenges. Beginners often struggle with security and the complexity of maintaining Kubernetes. Misconfigurations can lead to data exposure and service compromise. To mitigate these issues, consider working with managed service providers or investing in training to build your expertise.
Resources for Learning
If you're looking for resources to help you along the way, check out these helpful links:
- What Is Kubernetes? Finally, a Simple Explanation!
- Kubernetes Tutorial: Deploy Your First App on Kubernetes Today
- Hands-on Labs
With these steps and resources, you’re well on your way to mastering Kubernetes. Remember, practice makes perfect, so don’t hesitate to experiment and learn as you go!
Kubernetes is a game-changer in modern application management. It simplifies complex processes by using declarative configuration files and automating deployment, scaling, and updates. This means you can focus on building great applications instead of getting bogged down in manual tasks.
As you consider adopting Kubernetes, remember these key takeaways:
- Implement standards and automate policies for consistency.
- Plan your cluster architecture carefully for optimal performance.
- Integrate Kubernetes with your existing infrastructure.
To deepen your understanding, explore advanced resources like tools for cluster management, observability, and security. Engaging with hands-on projects can also solidify your skills. Embrace the power of Kubernetes and watch your applications thrive! 🚀
FAQ
What is Kubernetes used for?
Kubernetes automates the deployment, scaling, and management of containerized applications. It helps you manage workloads efficiently across clusters of machines.
Is Kubernetes difficult to learn?
While Kubernetes has a learning curve, many resources simplify the process. With practice and hands-on experience, you can become proficient.
Can I run Kubernetes on my laptop?
Yes! You can run Kubernetes locally using tools like Minikube or Docker Desktop. This setup is great for testing and development.
What are Pods in Kubernetes?
Pods are the smallest deployable units in Kubernetes. They can contain one or more containers that share storage and network resources.
How does Kubernetes handle scaling?
Kubernetes uses the Horizontal Pod Autoscaler (HPA) to automatically adjust the number of pods based on CPU usage or other metrics.
What is a Kubernetes Cluster?
A Kubernetes cluster consists of a control plane and worker nodes. It manages the deployment and operation of containerized applications.
Can I use Kubernetes with any cloud provider?
Absolutely! Kubernetes is cloud-agnostic, meaning you can run it on any cloud provider or even on-premises, giving you flexibility.
What is the difference between Kubernetes and Docker?
Docker is a platform for creating and running containers, while Kubernetes orchestrates those containers, managing their deployment and scaling.
🚀 Want to be part of m365.fm?
Then stop just listening… and start showing up.
👉 Connect with me on LinkedIn and let’s make something happen:
- 🎙️ Be a podcast guest and share your story
- 🎧 Host your own episode (yes, seriously)
- 💡 Pitch topics the community actually wants to hear
- 🌍 Build your personal brand in the Microsoft 365 space
This isn’t just a podcast — it’s a platform for people who take action.
🔥 Most people wait. The best ones don’t.
👉 Connect with me on LinkedIn and send me a message:
"I want in"
Let’s build something awesome 👊
1
00:00:00,000 --> 00:00:04,620
Today we're talking about something almost everyone is heard of but can't explain Kubernetes.
2
00:00:04,620 --> 00:00:08,440
It's confusing because it solves a problem most people don't see until they hit it.
3
00:00:08,440 --> 00:00:11,800
Everyone knows it matters, but ask what it does and you'll get a blank stare.
4
00:00:11,800 --> 00:00:15,940
It's not a docker replacement or a cloud operating system, though people often guess that.
5
00:00:15,940 --> 00:00:20,680
The confusion makes sense because Kubernetes solves a problem you don't know exists until you face it.
6
00:00:20,680 --> 00:00:24,640
It's a tool that becomes essential once you have more than a handful of containers to manage.
7
00:00:24,640 --> 00:00:28,180
By the end of this episode you'll understand what Kubernetes actually is,
8
00:00:28,180 --> 00:00:32,720
how it fits with containers and why Azure Kubernetes servers makes it practical for teams
9
00:00:32,720 --> 00:00:34,700
that don't want to build everything from scratch.
10
00:00:34,700 --> 00:00:36,900
Grab your coffee and let's dive in.
11
00:00:36,900 --> 00:00:39,700
The problem before containers, let's go back to the problem.
12
00:00:39,700 --> 00:00:41,700
Picture a software company 10 years ago.
13
00:00:41,700 --> 00:00:46,660
You have a few applications to run so you buy servers, install operating systems and deploy everything manually.
14
00:00:46,660 --> 00:00:50,180
Each app gets its own machine and you cannot share resources between them.
15
00:00:50,180 --> 00:00:53,240
If one app needs a lot of memory and another barely uses any,
16
00:00:53,240 --> 00:00:55,100
they each get their own server anyway.
17
00:00:55,100 --> 00:00:59,920
The waste was huge, servers ran at maybe 20% capacity, but you could not consolidate them
18
00:00:59,920 --> 00:01:02,660
because the applications would fight over dependencies.
19
00:01:02,660 --> 00:01:05,800
You ended up with a room full of servers, each barely doing any work,
20
00:01:05,800 --> 00:01:09,840
each consuming power and cooling and all of them needing constant maintenance.
21
00:01:09,840 --> 00:01:12,700
One app needs Python 3.7, another needs Python 3.8,
22
00:01:12,700 --> 00:01:14,600
one needs an older library, another needs the latest.
23
00:01:14,600 --> 00:01:18,040
You cannot run them on the same machine without breaking something so you buy more servers
24
00:01:18,040 --> 00:01:20,400
and pay for hardware that mostly sits idle.
25
00:01:20,400 --> 00:01:24,520
Virtual machines helped a little by letting you slice a physical server into smaller pieces,
26
00:01:24,520 --> 00:01:29,420
each running its own OS, but each VM is heavy with a full OS that takes up disk space and memory
27
00:01:29,420 --> 00:01:31,020
and takes minutes to start.
28
00:01:31,020 --> 00:01:33,980
And you had to configure each one separately, which was a lot of work.
29
00:01:33,980 --> 00:01:38,520
You are still managing all those operating systems, patching, updating and securing them.
30
00:01:38,520 --> 00:01:40,820
Teams needed something lighter and portable,
31
00:01:40,820 --> 00:01:45,860
a way to package an application with everything it needs to run without the overhead of a full virtual machine
32
00:01:45,860 --> 00:01:48,420
and that could be moved easily between machines.
33
00:01:48,420 --> 00:01:50,020
That's where containers came in.
34
00:01:50,020 --> 00:01:51,920
What containers actually are?
35
00:01:51,920 --> 00:01:56,120
A container is a small package that includes your application and everything it needs to run.
36
00:01:56,120 --> 00:02:01,120
That means the code, the runtime, the libraries and the configuration files are all bundled together in one unit.
37
00:02:01,120 --> 00:02:03,420
Think of it like a shipping container for software.
38
00:02:03,420 --> 00:02:08,920
A shipping container can go on a truck, a train or a ship, and the container itself stays the same.
39
00:02:08,920 --> 00:02:10,720
Your software container works the same way.
40
00:02:10,720 --> 00:02:15,820
You build it once and it runs the same on your laptop, your test server, and your production environment.
41
00:02:15,820 --> 00:02:19,420
The key difference between containers and virtual machines is how efficient they are.
42
00:02:19,420 --> 00:02:25,220
A virtual machine runs its own full operating system, so each VM has its own kernel, system files and everything else.
43
00:02:25,220 --> 00:02:27,420
A container shares the host operating system.
44
00:02:27,420 --> 00:02:30,220
It's just a process with its own isolated view of the world.
45
00:02:30,220 --> 00:02:33,420
That means containers start in seconds, not minutes.
46
00:02:33,420 --> 00:02:36,920
They use less memory and you can pack more of them onto a single machine.
47
00:02:36,920 --> 00:02:42,220
Docker made containers popular by giving developers a simple way to build and run them with a single command.
48
00:02:42,220 --> 00:02:45,920
Suddenly, the it works on my machine problems started to disappear.
49
00:02:45,920 --> 00:02:49,920
If your application runs in a container on your laptop, it will run the same way on the server.
50
00:02:49,920 --> 00:02:54,420
The environment is consistent everywhere, but containers solve one problem and create another.
51
00:02:54,420 --> 00:02:57,520
With a handful of containers, manual management works fine.
52
00:02:57,520 --> 00:03:00,220
You can start them, stop them, and keep track of them yourself.
53
00:03:00,220 --> 00:03:01,920
But what happens when you have hundreds of them?
54
00:03:01,920 --> 00:03:06,520
You need to decide which server runs, which container, restart, failed ones, connect them to each other,
55
00:03:06,520 --> 00:03:08,220
and scale them up when traffic spikes.
56
00:03:08,220 --> 00:03:11,520
That's a new challenge and that's exactly where Kubernetes comes in.
57
00:03:11,520 --> 00:03:12,820
The orchestration problem.
58
00:03:12,820 --> 00:03:17,420
So you've got containers working, you package your application, it runs consistently everywhere and life is good.
59
00:03:17,420 --> 00:03:21,320
But only for a while, with 10 or 20 containers you can manage things manually.
60
00:03:21,320 --> 00:03:25,120
You know which server runs, which container you can restart something if it crashes,
61
00:03:25,120 --> 00:03:27,020
and you can update a few things here and there.
62
00:03:27,020 --> 00:03:29,620
It's manageable, but then your application grows.
63
00:03:29,620 --> 00:03:34,420
You move to microservices, so instead of one big application, you have 20 smaller ones.
64
00:03:34,420 --> 00:03:39,120
Each one needs multiple copies running for reliability, and now you're looking at 200 containers.
65
00:03:39,120 --> 00:03:44,720
Manual management doesn't work anymore. You need to decide which server runs each container, restart containers when they fail,
66
00:03:44,720 --> 00:03:46,620
and connect them so they can communicate.
67
00:03:46,620 --> 00:03:51,020
You also need to scale up when traffic spikes, maybe during a sale or a product launch,
68
00:03:51,020 --> 00:03:53,220
and scale back down when things quiet down.
69
00:03:53,220 --> 00:03:58,620
And you need to roll out updates without downtime, which means replacing old containers with new ones one at a time,
70
00:03:58,620 --> 00:04:00,720
carefully, without breaking anything.
71
00:04:00,720 --> 00:04:04,720
These are orchestration problems, and they're exactly what Kubernetes was built to solve.
72
00:04:04,720 --> 00:04:10,220
Kubernetes is an open source platform that automates deploying, scaling, and managing containerized applications.
73
00:04:10,220 --> 00:04:15,820
Think of it as the operating system for your data center, just like Windows or Linux manages the resources on a single computer,
74
00:04:15,820 --> 00:04:20,620
like CPU, memory, and disk, Kubernetes manages the resources across all your servers.
75
00:04:20,620 --> 00:04:23,820
It treats all your machines as one big pool of computing power.
76
00:04:23,820 --> 00:04:29,820
You tell it what you want to run, and it figures out where to put it, how to keep it running, and how to connect it to everything else.
77
00:04:29,820 --> 00:04:32,620
Core concepts, pods, nodes, and clusters.
78
00:04:32,620 --> 00:04:34,820
Let's look at how Kubernetes actually works.
79
00:04:34,820 --> 00:04:37,120
The smallest unit in Kubernetes is called a pod.
80
00:04:37,120 --> 00:04:41,720
A pod wraps one or more containers, containers inside the same pod share storage and networking,
81
00:04:41,720 --> 00:04:43,620
so they can talk to each other over local host.
82
00:04:43,620 --> 00:04:46,120
You can think of a pod as a single unit of deployment.
83
00:04:46,120 --> 00:04:48,520
You don't deploy containers directly in Kubernetes.
84
00:04:48,520 --> 00:04:49,620
You deploy pods.
85
00:04:49,620 --> 00:04:51,920
Pods don't run on their own. They run on nodes.
86
00:04:51,920 --> 00:04:54,520
A node is a server, either physical or virtual.
87
00:04:54,520 --> 00:04:56,420
That's part of your Kubernetes cluster.
88
00:04:56,420 --> 00:05:00,520
Each node runs the software needed to run pods, plus a few other things will get to in a moment.
89
00:05:00,520 --> 00:05:04,120
A cluster is the collection of all nodes, managed as one unified system.
90
00:05:04,120 --> 00:05:09,920
In simple terms, a pod is your application, a node is where it runs, and a cluster is the entire environment.
91
00:05:09,920 --> 00:05:10,820
Pods are ephemeral.
92
00:05:10,820 --> 00:05:13,020
They can be created, destroyed, or moved at any time.
93
00:05:13,020 --> 00:05:13,720
That's by design.
94
00:05:13,720 --> 00:05:16,320
If a node fails, Kubernetes moves the pods to another one.
95
00:05:16,320 --> 00:05:18,320
For scaling up, it creates new pods.
96
00:05:18,320 --> 00:05:21,020
And when a pod crashes, it gets replaced automatically.
97
00:05:21,020 --> 00:05:23,320
The whole system treats pods as temporary.
98
00:05:23,320 --> 00:05:25,620
But if pods come and go, you need a way to talk to them.
99
00:05:25,620 --> 00:05:28,820
Instead of talking to a pod directly, you talk to a service.
100
00:05:28,820 --> 00:05:33,520
A service provides a stable network address that routes traffic to the right pods, even as pods change.
101
00:05:33,520 --> 00:05:36,320
Imagine a hotel. The hotel's phone number is the service.
102
00:05:36,320 --> 00:05:39,320
Rooms change guests all the time, but the phone number stays the same.
103
00:05:39,320 --> 00:05:41,920
You call the front desk, and they root your call to the right room.
104
00:05:41,920 --> 00:05:44,120
That's exactly what a service does in Kubernetes.
105
00:05:44,120 --> 00:05:48,920
It gives you a fixed address that always points to whatever pods are currently running your application.
106
00:05:48,920 --> 00:05:51,720
The control plane, the brain of the cluster.
107
00:05:51,720 --> 00:05:53,920
So you have pods, nodes, and a cluster.
108
00:05:53,920 --> 00:05:56,120
The question is, who decides what runs where?
109
00:05:56,120 --> 00:05:57,420
That's the job of the control plane.
110
00:05:57,420 --> 00:06:00,820
Every Kubernetes cluster has one, and it's the brain of the whole operation.
111
00:06:00,820 --> 00:06:02,620
All the decisions happen here.
112
00:06:02,620 --> 00:06:04,020
The control plane has several components.
113
00:06:04,020 --> 00:06:07,220
The first one is the API server, which access the front door to your cluster.
114
00:06:07,220 --> 00:06:12,220
Every command you send to Kubernetes, whether it's from the command line, a dashboard, or an automated script,
115
00:06:12,220 --> 00:06:13,720
goes through the API server.
116
00:06:13,720 --> 00:06:17,020
It authenticates your request, checks if you're allowed to do what you're asking,
117
00:06:17,020 --> 00:06:19,120
and then passes it along to the right place.
118
00:06:19,120 --> 00:06:22,720
Nothing happens in Kubernetes without first going through the API server.
119
00:06:22,720 --> 00:06:26,020
Next is the scheduler, which decides which node runs each pod.
120
00:06:26,020 --> 00:06:30,020
When you say, "I want this application running," the scheduler looks at all the available nodes,
121
00:06:30,020 --> 00:06:34,020
checks their available resources, like CPU, memory, and disk space,
122
00:06:34,020 --> 00:06:35,720
and picks the best one for the job.
123
00:06:35,720 --> 00:06:38,920
It's like a hotel manager assigning rooms based on what each guest needs.
124
00:06:38,920 --> 00:06:40,920
A guest with a lot of luggage gets a bigger room,
125
00:06:40,920 --> 00:06:45,720
while a lightweight application gets a smaller node with spare capacity, then there's the controller manager.
126
00:06:45,720 --> 00:06:47,720
This component keeps an eye on the cluster,
127
00:06:47,720 --> 00:06:50,020
and makes sure the actual state matches what you declared.
128
00:06:50,020 --> 00:06:52,720
You said you want three copies of your web app running.
129
00:06:52,720 --> 00:06:55,920
The controller manager checks that there are actually three copies running.
130
00:06:55,920 --> 00:06:58,620
If one crashes, it notices and starts a replacement.
131
00:06:58,620 --> 00:07:01,620
If someone accidentally deletes a pod, it creates a new one.
132
00:07:01,620 --> 00:07:04,120
It's the component that keeps your cluster honest.
133
00:07:04,120 --> 00:07:07,320
And finally, there's ETCD, which is the cluster's database.
134
00:07:07,320 --> 00:07:11,220
It stores everything like what's running, where it's running, and how it's configured.
135
00:07:11,220 --> 00:07:13,620
It's the source of truth for the entire cluster.
136
00:07:13,620 --> 00:07:18,020
If the API server is the front door, then ETCD is the filing cabinet in the back office
137
00:07:18,020 --> 00:07:19,320
where all the records are kept.
138
00:07:19,320 --> 00:07:22,020
The beauty of this design is that you describe what you want,
139
00:07:22,020 --> 00:07:23,820
and Kubernetes figures out how to make it real.
140
00:07:23,820 --> 00:07:25,320
You don't tell it how to do things.
141
00:07:25,320 --> 00:07:27,120
You tell it what the end result should look like.
142
00:07:27,120 --> 00:07:31,720
That's the declarative model, and it's the core idea behind everything Kubernetes does.
143
00:07:31,720 --> 00:07:34,320
Workloads, deployments, services, and scaling.
144
00:07:34,320 --> 00:07:37,720
So let's talk about how you actually run applications on Kubernetes.
145
00:07:37,720 --> 00:07:39,020
You won't create pods directly.
146
00:07:39,020 --> 00:07:41,720
Instead, you'll use a higher-level object called a deployment.
147
00:07:41,720 --> 00:07:44,320
Think of a deployment as a manager that tells Kubernetes
148
00:07:44,320 --> 00:07:46,320
how many copies of your pod should run,
149
00:07:46,320 --> 00:07:50,120
which container image to use, and how to update them when a new version comes out.
150
00:07:50,120 --> 00:07:52,520
It's the standard way to run stateless applications.
151
00:07:52,520 --> 00:07:55,720
When you update a deployment, say you push a new version of your app,
152
00:07:55,720 --> 00:07:57,720
Kubernetes performs a rolling update.
153
00:07:57,720 --> 00:08:01,220
It replaces pods one by one, making sure at least one copy is always running.
154
00:08:01,220 --> 00:08:04,220
That means no downtime and no sudden interruption for your users.
155
00:08:04,220 --> 00:08:06,220
And if something goes wrong with the new version,
156
00:08:06,220 --> 00:08:09,120
you can roll back to the previous version with a single command.
157
00:08:09,120 --> 00:08:12,420
That's a powerful safety net, but your pods still need to be reachable.
158
00:08:12,420 --> 00:08:13,820
That's where services come in.
159
00:08:13,820 --> 00:08:17,620
A service provides a stable network address that roots traffic to the right pods.
160
00:08:17,620 --> 00:08:20,920
It can also expose those pods to other parts of your application
161
00:08:20,920 --> 00:08:22,520
or to the outside world.
162
00:08:22,520 --> 00:08:25,820
A service can be internal, only accessible within the cluster,
163
00:08:25,820 --> 00:08:29,620
or external, with a public IP address that users can reach from the internet.
164
00:08:29,620 --> 00:08:31,320
Now here's the thing about scaling.
165
00:08:31,320 --> 00:08:34,820
Kubernetes can automatically grow and shrink your application based on demand.
166
00:08:34,820 --> 00:08:37,420
You set a target, say 70% CPU usage,
167
00:08:37,420 --> 00:08:40,620
and Kubernetes adds more pods when usage goes above that threshold
168
00:08:40,620 --> 00:08:42,620
and removes them when it drops.
169
00:08:42,620 --> 00:08:44,720
Your application scales up during a traffic spike
170
00:08:44,720 --> 00:08:46,820
and scales back down when things quiet down.
171
00:08:46,820 --> 00:08:49,920
No manual intervention needed, but all this power comes with complexity.
172
00:08:49,920 --> 00:08:53,420
Running your own Kubernetes cluster means you're responsible for the control plane,
173
00:08:53,420 --> 00:08:55,820
upgrades, security patches and backups.
174
00:08:55,820 --> 00:09:00,620
You need deep expertise to handle node failures, network configuration, and cluster scaling.
175
00:09:00,620 --> 00:09:04,120
Many teams spend more time managing the cluster than they do building applications.
176
00:09:04,120 --> 00:09:06,420
And that's where managed Kubernetes comes in.
177
00:09:06,420 --> 00:09:08,520
Self-managed version managed Kubernetes.
178
00:09:08,520 --> 00:09:11,320
So let's talk about the reality of running Kubernetes yourself.
179
00:09:11,320 --> 00:09:13,820
When you set up your own cluster, you're responsible for everything.
180
00:09:13,820 --> 00:09:17,620
The control plane upgrades security patches and ETCD backups.
181
00:09:17,620 --> 00:09:20,320
If the API server goes down, that's your problem.
182
00:09:20,320 --> 00:09:24,720
If a security vulnerability is discovered in the version you're running, you need to patch it.
183
00:09:24,720 --> 00:09:27,620
If ETCD gets corrupted, you need to restore from backup.
184
00:09:27,620 --> 00:09:29,320
All of this requires deep expertise.
185
00:09:29,320 --> 00:09:32,920
You need to understand how nodes fail, how networking works at the cluster level
186
00:09:32,920 --> 00:09:34,720
and how to scale things without breaking them.
187
00:09:34,720 --> 00:09:36,820
Here's the thing that surprises a lot of teams.
188
00:09:36,820 --> 00:09:39,720
Many organizations spend more time managing their Kubernetes cluster
189
00:09:39,720 --> 00:09:42,020
than they do building the applications that run on it.
190
00:09:42,020 --> 00:09:45,220
They're constantly fighting with upgrades, troubleshooting networking issues
191
00:09:45,220 --> 00:09:46,720
and dealing with node failures.
192
00:09:46,720 --> 00:09:48,220
The cluster becomes a full-time job.
193
00:09:48,220 --> 00:09:50,820
That's not why you adopted Kubernetes in the first place.
194
00:09:50,820 --> 00:09:53,120
This is where managed Kubernetes services come in.
195
00:09:53,120 --> 00:09:57,820
Services like Azure Kubernetes service or AKS handle the control plane for you.
196
00:09:57,820 --> 00:10:02,120
Azure manages the API server ETCD, the scheduler and the controller manager.
197
00:10:02,120 --> 00:10:04,520
You don't have to worry about patching them or keeping them running.
198
00:10:04,520 --> 00:10:08,620
You just pay for the worker nodes, the virtual machines that actually run your workloads.
199
00:10:08,620 --> 00:10:10,020
The control plane itself is free.
200
00:10:10,020 --> 00:10:11,820
This changes the equation dramatically.
201
00:10:11,820 --> 00:10:14,020
Instead of spending your time on cluster maintenance,
202
00:10:14,020 --> 00:10:16,320
your team can focus on what actually matters.
203
00:10:16,320 --> 00:10:17,820
The application is your building.
204
00:10:17,820 --> 00:10:19,920
For most teams, especially those just starting out,
205
00:10:19,920 --> 00:10:21,920
managed Kubernetes is the right choice.
206
00:10:21,920 --> 00:10:25,620
You get all the power of Kubernetes without the operational overhead.
207
00:10:25,620 --> 00:10:27,720
AKS Kubernetes made simple on Azure.
208
00:10:27,720 --> 00:10:29,220
So what exactly is AKS?
209
00:10:29,220 --> 00:10:31,020
It's Azure's managed Kubernetes service,
210
00:10:31,020 --> 00:10:34,520
giving you a full-featured cluster without building it from scratch.
211
00:10:34,520 --> 00:10:36,420
The control plane is free as we mentioned,
212
00:10:36,420 --> 00:10:39,320
so you only pay for the virtual machines running your workloads.
213
00:10:39,320 --> 00:10:43,820
That means you can start small, pay very little and scale up as your needs grow.
214
00:10:43,820 --> 00:10:45,820
As you are handled all the heavy lifting,
215
00:10:45,820 --> 00:10:49,920
upgrades, patching and health monitoring for the control plane are all taken care of.
216
00:10:49,920 --> 00:10:53,720
You don't need a dedicated team of Kubernetes experts just to keep things running.
217
00:10:53,720 --> 00:10:56,520
And because AKS is part of the Azure ecosystem,
218
00:10:56,520 --> 00:10:59,420
it integrates with tools you're probably already using.
219
00:10:59,420 --> 00:11:01,820
Azure Active Directory for authentication,
220
00:11:01,820 --> 00:11:03,920
Azure Monitor for logging and metrics,
221
00:11:03,920 --> 00:11:05,920
and Azure Policy for Governance.
222
00:11:05,920 --> 00:11:07,720
They all work together out of the box,
223
00:11:07,720 --> 00:11:09,420
no bolting on separate pieces,
224
00:11:09,420 --> 00:11:14,220
setting up CI/CD pipelines with GitHub actions or Azure DevOps takes just minutes.
225
00:11:14,220 --> 00:11:15,920
Push a change to your repository,
226
00:11:15,920 --> 00:11:18,220
and it automatically builds a new container image,
227
00:11:18,220 --> 00:11:21,820
pushes it to Azure Container Registry and updates your deployment on AKS.
228
00:11:21,820 --> 00:11:25,420
No manual steps, no SSH into servers, it's all automated.
229
00:11:25,420 --> 00:11:28,020
For beginners, there's AKS automatic mode,
230
00:11:28,020 --> 00:11:31,620
designed for teams that don't want to make every decision about cluster configuration.
231
00:11:31,620 --> 00:11:35,520
It provides ready to use defaults for scaling, networking, security and upgrades.
232
00:11:35,520 --> 00:11:38,220
You don't have to become a Kubernetes expert to get started.
233
00:11:38,220 --> 00:11:40,920
Just describe your application and AKS handles the rest.
234
00:11:40,920 --> 00:11:42,620
One command gives you a cluster,
235
00:11:42,620 --> 00:11:44,820
one manifest file gets your application running.
236
00:11:44,820 --> 00:11:47,620
The skills you learn on AKS transfer to any Kubernetes environment
237
00:11:47,620 --> 00:11:49,620
because it's standard Kubernetes under the hood.
238
00:11:49,620 --> 00:11:51,620
You're not learning a proprietary system,
239
00:11:51,620 --> 00:11:55,920
you're learning the real thing with Azure handling the operational complexity.
240
00:11:55,920 --> 00:11:57,620
So now you have the big picture,
241
00:11:57,620 --> 00:11:59,420
containers package your applications,
242
00:11:59,420 --> 00:12:01,020
so they run consistently everywhere,
243
00:12:01,020 --> 00:12:03,820
and Kubernetes orchestrates those containers at scale,
244
00:12:03,820 --> 00:12:07,020
handling deployment, scaling and recovery automatically.
245
00:12:07,020 --> 00:12:09,520
AKS makes that orchestration manageable
246
00:12:09,520 --> 00:12:13,720
by taking care of the control plane and integrating with the Azure tools you already know.
247
00:12:13,720 --> 00:12:15,020
The main point is this,
248
00:12:15,020 --> 00:12:18,220
Kubernetes isn't just for big tech companies with massive engineering teams.
249
00:12:18,220 --> 00:12:21,520
With managed services like AKS, it's accessible to any team.
250
00:12:21,520 --> 00:12:23,520
Your homework for this week is simple.
251
00:12:23,520 --> 00:12:25,520
Create a free Azure account,
252
00:12:25,520 --> 00:12:28,820
spin up an AKS cluster and deploy a simple application.
253
00:12:28,820 --> 00:12:31,820
It takes minutes and you'll see how far the platform has come.
254
00:12:31,820 --> 00:12:32,920
Ready to go deeper?
255
00:12:32,920 --> 00:12:36,220
The next episode covers how to build your first container image
256
00:12:36,220 --> 00:12:38,520
and push it to Azure Container Registry.
257
00:12:38,520 --> 00:12:40,720
Subscribe on your favorite podcast platform
258
00:12:40,720 --> 00:12:44,020
and share this with someone who's just starting their Kubernetes journey.
Founder of m365.fm, m365.show and m365con.net
Mirko Peters is a Microsoft 365 expert, content creator, and founder of m365.fm, a platform dedicated to sharing practical insights on modern workplace technologies. His work focuses on Microsoft 365 governance, security, collaboration, and real-world implementation strategies.
Through his podcast and written content, Mirko provides hands-on guidance for IT professionals, architects, and business leaders navigating the complexities of Microsoft 365. He is known for translating complex topics into clear, actionable advice, often highlighting common mistakes and overlooked risks in real-world environments.
With a strong emphasis on community contribution and knowledge sharing, Mirko is actively building a platform that connects experts, shares experiences, and helps organizations get the most out of their Microsoft 365 investments.
