Getting Started with Containerization

Reduce the operational burden on your system by automating and managing your containers

Gabriel N. Schenker, Hideto Saito, Hui-Chuan Chloe Lee, Ke-Jou Carol Hsu

• Publisher: Packt Publishing
• Year: 2019
• Print ISBN: 9781838645700
• eBook ISBN: 9781838649036
• Edition: 1
• Topic: Computer Science
• Subtopic: Cloud Computing
• Index: Computer Science

Choose the smarter way to learn about containerizing your applications and running them in production.

Key Features

• Deploy and manage highly scalable, containerized applications with Kubernetes
• Build high-availability Kubernetes clusters
• Secure your applications via encapsulation, networks, and secrets

Book Description

Kubernetes is an open source orchestration platform for managing containers in a cluster environment. This Learning Path introduces you to the world of containerization, in addition to providing you with an overview of Docker fundamentals. As you progress, you will be able to understand how Kubernetes works with containers. Starting with creating Kubernetes clusters and running applications with proper authentication and authorization, you'll learn how to create high-availability Kubernetes clusters on Amazon Web Services (AWS), and also learn how to use kubeconfig to manage different clusters. Whether it is learning about Docker containers and Docker Compose, or building a continuous delivery pipeline for your application, this Learning Path will equip you with all the right tools and techniques to get started with containerization.

By the end of this Learning Path, you will have gained hands-on experience of working with Docker containers and orchestrators, including SwarmKit and Kubernetes.

This Learning Path includes content from the following Packt products:

• Kubernetes Cookbook - Second Edition by Hideto Saito, Hui-Chuan Chloe Lee, and Ke-Jou Carol Hsu
• Learn Docker - Fundamentals of Docker 18.x by Gabriel N. Schenker

What you will learn

• Build your own container cluster
• Run a highly distributed application with Docker Swarm or Kubernetes
• Update or rollback a distributed application with zero downtime
• Containerize your traditional or microservice-based application
• Build a continuous delivery pipeline for your application
• Track metrics and logs for every container in your cluster
• Implement container orchestration to streamline deploying and managing applications

Who this book is for

This beginner-level Learning Path is designed for system administrators, operations engineers, DevOps engineers, and developers who want to get started with Docker and Kubernetes. Although no prior experience with Docker is required, basic knowledge of Kubernetes and containers will be helpful.

Walking through Kubernetes Concepts

In this chapter, we will cover the following recipes:

• Linking Pods and containers
• Managing Pods with ReplicaSets
• Deployment API
• Working with Services
• Working with Volumes
• Working with Secrets
• Working with names
• Working with Namespaces
• Working with labels and selectors

Introduction

In this chapter, we will start by creating different kinds of resources on the Kubernetes system. In order to realize your application in a microservices structure, reading the recipes in this chapter will be a good start towards understanding the concepts of the Kubernetes resources and consolidating them. After you deploy applications in Kubernetes, you can work on its scalable and efficient container management, and also fulfill the DevOps delivering procedure of microservices.

An overview of Kubernetes

Working with Kubernetes is quite easy, using either a Command Line Interface (CLI) or API (RESTful). This section will describe Kubernetes control by CLI. The CLI we use in this chapter is version 1.10.2.

After you install Kubernetes master, you can run a kubectl command as follows. It shows the kubectl and Kubernetes master versions (both the API Server and CLI are v1.10.2):

$ kubectl version --short
Client Version: v1.10.2
Server Version: v1.10.2

kubectl connects the Kubernetes API server using the RESTful API. By default, it attempts to access the localhost if .kube/config is not configured, otherwise you need to specify the API server address using the --server parameter. Therefore, it is recommended to use kubectl on the API server machine for practice.

If you use kubectl over the network, you need to consider authentication and authorization for the API server.

kubectl is the only command for Kubernetes clusters, and it controls the Kubernetes cluster manager. Find more information at http://kubernetes.io/docs/user-guide/kubectl-overview/. Any container, or Kubernetes cluster operation, can be performed by a kubectl command.

In addition, kubectl allows the inputting of information via either the command line's optional arguments or a file (use the -f option); it is highly recommended to use a file, because you can maintain Kubernetes configuration as code. This will be described in detail in this chapter.

Here is a typical kubectl command-line argument:

kubectl [command] [TYPE] [NAME] [flags]

The attributes of the preceding command are as follows:

• command: Specifies the operation that you want to perform on one or more resources.
• TYPE: Specifies the resource type. Resource types are case-sensitive and you can specify the singular, plural, or abbreviated forms.
• NAME: Specifies the name of the resource. Names are case-sensitive. If the name is omitted, details for all resources are displayed.
• flags: Specifies optional flags.

For example, if you want to launch nginx, you can use either the kubectl run command or the kubectl create -f command with the YAML file as follows:

1. Use the run command:

$ kubectl run my-first-nginx --image=nginx "my-first-nginx"

2. Use the create -f command with the YAML file:

$ cat nginx.yaml 
apiVersion: apps/v1
kind: Deployment
metadata:
 name: my-first-nginx
 labels:
 app: nginx
spec:
 replicas: 1
 selector:
 matchLabels:
 app: nginx
 template:
 metadata:
 labels:
 app: nginx
 spec:
 containers:
 - name: nginx
 image: nginx 

//specify -f (filename) 
$ kubectl create -f nginx.yaml 
deployment.apps "my-first-nginx" created

3. If you want to see the status of the Deployment, type the kubectl get command as follows:

$ kubectl get deployment
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
my-first-nginx 1 1 1 1 4s

4. If you also want the support abbreviation, type the following:

$ kubectl get deploy
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
my-first-nginx 1 1 1 1 38s

5. If you want to delete these resources, type the kubectl delete command as follows:

$ kubectl delete deploy my-first-nginx
deployment.extensions "my-first-nginx" deleted

6. The kubectl command supports many kinds of sub-commands; use the -h option to see the details, for example:

//display whole sub command options 
$ kubectl -h 


//display sub command "get" options 
$ kubectl get -h 


//display sub command "run" options 
$ kubectl run -h 

This section describes how to use the kubectl command to control the Kubernetes cluster. The following recipes describe how to set up Kubernetes components:

• Setting up a Kubernetes cluster on macOS using minikube and Set up a Kubernetes cluster on Windows using minikube in Chapter 12, Building Your Own Kubernetes Cluster
• Setting up a Kubernetes cluster on Linux using kubeadm in Chapter 12, Building Your Own Kubernetes Cluster
• Setting up a Kubernetes cluster on Linux using kubespray (Ansible) in Chapter 12, Building Your Own Kubernetes Cluster

Linking Pods and containers

The Pod is a group of one or more containers and the smallest deployable unit in Kubernetes. Pods are always co-located and co-scheduled, and run in a shared context. Each Pod is isolated by the following Linux namespaces:

• The process ID (PID) namespace
• The network namespace
• The interprocess communication (IPC) namespace
• The unix time sharing (UTS) namespace

In a pre-container world, they would have been executed on the same physical or virtual machine.

It is useful to construct your own application stack Pod (for example, web server and database) that are mixed by different Docker images.

Getting ready

You must have a Kubernetes cluster and make sure that the Kubernetes node has accessibility to the Docker Hub (https://hub.docker.com) in order to download Docker images.

If you are running minikube, use minikube ssh to log on to the minikube VM first, then run the docker pull command.

You can simulate ...

Table of contents

• Title Page
• Copyright
• About Packt
• Contributors
• Preface
• What Are Containers and Why Should I Use Them?
• Setting up a Working Environment
• Working with Containers
• Creating and Managing Container Images
• Data Volumes and System Management
• Distributed Application Architecture
• Single-Host Networking
• Docker Compose
• Orchestrators
• Introduction to Docker Swarm
• Zero Downtime Deployments and Secrets
• Building Your Own Kubernetes Cluster
• Walking through Kubernetes Concepts
• Playing with Containers
• Building High-Availability Clusters
• Building Continuous Delivery Pipelines
• Building Kubernetes on AWS
• Advanced Cluster Administration
• Other Books You May Enjoy