How to Install and Configure Kubernetes Cluster with Kubeadm and Ansible on Ubuntu 16.04

Kubernetes is the opensource software for the containerized application to deploy, scale and manage the clusters of hosts. There are many ways to install and configure Kubernetes components. Kubeadm will take care of installing Kubernetes Components. With the help of Ansible and Kubeadm, we can completely set up the Kubernetes clusters. In this article, we will discuss How to Install and Configure Kubernetes Cluster with Kubeadm and Ansible on Ubuntu 16.04 and deploy a sample application on the clusters.

Architecture of Kubernetes.

Before getting into the setup. Let us discuss the Architecture of the Kubernetes. This will help us understand the components and use of it. Basically, Kubernetes is having two major types of nodes called Master and Worker nodes.

Master Node:

Master Node is having following components.

• API Server – It creates an interface between Cluster nodes and other components of the Kubernetes master nodes.
• Etcd – This is the Key-Value storage which stores the state at any point of any cluster.
• Scheduler – This component watches newly created pods that are not assigned to any workload or service and assign it for the same.
• Kube – Control Manager – Kube control manager is for Kubernetes native components. This Control manager includes following sub-components
  • Node Controller – When a node is going down, this component will notify and respond.
  • Replication Controller – This will take care of the number of pods per replication.
  • Endpoint Controller – It will take care of endpoints of all services.
  • Service Account Controller – This will take care of account management for API and other RBAC.
• Cloud – Control Manager – Cloud control Manager will interact with Cloud providers to run and control the cloud-based containers. This feature is available only after Kubernetes 1.6. This includes the following sub-components.
  • Node Controller – Checks if a node in the cloud is down or not and it will notify and response for the situation.
  • Route Controller – This will create network level routing in cloud infrastructure.
  • Service Controller – This is basically a load-balancer controller from the cloud.
  • Volume Controller – This is for maintaining the volumes in terms of creating, attaching mounting and interacting with the cloud provider.

Worker Node:

Worker Node is responsible for maintaining the runtime or workload of the application or service. This is having the following components.

Requirements

We are going to set up following nodes

1. Master Node – Where Kubernetes Master will run
2. Worker Node 1 – This is the node where the application or service will run.
3. Worker Node 2 – This will also run Application or service.

All these three nodes are going to be in Ubuntu 16.04. So, we need to make the note of the following requirements

Let us get in to the Installation and configuration of Kubernetes clusters step by step.

How to Install and Configure Kubernetes Cluster

So, Here we go. We will see how to Install and Configure Kubernetes Cluster with Kubeadm and Ansible. To make it clear again, Ansible is to install Kubernetes dependencies and kubeadm. Then kubeadm will take care of installing kubernetes components.

Step 1: Ansible setup for Kubernetes

Before starting with Ansible, All the Ansible scripts that are used here are published in GitHub (https://github.com/digitalvarys/kube-ansible). Please clone if you wish to use it.

For hosting Ansible orchestration, either take machine which will communicate with all the nodes we selected or configure Ansible in local machine. First, create the workspace folder for the Kubernetes.

mkdir ~/kube-ansible
cd ~/kube-ansible

This folder is going to be the workspace for Ansible. Then Create hosts file by passing following command

nano ~/kube-ansible /hosts

Then add the node groups in the hosts file. Add the following lines in the hosts file.

[masters]
master ansible_host=172.168.0.10 ansible_user=root

[workers]
worker1 ansible_host=172.168.0.11 ansible_user=root
worker2 ansible_host=172.168.0.12 ansible_user=root

[all:vars]
ansible_python_interpreter=/usr/bin/python3

In this, We have grouped two clusters called master and workers. Where “masters” group will have the Kubernetes master node and “worker” will have worker clusters nodes.

Step 2: Creating Non-root user

Kubernetes need to be installed with a non-root user. So, with Ansible we will create a non-root user called “ubuntu” in all the nodes. For the same create a YAML file by passing the following command.

nano ~/kube-ansible/non-root-user.yml

then add following lines in the file.

- hosts: all
  become: yes
  tasks:
    - name: creating 'ubuntu' user
      user: name=ubuntu append=yes state=present createhome=yes shell=/bin/bash

    - name: 'ubuntu' for passwordless sudo
      lineinfile:
        dest: /etc/sudoers
        line: 'ubuntu ALL=(ALL) NOPASSWD: ALL'
        validate: 'visudo -cf %s'

    - name: authorized keys for the ubuntu user
      authorized_key: user=ubuntu key="{{item}}"
      with_file:
        - ~/.ssh/id_rsa.pub

This file will create a user called “ubuntu” and set password-less sudo entry for “ubuntu” user and then add an ssh key for the authorization for “ubuntu” user.

Once the above file is saved, run the following command to run the ansible playbook.

ansible-playbook -i hosts ~/kube-ansible/non-root-user.yml

This will give the following console output.

PLAY [all] ****

TASK [Gathering Facts] ****
ok: [masters]
ok: [worker1]
ok: [worker2]

TASK [creating 'ubuntu' user] ****
changed: [masters]
changed: [worker1]
changed: [worker2]

TASK ['ubuntu' for passwordless sudo] ****
changed: [masters]
changed: [worker1]
changed: [worker2]

TASK [authorized keys for the ubuntu user] ****
changed: [worker1] => (item=ssh-rsa AAAAB3...
changed: [worker2] => (item=ssh-rsa AAAAB3...
changed: [masters] => (item=ssh-rsa AAAAB3...

PLAY RECAP ****
masters                     : ok=5    changed=4    unreachable=0    failed=0   
worker1                    : ok=5    changed=4    unreachable=0    failed=0   
worker2                    : ok=5    changed=4    unreachable=0    failed=0   

Next, we will go for installing Kubernetes binaries.

Step 3: Installing Kubernetes Binaries.

To run all Kubernetes setup, we need to install all the following necessary components.

• Container Runtime: There are many container runtimes available like rkt or Docker. In our case, we are going to install Docker.
• Kubeadm: This will take care of installing the many cluster components.
• Kubelet: system level service to communicate master and handle node operations.
• Kubectl: OperateKubernetes master from Command line interface. This will talk with API server.

So, all these components are going to be installed using APT package manager with ansible. Open a yaml file by passing following command in the command line.

nano ~/kube-ansible/kube-dependencies.yml

Then add the following lines in the above file.

- hosts: all
  become: yes
  tasks:
   - name: Docker Installation
     apt:
       name: docker.io
       state: present
       update_cache: true

   - name: install APT Transport HTTPS
     apt:
       name: apt-transport-https
       state: present

   - name: add Kubernetes apt-key for APT repository
     apt_key:
       url: https://packages.cloud.google.com/apt/doc/apt-key.gpg
       state: present

   - name: add Kubernetes APT repository
     apt_repository:
      repo: deb http://apt.kubernetes.io/ kubernetes-xenial main
      state: present
      filename: 'kubernetes'

   - name: install kubelet
     apt:
       name: kubelet=1.14.0-00
       state: present
       update_cache: true

   - name: install kubeadm
     apt:
       name: kubeadm=1.14.0-00
       state: present

- hosts: masters
  become: yes
  tasks:
   - name: install kubectl
     apt:
       name: kubectl=1.14.0-00
       state: present
       force: yes

The above code will do the needed dependent components in order.

1. The First task will install Docker runtime
2. Then external https source to apt will be installed
3. After that, adds Kubernetes apt-key for APT repository
4. Then, adds Kubernetes to the APT repository
5. After that, Installing kubelet and kubeadm on all the instances.
6. Then, only on the master node, kubectl is installed.

Once after adding the above lines, run the ansible playbook by passing following command.

ansible-playbook -i hosts ~/kube-ansible/kube-dependencies.yml

This will through following output

PLAY [all] ****

TASK [Gathering Facts] ****
ok: [worker1]
ok: [worker2]
ok: [masters]

TASK [Docker Installation] ****
changed: [masters]
changed: [worker1]
changed: [worker2]

TASK [install APT Transport HTTPS] *****
ok: [masters]
ok: [worker1]
changed: [worker2]

TASK [add Kubernetes apt-key for APT repository] *****
changed: [masters]
changed: [worker1]
changed: [worker2]

TASK [add Kubernetes APT repository] *****
changed: [masters]
changed: [worker1]
changed: [worker2]

TASK [install kubelet] *****
changed: [masters]
changed: [worker1]
changed: [worker2]

TASK [install kubeadm] *****
changed: [masters]
changed: [worker1]
changed: [worker2]

PLAY [masters] *****

TASK [Gathering Facts] *****
ok: [masters]

TASK [install kubectl] ******
ok: [masters]

PLAY RECAP ****
masters                     : ok=9    changed=5    unreachable=0    failed=0   
worker1                    : ok=7    changed=5    unreachable=0    failed=0  
worker2                    : ok=7    changed=5    unreachable=0    failed=0  

Now, all the kubernetes dependencies are installed in all the nodes with Ansible. Now, let us configure the master node.

Step 4: Master node setup

To set up the master node, let us create ansible playbook by passing the following command.

nano ~/kube-ansible/master-cluster.yml

Then add the following lines on the above file.

- hosts: masters
  become: yes
  tasks:
    - name: Start the cluster
      shell: kubeadm init --pod-network-cidr=10.244.0.0/16 >> cluster.txt
      args:
        chdir: $HOME
        creates: cluster.txt

    - name: create .kube directory
      become: yes
      become_user: ubuntu
      file:
        path: $HOME/.kube
        state: directory
        mode: 0755

    - name: copy admin.conf to user's kube config
      copy:
        src: /etc/kubernetes/admin.conf
        dest: /home/ubuntu/.kube/config
        remote_src: yes
        owner: ubuntu

    - name: install Pod network
      become: yes
      become_user: ubuntu
      shell: kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/a70459be0084506e4ec919aa1c114638878db11b/Documentation/kube-flannel.yml >> pod_setup.txt
      args:
        chdir: $HOME
        creates: pod_setup.txt

In the above playbook, We have started the cluster first. Then “.kube” Directory will be created with the right permission. Then copying admin configuration file in the “.kube” file. After that, Configuring pod network configuration by installing “flannel”.

Once after adding the above lines. Run the ansible playbook by passing the following command.

ansible-playbook -i hosts ~/kube-ansible/master-cluster.yml

then this will through following output.

PLAY [masters] ****

TASK [Gathering Facts] ****
ok: [masters]

TASK [Start the cluster] ****
changed: [masters]

TASK [create .kube directory] ****
changed: [masters]

TASK [copy admin.conf to user's kube config] *****
changed: [masters]

TASK [install Pod network] *****
changed: [masters]

PLAY RECAP ****
masters                     : ok=5    changed=4    unreachable=0    failed=0  

Verify the node status by passing the following command into the Master node.

kubectl get nodes

and this should give the following output

NAME      STATUS    ROLES     AGE       VERSION
master    Ready     master    0d        v2.13.0

Now, we will set up the worker nodes.

Step 5: Worker nodes setup

In the worker node, we have already installed all the necessary Kubernetes components. Now we just need to attach worker node to master node. To create the same, Open the worker ansible playbook by passing the following command.

nano ~/kube-ansible/workers-cluster.yml

Then, add the following lines.

- hosts: masters
  become: yes
  gather_facts: false
  tasks:
    - name: get join command
      shell: kubeadm token create --print-join-command
      register: join_command_raw

    - name: set join command
      set_fact:
        join_command: "{{ join_command_raw.stdout_lines[0] }}"

- hosts: workers
  become: yes
  tasks:
    - name: join cluster
      shell: "{{ hostvars['masters'].join_command }} >> node_joined.txt"
      args:
        chdir: $HOME
        creates: node_joined.txt

In this, we are adding a task on the master node to create a token to join the worker node to the master node. Then in the worker node, creating a task to join the master node.

To run the Ansible playbook, we need to pass the following command.

ansible-playbook -i hosts ~/kube-ansible/workers-cluster.yml

This will through the following output.

PLAY [masters] ****

TASK [get join command] ****
changed: [masters]

TASK [set join command] *****
ok: [masters]

PLAY [workers] *****

TASK [Gathering Facts] *****
ok: [worker1]
ok: [worker2]

TASK [join cluster] *****
changed: [worker1]
changed: [worker2]

PLAY RECAP *****
masters                     : ok=2    changed=1    unreachable=0    failed=0   
worker1                    : ok=2    changed=1    unreachable=0    failed=0  
worker2                    : ok=2    changed=1    unreachable=0    failed=0  

Now we have configured the worker nodes. Then, let us verify the cluster by passing following command on the master node.

kubectl get nodes

and this should give the following output now.

NAME      STATUS    ROLES     AGE       VERSION
master    Ready     master    0d        v2.13.0
worker1   Ready     <none>    0d        v1.26.0
worker2   Ready     <none>    0d        v1.26.0

If you are seeing the above output, Then, our configurations are working. Now, let us see how we can deploy a sample application on our Kubernetes cluster.

Step 6: Deploying and Running the sample application on the kubernetes cluster.

Let us deploy Apache server on the clusters by passing following command

kubectl create deployment apache-server --image=httpd

This command will create a pod with a container from the image of httpd. Now let us create a service with apache server by passing following command

kubectl expose deploy apache-server --port 80 --target-port 80 --type NodePort

Now, lets see the running services by passing following command.

kubectl get services

This will open the following output

NAME         TYPE        CLUSTER-IP       EXTERNAL-IP           PORT(S)        AGE
Apache-server        NodePort    10.109.228.209   <none>                80:80/TCP   1d

Now we can even test the application on the browser by hitting the following URL, http://172.168.0.11:80 or http://172.168.0.12:80.

Conclusion:

In this article, we have discussed How to Install and Configure the Kubernetes Cluster with Kubeadm and Ansible on Ubuntu 16.04. Running application Kubernetes is an art. We have to learn it from a fine resource. To learn more about the Kubernetes, I recommend this Kubernetes for Absolute Beginners – Hand On. From Udemy

We will discuss more on the Kubernetes in our upcoming articles. Stay tuned for more DevOps, DevSecOps, and Agile related topics.