hostnamectl set-hostname clusterserver1.rmohan.com
ifconfig -a
vi /etc/selinux/config
systemctl disable firewalld
systemctl stop firewalld
vi /etc/hosts
yum install wget
yum update
yum remove docker docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-selinux docker-engine-selinux docker-engine
yum install -y yum-utils device-mapper-persistent-data lvm2
yum-config-manager –add-repo https://download.docker.com/linux/centos/docker-ce.repo
yum-config-manager –enable docker-ce-edge
yum list docker-ce –showduplicates | sort -r
yum install docker-ce

systemctl enable docker

systemctl start docker

 

Uninstall Docker CE

1. Uninstall the Docker package:

   $yum remove docker-ce
   

2. Images, containers, volumes, or customized configuration files on your host are not automatically removed. To delete all images, containers, and volumes:

   $ rm -rf /var/lib/docker

Docker is an open-source tool that automates the deployment of applications inside software containers by providing an additional layer of abstraction of operating system level virtualization on Linux. Docker makes it easier to create, deploy and run applications by using containers. Containers allow a developer to package up an application with all of the libraries and dependencies, and ship it all out as one package. Docker is same as virtual machine, rather than creating a whole virtual operating system. Docker allows applications to use the same Linux kernel as the system that they are running on. This gives a significant performance boost and reduces the size of the application.

Docker is preferred by many system admins and developers to maximize their creativity in an App production environment. For system admins, Docker gives flexibility and reduces the number of systems needed because of its small footprint and lower overhead.

In this tutorial, We’ll learn how to install Docker on CentOS-7.

##Requirements

CentOS-7 64-bit configured with static IP address. Kernel version must be 3.10 at minimum.

##Installing Docker

It is recommended to update your system before installing docker.

To update the system, Run:

sudo yum -y update

Docker package is not available in CentOS-7 repository. So you need to create repo for docker.

You can create docker repo by creating docker.repo file inside /etc/yum.repos.d/ directory.

sudo nano /etc/yum.repos.d/docker.repo

Add the following line:

[dockerrepo]
name=Docker Repository
baseurl=https://yum.dockerproject.org/repo/main/centos/7
enabled=1
gpgcheck=1
gpgkey=https://yum.dockerproject.org/gpg

After creating docker repo, run the following command to install docker.

sudo yum install docker-engine

Once docker has been installed, it is recommended to start docker service and set docker service to start at boot.

You can do this by running the following command:

sudo systemctl start docker.service sudo systemctl enable docker.service

You can check the status of Docker by running the following command:

sudo systemctl status docker.service

Finally, you can verify that the latest version of docker is installed with the following command

sudo docker version

You can see the output some thing like this:

Client:
 Version:      1.10.0
 API version:  1.22
 Go version:   go1.5.3
 Git commit:   590d5108
 Built:        Thu Feb  4 18:36:33 2016
 OS/Arch:      linux/amd64

Server:
Version: 1.10.0
API version: 1.22
Go version: go1.5.3
Git commit: 590d5108
Built: Thu Feb 4 18:36:33 2016
OS/Arch: linux/amd64


##Working With Docker

###Downloading a Docker Container

Let’s start using docker. You will need to have an image present on your host machine where the containers will exist. You can download the CentOS docker image by running the following command.

sudo docker pull centos

You can see the output some thing like this:

Using default tag: latest
latest: Pulling from library/centos

a3ed95caeb02: Pull complete
196355c4b639: Pull complete
Digest: sha256:381f21e4c7b3724c6f420b2bcfa6e13e47ed155192869a2a04fa10f944c78476
Status: Downloaded newer image for centos:latest


###Running a Docker Container

Now, You just run one command to setup a basic CentOS container with a bash shell.

To run a command in new container, Run:

sudo docker run -i -t centos /bin/bash

Note: -i flag attaches stdin and stdout and -t flag allocates a tty.

That’s it. Now you’re using a bash shell inside of a centos docker container.

There are many containers already available on docker website. You can found any container through a search. For example to search centos container, Run:

sudo docker search centos

You can see the output some thing like this:

NAME                            DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
centos                          The official build of CentOS.                   2079      [OK]       
jdeathe/centos-ssh              CentOS-6 6.7 x86_64 / CentOS-7 7.2.1511 x8...   19                   [OK]
jdeathe/centos-ssh-apache-php   CentOS-6 6.7 x86_64 / Apache / PHP / PHP M...   14                   [OK]
million12/centos-supervisor     Base CentOS-7 with supervisord launcher, h...   10                   [OK]
blalor/centos                   Bare-bones base CentOS 6.5 image                8                    [OK]
nimmis/java-centos              This is docker images of CentOS 7 with dif...   8                    [OK]
torusware/speedus-centos        Always updated official CentOS docker imag...   7                    [OK]
centos/mariadb55-centos7                                                        3                    [OK]
nickistre/centos-lamp           LAMP on centos setup                            3                    [OK]
nathonfowlie/centos-jre         Latest CentOS image with the JRE pre-insta...   3                    [OK]
consol/sakuli-centos-xfce       Sakuli end-2-end testing and monitoring co...   2                    [OK]
timhughes/centos                Centos with systemd installed and running       1                    [OK]
darksheer/centos                Base Centos Image -- Updated hourly             1                    [OK]
softvisio/centos                Centos                                          1                    [OK]
lighthopper/orientdb-centos     A Dockerfile for creating an OrientDB imag...   1                    [OK]
yajo/centos-epel                CentOS with EPEL and fully updated              1                    [OK]
grayzone/centos                 auto build for centos.                          0                    [OK]
ustclug/centos                   USTC centos                                    0                    [OK]
januswel/centos                 yum update-ed CentOS image                      0                    [OK]
dmglab/centos                   CentOS with some extras - This is for the ...   0                    [OK]
jsmigel/centos-epel             Docker base image of CentOS w/ EPEL installed   0                    [OK]
grossws/centos                  CentOS 6 and 7 base images with gosu and l...   0                    [OK]
labengine/centos                Centos image base                               0                    [OK]
lighthopper/openjdk-centos      A Dockerfile for creating an OpenJDK image...   0                    [OK]
blacklabelops/centos            CentOS Base Image! Built and Updates Daily!     0                    [OK]

You can also list all available images on your system using the following command:

sudo docker images

You can see the output some thing like this:

REPOSITORY                  TAG                 IMAGE ID            CREATED             SIZE
firefox-instance            latest              8e61bff07fa0        3 weeks ago         354.6 MB
centos                      latest              d0e7f81ca65c        4 weeks ago         196.6 MB
debian                      latest              f50f9524513f        4 weeks ago         125.1 MB
apache/ubuntu               latest              196655130bc9        4 weeks ago         224.1 MB
apache-instance             latest              7da78270c5f7        4 weeks ago         224.1 MB
apache-instance             ubuntu              7da78270c5f7        4 weeks ago         224.1 MB
hitjethva/apache-instance   ubuntu              7da78270c5f7        4 weeks ago         224.1 MB

##Docker basic command lines

Let’s start with seeing all available commands docker have.

You can list all available docker command by running the following command:

sudo docker

You should see the following output:

Commands:
``` language-bash
    attach    Attach to a running container
    build     Build an image from a Dockerfile
    commit    Create a new image from a container's changes
    cp        Copy files/folders between a container and the local filesystem
    create    Create a new container
    diff      Inspect changes on a container's filesystem
    events    Get real time events from the server
    exec      Run a command in a running container
    export    Export a container's filesystem as a tar archive
    history   Show the history of an image
    images    List images
    import    Import the contents from a tarball to create a filesystem image
    info      Display system-wide information
    inspect   Return low-level information on a container or image
    kill      Kill a running container
    load      Load an image from a tar archive or STDIN
    login     Register or log in to a Docker registry
    logout    Log out from a Docker registry
    logs      Fetch the logs of a container
    network   Manage Docker networks
    pause     Pause all processes within a container
    port      List port mappings or a specific mapping for the CONTAINER
    ps        List containers
    pull      Pull an image or a repository from a registry
    push      Push an image or a repository to a registry
    rename    Rename a container
    restart   Restart a container
    rm        Remove one or more containers
    rmi       Remove one or more images
    run       Run a command in a new container
    save      Save an image(s) to a tar archive
    search    Search the Docker Hub for images
    start     Start one or more stopped containers
    stats     Display a live stream of container(s) resource usage statistics
    stop      Stop a running container
    tag       Tag an image into a repository
    top       Display the running processes of a container
    unpause   Unpause all processes within a container
    update    Update resources of one or more containers
    version   Show the Docker version information
    volume    Manage Docker volumes
    wait      Block until a container stops, then print its exit code

Run ‘docker COMMAND –help’ for more information on a command.

To check system-wide information on docker, run:

`sudo docker info`

You should see the following output:


Containers: 6 Running: 0 Paused: 0 Stopped: 6 Images: 22 Server Version: 1.10.0 Storage Driver: aufs Root Dir: /var/lib/docker/aufs Backing Filesystem: extfs Dirs: 35 Dirperm1 Supported: false Execution Driver: native-0.2 Logging Driver: json-file Plugins: Volume: local Network: bridge null host Kernel Version: 3.13.0-32-generic Operating System: Zorin OS 9 OSType: linux Architecture: x86_64 CPUs: 4 Total Memory: 3.746 GiB Name: Vyom-PC ID: G2NZ:3DDJ:KJFV:HC2E:HR3Y:J4JH:TX2D:EX57:K26Y:3AFH:FGKB:XEIF Username: hitjethva Registry: https://index.docker.io/v1/ WARNING: No swap limit support

You can use the following command to list all running containers:

`sudo docker ps`

You can see the running container in following image:


CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 534544f2e924 centos “/bin/bash” 30 seconds ago Up 29 seconds boring_hamilton “`

You can also list both running and non-running containers by running the following command:

sudo docker ps -a

Sometimes container stops due to its process ending or you stopping it explicitly. In this situation you can run container again with container ID.

sudo docker run "container ID"

You can also stop a running container by running the following command:

sudo docker stop "container ID"

Note: You can find container ID using sudo docker ps command.

If you would like to save the changes you have made with a container, use commit command to save to save it as an image.

sudo docker commit "container ID" image_name

This command turns your container to an image. You can roll back when your container you need.

If you want to attach into a running container, Docker allows you to interaction with running containers using the attach command.

You can use attach command with the container ID..

sudo docker attach "container ID"

##Stop and Delete all Containers and Images

To stop all running containers, Run:

sudo docker stop $(docker ps -a -q)

To delete all existing containers, Run:

sudo docker rm $(docker ps -a -q)

To delete all existing images, Run:

sudo docker rmi $(docker images -q -a)

##Conclusion

Congratulations! You now have a centos server with a Docker platform for your application development environment.

Kubernetes (commonly known as K8s) is an open source system for automatically deploying, extending, and managing containerized applications and is an “open source” version of Borg, Google’s internal tool.

Kubernetes is currently recognized as the most advanced container cluster management tool. After the release of version 1.0, Kubernetes has been developing at a faster speed and has been fully supported by container ecosystem companies, including coreos, rancher, and many other public cloud services. Vendors also provide infrastructure services based on Kubernetes’ secondary development when providing container services, such as Huawei. It can be said that Kubernetes is also Docker’s foray into the strongest competitors in container cluster management and service orchestration (Docker Swarm).

Kubernetes defines a set of building blocks that together provide a mechanism for deploying, maintaining, and extending applications. The components that make up Kubernetes are designed to be loosely coupled and scalable so that they can meet a variety of different workloads. Scalability is largely provided by the Kubernetes API – it is used as an internal component of extensions and containers that run on Kubernetes.

Because Kubernetes is a system made up of many components, it is still difficult for Kubernetes to install and deploy, and Kubernetes is developed by Google. There are many internal dependencies that need to be accessed through the wall.

Of course, there are quick installation tools, such as kubeadm, kubeadm is the official tool provided by Kubernetes to quickly install and initialize the Kubernetes cluster. Currently, it is still in an incubator development state. With the release of Kubernetes, the release of each version will be updated synchronously. Of course, the current kubeadm It cannot be used in a production environment.

 

 

2. Kubernetes features

Kubernetes features:

• Simple : lightweight, simple, easy to use
• Portable : public, private, hybrid, multi-cloud
• Extensible : modular, plug-in, mountable, combinable
• Self -healing : Automatic layout, automatic restart, automatic copy

In layman terms:

• Automated container deployment and replication
• Expand or shrink containers at any time
• Organize containers into groups and provide load balancing among containers
• Easily upgrade new versions of application containers
• Provide container flexibility to replace a container if it fails

3. Kubernetes terminology

Kubernetes terminology:

• Master Node : The computer used to control the Kubernetes node. All task assignments come from this.
• Minion Node : The computer that performs the request and assignment tasks. The Kubernetes host is responsible for controlling the nodes.
• Namespace : Namespace is an abstract set of a set of resources and objects. For example, it can be used to divide the internal objects of the system into different project groups or user groups. The common pods, services, replication controllers, and deployments are all part of a namespace (the default is default), while node, persistentVolumes, etc. do not belong to any namespace.
• Pod : A container group that is deployed on a single node and contains one or more containers. A Pod can be created, scheduled, and shared with all Kubernetes managed minimum deployment units, all containers in the same container set. IP address, IPC, host name, and other resources. The container set abstracts the network and storage from the underlying container so that you can more easily move the container in the cluster.
• Deployment : Deployment is a new generation of objects for Pod management. Compared with Replication Controller, it provides more complete functionality and is easier and more convenient to use.
• Replication Controller : The replication controller manages the lifecycle of pods. They ensure that a specified number of pods are running at any given time. They do this by creating or deleting pods.
• Service : The service provides a single stable name and address for a group of pods. The service separates the work definition from the container set. The Kubernetes service agent automatically assigns the service request to the correct container set—whether or not the container set moves to the cluster. Which position in it, even if it has been replaced.
• Lable : Labels are used to organize and select object groups based on key-value pairs, which are used for each Kubernetes component.

In Kubernetes, all containers are run in a Pod, a Pod to hold a single container, or multiple cooperating containers. In the latter case, the containers in the Pod are guaranteed to be placed on the same machine and resources can be shared. A Pod can also contain zero or more volumes. Volumes are private to a container or can be shared between containers in a Pod. For each Pod created by the user, the system finds a machine that is healthy and has sufficient capacity, and then starts to start the corresponding container there. If a container fails, it is automatically restarted by Kubernetes’ node agent. This node agent is called a Kubelet. However, if the Pod or his machine fails, it will not be automatically transferred or restarted unless the user also defines a Replication Controller.

Pod’s copy sets can collectively form an entire application, a microservice, or a layer of a multi-tier application. Once the Pod is created, the system continuously monitors their health status and the health of the machine they are running on. If a Pod has problems due to a software problem or a machine failure, the Replication controller automatically creates a new Pod on a healthy machine.

Kubernetes supports a unique network model. Kubernetes encourages the use of flat address spaces and does not dynamically allocate ports, but rather allows users to choose any port that suits them. To achieve this, it assigns each Pod an IP address.

Kubernetes provides an abstraction of Service that provides a stable IP address and DNS name to correspond to a set of dynamic pods, such as a set of pods that make up a microservice. This Pod group is defined by the Label selector, because you can specify any Pod group. When a container running in a Kubernetes Pod connects to this address, the connection is forwarded by the local proxy (called the kube proxy). The agent runs on the source machine, the forwarding destination is a corresponding back-end container, and the exact back-end is selected by the round-robin policy to balance the load. The kube proxy will also track the dynamic changes of the backend Pod group, such as when the Pod is replaced by a new Pod on the new machine, so the IP and DNS names of the service do not need to be changed.

Every Kubernetes resource, such as a pod, is identified by a URI and has a UID. One of the key components in URIs is the type of object (eg, Pod), the name of the object, and the namespace of the object. For a particular object type, each name is unique in its namespace, given the name of an object is not given in the namespace, that is the default namespace, UID in both time and space range only.

---

More about Service:

• Service is an application service abstraction that provides load balancing and service discovery for the application through labels. The list of Pod IPs and ports that match the labels constitutes endpoints, which are used by kube-proxy to load balance the service IP to these endpoints.
• Each Service automatically assigns a cluster IP (virtual address accessible only within the cluster) and a DNS name from which other containers can access the service without having to know about the backend container’s operation.

 

 

Kubernetes components

Kubernetes components:

• kubectl : client command-line tool, formatted commands sent to the kube-apiserver accepted as the operation of the entire system entrance.
• Kube-apiserver : Serves as a control entry for the entire system, providing interfaces with REST API services.
• kube-controller-manager : Used to perform background tasks in the entire system, including the status of nodes, the number of pods, and the association between Pods and Service.
• kube-scheduler ( Pods are scheduled to Node): Responsible for node resource management, accept PUBs created from kube-apiserver and assign them to a node.
• etcd : Responsible for service discovery and configuration sharing between nodes.
• kube-proxy : Runs on each compute node, responsible for the Pod web proxy. Regular Getd service information from etcd to do the appropriate strategy.
• kubelet : runs on each compute node, acts as an agent, accepts Pods tasks and management containers that are assigned to this node, periodically obtains container status and feeds back to kube-apiserver.
• DNS : An optional DNS service for creating DNS records for each Service object so that all pods can access services through DNS.
• flannel : Flannel is CoreOS team designed a cover for Kubernetes network (Overlay Network) tool, you need to download another deployment. We know that when we start Docker there will be an IP address for interacting with the container. If you do not manage it, the IP address may be the same on all machines, and it is limited to communicate on the machine, you can not access Docker containers on other machines. The purpose of the Flannel is to re-plan the use of IP addresses for all nodes in the cluster, so that containers on different nodes can obtain IP addresses that belong to the same intranet and do not duplicate IP addresses, and allow containers belonging to different nodes to directly pass the IP address. Network IP communication.

master node contains the components:

docker
etcd
kube-apiserver
kube-controller-manager
kubelet
kube-scheduler

The minion node contains components:

Docker
kubelet
kube-proxy