In this chapter, we are going to use the following technologies and software:

• Minikube
• Bash Shell
• GitHub
• Kubernetes
• Docker
• Firefox

You will be required to install Minikube on your laptop or any other virtual environment you are going to use. All the instructions for installing Minikube can be found at https://kubernetes.io/docs/tasks/tools/install-minikube/.

All the code for this chapter is located on GitHub at https://github.com/PacktPublishing/Learn-OpenShift.

Bash Shell will be used as a part of your virtual environment.

Firefox or any other browser can be used to navigate through Docker Hub.

Containers offer unmatched benefits in terms of density, deployment speed, and scalability in comparison to virtualization. But containers by themselves are not enough to match all the requirements of today's business, which expects the infrastructure to be adaptable to dynamic challenges. It is quite simple to start and manage a couple dozen containers, but things get complicated when the number climbs to hundreds, which is very common for large workloads. This is where Container Orchestration Engines (COE) come in. They bring true power to containers, offering various mechanisms to deploy, destroy, and scale multiple containers rapidly.

There are multiple container management solutions available, with the most popular being Kubernetes and Docker Swarm:

• Kubernetes: First released in July 2015, Kubernetes comes directly from Borg—...

Kubernetes and Docker Swarm are the most commonly used orchestration frameworks. They provide a similar set of capabilities and essentially solve the same problem—management containers in an unsafe and highly dynamic environment. While some of their features overlap, there are also significant differences and the choice of system depends on many factors, such as the number of containers, availability requirements, and team expertise, to name a few.

The table provides an insight into the most important differences:

Like any complex system, a Kubernetes cluster can be viewed from multiple perspectives. From the infrastructure perspective, it comprises two sets of nodes; they can be bare-metal servers as well as VMs:

• Masters:

This type of node is responsible for cluster management, network allocation, quota enforcement, synchronization, and communication. Master nodes act as the main point of contact for clients—be it actual people or some external system. In the simplest setup, there can be only one master, but highly available clusters require at least two to prevent common fail situations. The most important service that masters run is the API.

• Nodes:

Nodes do the actual work of hosting Docker containers. More specifically, nodes provide a runtime environment for running pods, which are described later in this book. These servers run the kubelet service...

In this chapter, you will install Minikube—a simple single-node Kubernetes cluster. While not suitable for any production-grade workload, it is a useful tool to learn the basics of cluster management quickly. Although it supports several drivers for VM providers, in this tutorial we will use the KVM2 driver since KVM virtualization is available even in a base Linux environment.

The easiest method is to go to https://kubernetes.io/docs/getting-started-guides/minikube/ and install Minikube on your favorite OS. Then go to https://kubernetes.io/docs/tasks/tools/install-kubectl/ and install kubectl. kubectl is a CLI command to manage Kubernetes. Once you are done, it is time to start Minikube:

$ minikube start
Starting local Kubernetes v1.9.0 cluster...
Starting VM...
Downloading Minikube ISO
...
<output omitted>
...
Kubectl is now configured...

Kubectl is a command-line interface for managing a Kubernetes cluster and its resources. In this section, you will learn about the most common commands and their use cases.

The syntax for all the commands follows this convention:

$ kubectl <COMMAND> <RESOURCE_TYPE> <RESOURCE_NAME> <OPTIONS>

Commands in angle brackets <> mean the following:

• COMMAND: An action to be executed against one or more resources.
• RESOURCE_TYPE: The type of resource to be acted upon, for example, a pod or service.
• RESOURCE_NAME: The name of the resource(s) to manage.
• OPTIONS: Various flags used to modify the behavior of kubectl commands. They have higher priority than default values and environment variables, thus overriding them.

Once you are done working with Kubernetes, you can easily stop the Minikube cluster by running the minikube stop command:

$ minikube stop
Stopping local Kubernetes cluster...
Machine stopped.

After that, you can delete the Minikube VM if you want by running the minikube delete command:

$ minikube delete
Deleting local Kubernetes cluster...
Machine deleted.

Verify that the Minikube cluster no longer exists:

$ minikube status
minikube:
cluster:
kubectl:

Although it is a powerful orchestration engine, Kubernetes doesn't have the features that are commonly required by PaaS solutions such as OpenShift and others:

• Security:

Kubernetes namespaces are provided mainly for the purpose of resource quota enforcement for different groups of users, but they do not provide any security constraints or authentication. For example, every user from every namespace can see all other namespaces and their resources.

• Deployments:

Kubernetes provides the means to create a deployment from an image with a single command, but doesn't create a service for external clients.

• SCM integration:

Kubernetes doesn't support integration with SCM via webhooks to facilitate deployment.

• Builds:

Kubernetes doesn't provide advanced build modes such as Source-to-Image (S2I) and Custom Builder.

• Authentication:

Support...

In this chapter, we have briefly discussed Kubernetes concepts and the Kubernetes architecture, and the main difference between Kubernetes and Docker Swarm. We installed Kubernetes using Minikube, which is a very easy-to-use CLI tool with which to set up a Kubernetes lab environment. Then we used the kubectl command to perform various tasks such as running, editing, describing, and deleting Kubernetes pods and other Kubernetes resources. Finally, we finished by listing the main Kubernetes limitations, which we are going to address later in this book.

In the next chapter, we are going to work with CRI-O, which is a universal container runtime interface that allows Kubernetes to provide support for different container platforms.

1. What are the two Node types used by Kubernetes?:
   1. Node
   2. Minikube
   3. Vagrant
   4. Master

2. Which container platforms are supported by Kuberntes? choose two:
   1. Docker
   2. OpenShift
   3. Rkt
   4. Minishift
3. In Kubernetes, a pod is a minimal unit of deployment which represents a group of containers:
   1. True
   2. False
4. What are the main two Kubernetes services running on a Kubernetes Node? choose two:
   1. etcd
   2. kubelet
   3. kube-proxy
   4. kube-node
   5. kube-apiserver
5. What are acceptable file formats for creating Kubernetes resources with the kubectl create -f command? choose two:
   1. JSON
   2. Jinja2
   3. CSV
   4. YANG
   5. YAML
6. Kubernetes has a built-in CI/CD toolset to improve corporate software delivery frameworks:
   1. True
   2. False

Since we are covering the very basics of Docker containers, you may be interested in diving into specific topics. Here's a list of links that may be helpful to look through to learn more about Docker and containers in general:

• Kubernetes concepts: https://kubernetes.io/docs/concepts/
• Kubernetes CLI: https://kubernetes.io/docs/reference/generated/kubectl/kubectl/
• Kubernetes installation: https://kubernetes.io/docs/setup/pick-right-solution/
• Kubernetes cheat sheet: https://kubernetes.io/docs/reference/kubectl/cheatsheet/
• Kubernetes API overview: https://v1-9.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.9/
• YAML wiki page: https://en.wikipedia.org/wiki/YAML
• YAML syntax check: http://www.yamllint.com/
• JSON Wiki page: https://en.wikipedia.org/wiki/JSON
• JSON syntax check: https://jsonlint.com/