This chapter has the following technical requirements:

• An Ubuntu 22.04+ server running Docker with a minimum of 4 GB of RAM, although 8 GB is recommended
• Scripts from the chapter2 folder from the GitHub repo, which you can access by going to this book’s GitHub repository: https://github.com/PacktPublishing/Kubernetes-An-Enterprise-Guide-Third-Edition

We consider it essential to highlight that this chapter will mention various Kubernetes objects, some of which may lack extensive context. However, in Chapter 3, Kubernetes Bootcamp, we will dive into Kubernetes objects in depth, providing numerous example commands to enhance your understanding. To ensure a practical learning experience, we recommend having a cluster while reading the bootcamp chapter.

Most of the basic Kubernetes topics covered in this chapter will be discussed in future chapters, so if some topics become a bit foggy after you’ve read this chapter, never...

Since this chapter will discuss various common Kubernetes objects and components, we’ve included a table with brief definitions for each term. This will provide you with the necessary context and help ensure you understand the terminology as you read through the chapter.

In Chapter 3, Kubernetes Bootcamp, we will go over the components of Kubernetes and the basic set of objects that are included in a cluster. Since we will have to use some basic objects in this module, we have provided some common Kubernetes components and resources in the table below.

Figure 2.1: Kubernetes components and objects

While these are only a few of the objects that are available in a Kubernetes cluster, they are the objects we will discuss in this chapter. Knowing what each resource is and having basic knowledge of its functionality will help you to understand this chapter.

Interacting with a cluster

To interact with a cluster...

Over time, several solutions have been developed to facilitate the installation of development Kubernetes clusters, enabling administrators and developers to conduct testing on local systems. While these tools have proven effective for basic Kubernetes testing, they often possess certain limitations that render them suboptimal for more advanced scenarios.

Some of the most common solutions available are as follows:

• Docker Desktop
• K3s
• KinD
• kubeadm
• minikube
• Rancher Desktop

Each solution has benefits, limitations, and use cases. Some solutions limit you to a single node that runs both the control plane and worker nodes. Others offer multi-node support but require additional resources to create multiple virtual machines. Depending on your development or testing requirements, these solutions may not meet your needs completely.

To truly get into Kubernetes, you need to have a cluster that has at least a...

At the time of writing, the current version of KinD is 0.22.0, supporting Kubernetes clusters up to 1.30.x.

The files required to deploy KinD and all of the components for the cluster that we will use for the chapters are located in the repository, under the chapter2 folder. The script, create-cluster.sh, located in the root of the chapter2 directory, will execute all of the steps discussed in the remainder of the chapter. You do not need to execute the commands as you read the chapter; you are welcome to follow the steps, but before executing the install script in the repo, you must delete any KinD clusters that may have been deployed.

The deployment script contains in-line remarks to explain each step; however, we will explain each step of the installation process in the next section.

Installing KinD – prerequisites

There are multiple methods available for installing KinD, but the simplest and fastest approach to begin building KinD clusters...

The KinD utility offers the flexibility to create both single-node clusters and more intricate setups with multiple control plane nodes and worker nodes. In this section, we will dive into the various options provided by the KinD executable. By the conclusion of this chapter, you will have a fully operational two-node cluster comprising a control plane node and a worker node.

For the exercises covered in this book, we will be setting up a multi-node cluster. The simple cluster configuration provided in the next section serves as an introductory example and should not be employed for the exercises presented in the book.

Creating a simple cluster

We will create a cluster later in the chapter, but before we do that, let’s explain how we can use KinD to create different...

Now that you have a fully functional Kubernetes cluster, we can dive into the realm of a few key Kubernetes objects, specifically storage objects. In the next chapter, Kubernetes Bootcamp, we will get deeper into the other objects that are available in a Kubernetes cluster. While that chapter will explore the large list of objects available in a cluster, it is important to introduce the storage-related objects at this point, since KinD provides storage capabilities.

In this section, we shall acquaint ourselves with the storage objects seamlessly integrated within KinD. These purpose-built storage objects extend persistent storage capabilities to your workloads within the cluster, ensuring data persistence and resilience. By familiarizing ourselves with these storage objects, we lay the foundation for seamless data management within the Kubernetes ecosystem.

KinD storage objects

Remember that KinD includes Rancher’s auto-provisioner to...

We added this section for anybody who may want to know more about how to load balance between multiple worker nodes.

This section disccusses a complex topic that covers adding a custom HAProxy container that you can use to load balance worker nodes in a KinD cluster. You should not deploy this on the KinD cluster that we will use for the remaining chapters.

Since you will interact with load balancers in most enterprise environments, we wanted to add a section on how to configure your own HAProxy container for worker nodes, in order to load balance between three KinD nodes.

First, we will not use this configuration for any of the chapters in this book. We want to make the exercises available to everyone, so to limit the required resources, we will always use the two-node cluster that we created earlier in this chapter. If you want to test KinD nodes with a load balancer, we suggest using a different Docker host or waiting until...

This chapter provided an overview of the KinD project, a Kubernetes SIG project. We covered the process of installing optional components in a KinD cluster, such as Calico for CNI and NGINX for Ingress control. Additionally, we explored the Kubernetes storage objects that are included with a KinD cluster.

You should now understand the potential benefits that KinD can bring to you and your organization. It offers a user-friendly and highly customizable Kubernetes cluster deployment, and the number of clusters on a single host is only limited by the available host resources.

In the next chapter, we will dive into Kubernetes objects. We’ve called the next chapter Kubernetes Bootcamp, since it will cover the majority of the basic Kubernetes objects and what each one is used for. The next chapter can be considered a “Kubernetes pocket guide.” It contains a quick reference to Kubernetes objects and what they do, as well as when to use them.

It’...

1. What object must be created before you can create a PersistentVolumeClaim?
   1. PVC
   2. A disk
   3. PersistentVolume
   4. VirtualDisk

Answer: c

2. KinD includes a dynamic disk provisioner. Which company created the provisioner?
   1. Microsoft
   2. CNCF
   3. VMware
   4. Rancher

Answer: d

3. If you created a KinD cluster with multiple worker nodes, what would you install to direct traffic to each node?
   1. A load balancer
   2. A proxy server
   3. Nothing
   4. Replicas set to 3

Answer: a

4. True or false? A Kubernetes cluster can only have one CSIdriver installed.
   1. True
   2. False

Answer: b