Kubernetes Tutorials For Beginners 2023 | Basics To Advance

Kubernetes tutorials for Beginners

Kubernetes is an open-source Google platform used for container management systems.

In this post, I will provide a comprehensive guide on Kubernetes tutorials for beginners.

As a DevOps engineer, I rely on Kubernetes for container orchestration, which also helps me enable the seamless management of containerized applications.

If you are an IT enthusiast who wants to learn about containerization and orchestration, this guide is for you.

Linux Foundation is the best source for top-quality certification, and I have the latest Linux Foundation discount coupon for you to avail of 50% off on the CKA and other certifications.

What is Kubernetes Used For?

Kubernetes is often called K8s and serves as a container orchestration platform that simplifies containerized applications’ deployment, management, and scaling.

Kubernetes’ primary purpose is to streamline the orchestration of containers, allowing developers to focus on building and maintaining their applications without worrying about the underlying infrastructure.

Kubernetes excels in scenarios where multiple containers running on different machines must work together. It helped me to keep running the application by automating tasks like load balancing, scaling, and container placement.

As a developer, I often interact with Kubernetes clusters provided by infrastructure teams. I highly recommend thoroughly understanding Kubernetes objects and their role in managing containerized workloads.

If you want to prepare for the Kubernetes exam, then read our guide on CKA exam preparation.

Why do you need containers?

In such a case, containers provide a solution by offering isolated environments that would do everything for the app to keep running while developers are modifying the app at the backend. 

I have used containers to edit and deploy applications without disrupting the consumer side. It ensures updates and maintenance can occur without service interruptions.

Containerization has emerged as a preferred method for packaging, deploying, and updating web apps, as it simplifies software management, enhances scalability, and helps maintain the high availability expected by today’s users.

Kubernetes Architecture Basics

The Kubernetes architecture has two main components:

  • Master Node
  • Worker Node

These two nodes have different features but are interconnected in orchestrating containerized applications.

1. Master Node

The Master Node is the central control point for administrative tasks that we use to oversee the entire Kubernetes cluster.

This makes the cluster more flexible to operate as it allows multiple master nodes in case of failures. Let me explain the main components of the Master Node:

API Server:

The API server is the primary entry point for REST commands that help manage and manipulate the cluster. It helps the developers to communicate with the Kubernetes clusters. 


Controller-manager regulates the cluster and manages various control loops, which carry out a continuous operation.

It helps observe objects so that the current state can match the specified state of the object. 


The Scheduler assigns tasks to Worker Nodes and helps track down how a resource is utilized across the cluster node by storing all the usage information of the Worker node.

In this way, the workload can be evenly distributed to the available nodes so that it can be managed. 


ETCD is a distributed key-value store that supports shared configuration and service discovery within the cluster. The ETCD components receive commands and work by communicating with the other components. 

2. Worker Node

The Worker Node manages the network between the containers and interacts with the Master Node to allocate resources. You can also refer to this node as Slave Node.

Below, I will be talking about the Key components of the Worker Node:

Docker Container:

Docker runs on each Worker Node and executes configured pods, encapsulating the application’s components.


Kubelet retrieves pod configurations from the API Server and ensures the containers are ready and running as specified.


Acting as a network proxy and load balancer, Kube-proxy enables service accessibility within a single Worker Node.


Pods group one or more containers that can logically run together on nodes, promoting application modularity and facilitating efficient resource management.

This architectural framework enables Kubernetes to orchestrate containerized applications seamlessly, providing scalability, fault tolerance, and centralized control over container deployments and management.

Kubernetes Fundamental Concepts You Need to Know

Below, I am mentioning the fundamental Kubernetes Concepts that you need to know:

1. Pod

Pod is the smallest and most basic unit of Kubernetes and serves as its fundamental building piece. The simplest entities in Kubernetes’ object model are these pods, which are also the easiest to generate and deploy.

A form of representation of the processes that are now operating in the cluster is provided by pods.

2. Deployment

A “deployment” in Kubernetes is a procedure that makes it easier to handle several identical pods for an application.

Deployments run and maintain many copies/replicas of the application and are responsible for ensuring the continuous operation of your application. 

When an instance fails, crashes, or becomes unresponsive, this function saves the day. Deployment quickly replaces the malfunctioning instance, ensuring that your application is always available.

3. Namespace

I have used the Namespaces in Kubernetes to divide my clusters into several different virtual clusters that I can use for various purposes.

You can always deploy Kubernetes objects like Pods and Deployments in some specific namespace so that you can easily track them down and search them among other available objects.

If you deploy different objects in different namespaces, then you can isolate different projects on the same cluster.

Advantages of Kubernetes

I have mentioned some of the best advantages of Kubernetes that will make you drawn toward this technical advancement more and more: 

1. Effortless Service Organization with Pods

Kubernetes simplifies service management by grouping them into pods for efficient orchestration.

2. Backed by Google’s Expertise

All of us trust Google and its backend experts. Google has developed Kubernetes, and it supports the infrastructure, ensuring robust performance and reliability for consumers.

3. Largest Community Support

With the largest community among container orchestration tools, Kubernetes offers a wealth of resources and support.

4. Versatile Storage Options

I have used various storage choices on Kubernetes that include on-premises, SANs, and public clouds like Google, Azure, and AWS. You can change it according to your needs because it is compatible with different platforms. 

5. Immutable Infrastructure Principles

Kubernetes adheres to the principles of immutable infrastructure. This infrastructure helps Kubernetes to stay stable and predictable. 

6. Freedom from Vendor Lock-in

Kubernetes allows flexibility by utilizing vendor-specific APIs or services only where needed, reducing vendor lock-in risks.

7. Zero-Downtime Updates

Containerization with Kubernetes enables seamless application updates and releases without service interruptions.

8. Resource Control

Kubernetes empowers you to manage containerized applications precisely, ensuring they run where and when needed with access to the right resources and tools.

Disadvantages of Kubernetes

Let’s take a look at the Disadvantages of Kubernetes that I have faced:

1. Limited Dashboard Utility

Kubernetes dashboard could not fully meet my expectations as it did not support additional tools for comprehensive management.

2. Complexity in Local Development Environments

Kubernetes can be overkill in environments where all development occurs locally, potentially adding unnecessary complexity.

3. Security Challenges

While effective, Kubernetes security may require additional configurations and measures to meet specific security standards and requirements.

What is a Pod?

A “pod” serves as the fundamental building block of Kubernetes, which constitutes the smallest and most elementary unit.

These pods are the simplest entities within Kubernetes’ object model and are readily created and deployed. Pods are a kind of representation of the processes actively running within the cluster.

There are several phases that each pod has to go through, which signifies its position within its life cycle. Note that these phases don’t encompass a comprehensive overview of the pod’s state or contained containers.

Instead, they serve as indicators of the pod’s current condition at a particular timestamp, aiding administrators in monitoring and managing their Kubernetes workloads effectively.

What is a Deployment in Kubernetes?

In Kubernetes, a “deployment” is a process that facilitates the management of multiple identical pods for an application. Deployments are responsible for ensuring the continuous operation of your application by running and maintaining multiple replicas.

This function comes to the rescue in cases where an instance fails, crashes, or becomes unresponsive. In such cases, the deployment swiftly replaces the problematic instance, guaranteeing that at least one instance of your application remains available.

The Kubernetes deployment controller oversees these deployments and ensures their reliability. Deployments employ “pod templates” to define the desired specifications for the pods, including aspects like volume mounts, labels, taints, and more.

Furthermore, when modifications are made to a deployment’s pod template, Kubernetes automatically generates new pods, ensuring seamless and controlled updates to the application.

Configuration and Storage in Kubernetes

1. Configuration in Kubernetes

I believe Configuration in Kubernetes plays a pivotal role in ensuring the smooth operation of applications running within the cluster. 

Below, I am mentioning the two primary objects for handling configuration data: 

  • ConfigMaps
  • Secrets

Using these objects has been essential for me to inject configuration data into containers while adhering to the best practice of separating configuration from application code.

ConfigMaps are ideal for non-sensitive data and are commonly used across Kubernetes clusters. They allow you to specify key-value pairs of configuration data that pods can reference. 

Secrets are designed for sensitive data, and when defining them in YAML, it gives values typically provided in base64-encoded form to enhance security.

Pods within Kubernetes can easily reference ConfigMaps and Secrets that specify a key to retrieve the corresponding configuration data. You can use this data to expose environment variables within the containers. This process makes it readily accessible for use in application code.

This approach ensures that configuration data is decoupled from the application logic, promoting flexibility and security. 

ConfigMaps and Secrets have helped me to easily manage and update application configurations, which contributes to the robustness of applications in a Kubernetes cluster.

2. Storage in Kubernetes

Initially, storage in Kubernetes has been a challenge for me regarding data persistence and sharing within pods. But I have used the concepts of Volumes and Persistent Volumes by Kubernetes to tackle this particular issue:


In Kubernetes, various volume types are available, with “emptyDir” being a common choice. “emptyDir” serves two vital functions: 

Enabling data sharing between containers within the same pod.

Preserving data even if a container crashes. 

However, it’s crucial to note that “emptyDir” volumes are tied to the pod’s lifecycle. If the pod is deleted for any reason, the data within the volume is lost. 

To configure volumes for pods, define them in the pod spec under “volumes” and reference them in containers using “volumeMounts,” specifying the “mountPath” where data from the volume will be accessible.

Persistent Volumes: 

For data that must persist regardless of pod changes, Persistent Volumes (PVs) come into play. PVs are cluster-level storage objects provisioned by administrators. 

Developers interact with Persistent Volumes through Persistent Volume Claims (PVCs), representing storage requests. Once a PVC is created, Kubernetes binds it to a suitable PV automatically. This ensures data persistence even if pods are deleted. PVCs are referenced within pod YAML under the “volumes” section.

This approach to storage management ensures the availability and resilience of data within Kubernetes, providing solutions for both transient and durable data needs. 

Developers can leverage these concepts, understanding that infrastructure teams often handle provisioning in more complex scenarios. Having a grasp of these storage mechanisms is valuable for Kubernetes practitioners, as it contributes to more robust and reliable application deployments.

Make sure to read this guide to learn how you can install CRI-O on Ubuntu for Kubernetes.

Services and Ingresses in Kubernetes

1. Services in Kubernetes

Let me explain something important about Kubernetes Services. Why am I saying it’s important? Because it has helped me get better communication and accessibility within a cluster.

The Problem Services Solve: 

If you recall our previous discussion on Deployments, we learned how they manage multiple pods for our applications. Consider a scenario where the front end of our application, managed by a deployment, needs to interact with backend pods.

The challenge is how the frontend code can locate and communicate with the ephemeral backend pods. Service objects are the solution.

What Services Do: 

I have mentioned some of the most important functions of Services in Kubernetes. The YAML example provided illustrates a basic service configuration. Here’s how it works:

  • Label-Based Routing: Services route traffic to pods with specific labels. In the example, the Service routes traffic to pods labeled “app: database.”
  • Port Specification: The YAML defines two ports: “port” and “targetPort.” The “targetPort” indicates the port on which the selected pods are listening. The Service directs requests to pods on this port. The “port” represents the port within the cluster through which the Service is exposed. It’s crucial for distinguishing different services exposed on various ports within the cluster.
  • Network Protocols: While TCP is the default network protocol, Kubernetes supports various other protocols, offering flexibility in communication.

By using the “MONGODB_HOST” environment variable, set to the Service’s name, such as “mongodb,” the frontend code can easily connect to the backend service.

This seamless communication is the essence of Kubernetes Services, allowing different parts of an application to interact reliably within the cluster.

2. Ingresses in Kubernetes

Ingresses in Kubernetes are a simple and powerful Kubernetes object that streamlines external access and routing of incoming traffic to different services within your cluster.

In Kubernetes, Ingress objects helped me to manage external access to various services within a cluster. Let me explain more in detail about Ingresses:

Streamlining External Access

When your application is hosted on a cloud provider, it’s common practice to set up individual load balancers for each service, providing static IP addresses for external accessibility. However, managing multiple load balancers can be cost-effective and complex.

Ingresses provide a smarter solution in the world of Kubernetes. Instead of juggling multiple load balancers, you can set up a single load balancer that points to the Ingress.

The Ingress, in turn, takes care of routing incoming traffic to the appropriate services within the cluster. It acts as a traffic director, simplifying the external access to various parts of your application.

Routing Rules Simplified

Within the Ingress object, you can define routing rules based on URL paths and hostnames. For instance, you can specify that requests to “/api” should be directed to a backend service, while other requests should be directed to a frontend service.

This level of granular control simplifies route management compared to traditional methods like setting up separate NGINX proxies for each application.

When I created an Ingress object, I had to install an ingress controller in the cluster as a cluster admin. Unlike other Kubernetes objects like Pods or Deployments, Ingress controllers are not preinstalled.

As a developer, I often did not need to perform this setup myself, especially in managed Kubernetes environments like Okteto.

They are a valuable tool for managing application accessibility and enhancing the overall deployment experience.

Check this guide on how to convert the HELM chart to Kubernetes YAML by following the simple steps mentioned.

Conclusion: Kubernetes Tutorials For Beginners

Hopefully, this guide on Kubernetes tutorials for beginners has taught you well enough about the basics of Kubernetes.

I have tried to mention everything important in this guide. Make sure that you have a strong command of the fundamentals of Kubernetes.

Get some detailed information on configuration, storage, ingresses, etc., as they are some essential functionalities of Kubernetes.

Frequently Asked Questions

Can I learn Kubernetes in 1 month?

Depending on your past knowledge and expertise with containerization, cloud computing, & distributed systems, learning Kubernetes from scratch may take a while. It can also take a few weeks to many months to master Kubernetes, assuming you have no prior expertise with these technologies.

Leave a Reply

Your email address will not be published. Required fields are marked *

Share this article

Get Proven Copywriting Tips Straight to Your Inbox

Avail 20% instant discount on a huge training catalog using our special Linux Foundation coupons: UPWRITEZ20