Installing Kubernetes Cluster with 2 minions on Ubuntu to manage pods and services


Introduction

Kubernetes is a system designed to manage containerized applications built within Docker containers in a clustered environments. It provides basic mechanisms for deployment, maintenance and scaling of applications on public, private or hybrid setups, means, it handles the entier life cycle of a containerized application. It also have intelligency of self-healing features where containers can be auto provisioned, restarted or even replicated.

index

Goals

By the end of this Blog, you will:

  • Understand the utility of Kubernetes
  • Learn how to Setup Kubernetes Cluster

Prerequisites

For this blog, you will need:

  • Understanding of Kubernetes Componetes.
  • The nodes must installed docker version 1.2+ and bridge-utils to manipulate linux bridge.
  • All machines should communicate with each other and Master node needs to be connected to the Internet as it download the necessary files
  • All node must have Ubuntu 14.04 LTS 64bit server
  • Dependencies of this guide: etcd-2.2.1, flannel-0.5.5, k8s-1.1.8, may work with higher versions.
  • All the remote servers can be ssh logged in without a password by using key authentication.
eval "$(ssh-agent)"
ssh-add admin-key.pem

Before, starting the installation and configuration, let’s understand the Kubernetes components. Even you can look to my another blog Introduction to Kubernetes for more details.

Kubernetes Components

Kubernetes works in server-client concept, where, it has a master that provide centralized control for a all minions(agent). We will be deploying one Kubernetes master with two minions and we will also have a workspace machine from where we will run all installation scripts.

Kubernetes has several components:

etcd – A highly available key-value store for shared configuration and service discovery.

flannel – An etcd backed network fabric for containers.

kube-apiserver – Provides the API for Kubernetes orchestration.

kube-controller-manager – Enforces Kubernetes services.

kube-scheduler – Schedules containers on hosts.

kubelet – Processes a container manifest so the containers are launched according to how they are described.

kube-proxy – Provides network proxy services.

Set up working directory

Login into the workspace machine and create the workspace directory.

$ mkdir workspace
$ cd workspace/

Change the directory to workspace and clone the kubernetes github repo locally.

$git clone https://github.com/kubernetes/kubernetes.git
Cloning into 'kubernetes'...
remote: Counting objects: 258974, done.
remote: Compressing objects: 100% (9/9), done.
remote: Total 258974 (delta 3), reused 0 (delta 0), pack-reused 258965
Receiving objects: 100% (258974/258974), 185.65 MiB | 10.11 MiB/s, done.
Resolving deltas: 100% (169989/169989), done.

When we start the setup process, the required binary automatically picked up the latest release. But we can customize version as per our requirement by setting up corresponding environment variable ETCD_VERSION , FLANNEL_VERSION and KUBE_VERSION like following.

$ export KUBE_VERSION=2.2.1
$ export FLANNEL_VERSION=0.5.5
$ export ETCD_VERSION=1.1.8

Cluster IP details:

Master : 10.2.0.33

Nodes: 10.2.0.34, 10.2.0.35

We can also configure our master as node(minios) but that over load the master, so we are doing master as completed standalone setup.

Configure the cluster information

We can configure the cluster information in cluster /ubuntu/config-default.sh file or even we can export as environment variable. Following is a simple sample:

export nodes="ubuntu@10.2.0.33 ubuntu@10.2.0.34 ubuntu@10.2.0.35"
export role="a i i"
export NUM_NODES=${NUM_NODES:-3}
export SERVICE_CLUSTER_IP_RANGE=192.168.3.0/24
export FLANNEL_NET=172.16.0.0/16

The FLANNEL_NET variable defines the IP range used for flannel overlay network, should not conflict with above SERVICE_CLUSTER_IP_RANGE. You can optionally provide additional Flannel network configuration through FLANNEL_OTHER_NET_CONFIG, as explained in cluster /ubuntu/config-default.sh

Note: When deploying, master needs to be connected to the Internet to download the necessary files. If your machines are located in a private network that need proxy setting to connect the Internet, you can set the config PROXY_SETTING in cluster /ubuntu/config-default.sh such as:

PROXY_SETTING="http_proxy=http://server:port https_proxy=https://server:port"

After all the above variables being set correctly, we can use following command in cluster/ directory to bring up the whole cluster.

$ cd kubernetes/cluster/
$ KUBERNETES_PROVIDER=ubuntu ./kube-up.sh

The scripts automatically copy binaries and config files to all the machines via scp and start kubernetes service on them. The only thing you need to do is to type the sudo password when promoted.


Deploying node on machine 10.2.0.35

[sudo] password to start node:

If everything works correctly, you will see the following message from console indicating the k8s cluster is up.

Cluster validation succeeded

Test it out

You can use kubectl command to check if the newly created cluster is working correctly. The kubectl binary is under the cluster/ubuntu/binaries directory. You can make it available via PATH, then you can use the below command smoothly.

For example, use $ kubectl get nodes to see if all of your nodes are ready.

$ kubectl get nodes
NAME LABELS STATUS
10.2.0.31 kubernetes.io/hostname=10.2.0.31 Ready
10.2.0.32 kubernetes.io/hostname=10.2.0.32 Ready
10.2.0.33 kubernetes.io/hostname=10.2.0.33 Ready

Congratulations! you have configured your kubernetes cluster. In case you need any help while playing kubernetes then please write to me at Pravin Mishra. We will be happy to assist.

An Introduction to Kubernetes


In this blog, I am going to give brief introduction to Kubernetes and it’s services. In later blog, we will deploy and configure Kubernets cluster on OpenStack VM.

Kubernetes is basically a cluster management tool for Docker container. It help us to schedule and deploy any number of container replicas onto a node clusters. Kubernetes is enough inteligent to take care of making decisions like which containers go on which servers/node.

Kubernetes is a KEY to assess and dealing with various containers instead of simply working with Docker on a manually configured host.

Why Kubernetes?

Kubernetes enables you to respond quickly to customer demand by scaling or rolling out new features and to make maximal use of your hardware.

Kubernetes is:

  • lean: lightweight, simple, accessible
  • portable: public, private, hybrid, multi cloud
  • extensible: modular, pluggable, hookable, composable, toolable
  • self-healing: auto-placement, auto-restart, auto-replication

Parts of Kubernetes

A running Kubernetes cluster contains node agents (kubelet) and master components (APIs, scheduler, etc), on top of a distributed storage solution. The Kubernetes node has the services necessary to run application containers and be managed from the master systems.

  • Master: the managing machine, which oversees one or more minions.
  • Minion: a slave that runs tasks as delegated by the user and Kubernetes master.
  • Pod: an application (or part of an application) that runs on a minion. This is the basic unit of manipulation in Kubernetes.
  • Replication Controller: ensures that the requested number of pods are running on minions at all times.
  • Label: an arbitrary key/value pair that the Replication Controller uses for service discovery
    kubecfg: the command line config tool
  • Service: an endpoint that provides load balancing across a replicated group of pods

To manage resources within Kubernetes, It will interact with the Kubernetes API and pulling down the Kubernetes binaries that will give all the services necessary to get Kubernetes configuration up and running. Like most other cluster management solutions, Kubernetes works by creating a master, which exposes the Kubernetes API and allows to request certain tasks to be completed. The master then spawns containers to handle the workload. Aside from running Docker, each node runs the Kubelet service — which is an agent that works with the container manifest — and a proxy service. The Kubernetes control plane is comprised of many components, but they all run on the single Kubernetes master node.