Blog

Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications. It groups containers that make up an application into logical units for easy management and discovery.

Kubernetes is an open-source platform designed to automate deploying, scaling, and operating application containers. With Kubernetes, you can quickly and efficiently respond to customer demand: Deploy your applications quickly and predictably.

Docker container is an open source software development platform. Its main benefit is to package applications in “containers,” allowing them to be portable among any system running the Linux operating system (OS).

These master and node machines run the Kubernetes cluster orchestration system. A container cluster is the foundation of Container Engine: the Kubernetes objects that represent your containerized applications all run on top of a cluster.

Docker Swarm is a clustering and scheduling tool for Docker containers. With Swarm, IT administrators and developers can establish and manage a cluster of Docker nodes as a single virtual system.

OpenShift Online is Red Hat’s public cloud application development and hosting platform that automates the provisioning, management and scaling of applications so that you can focus on writing the code for your business, startup, or big idea.

Namespaces are intended for use in environments with many users spread across multiple teams, or projects. Namespaces are a way to divide cluster resources between multiple uses (via resource quota). In future versions of Kubernetes, objects in the same namespace will have the same access control policies by default.

A node is a worker machine in Kubernetes, previously known as a minion. A node may be a VM or physical machine, depending on the cluster. Each node has the services necessary to run pods and is managed by the master components. The services on a node include Docker, kubelet and kube-proxy.

Heapster is a cluster-wide aggregator of monitoring and event data. It supports Kubernetes natively and works on all Kubernetes setups, including our Deis Workflow setup.

A container cluster is a set of Compute Engine instances called nodes. It also creates routes for the nodes, so that containers running on the nodes can communicate with each other. The Kubernetes API server does not run on your cluster nodes. Instead, Container Engine hosts the API server.

Kubelet run pods. The unit of execution that Kubernetes works with is the pod. A pod is a collection of containers that share some resources: they have a single IP, and can share volumes.

Minikube is a tool that makes it easy to run Kubernetes locally. Minikube runs a single-node Kubernetes cluster inside a VM on your laptop for users looking to try out Kubernetes or develop with it day-to-day.

kubectl is a command line interface for running commands against Kubernetes clusters. This overview covers kubectl syntax, describes the command operations, and provides common examples. For details about each command, including all the supported flags and subcommands, see the kubectl reference documentation.

Google Container Engine (GKE) is a management and orchestration system for Docker container and container clusters that run within Google’s public cloud services. Google Container Engine is based on Kubernetes, Google’s open source container management system.

Kubernetes, also sometimes called K8S (K – eight characters – S), is an open source orchestration framework for containerized applications that was born from the Google data centers.

Synopsis. The Kubernetes network proxy runs on each node. Service cluster ips and ports are currently found through Docker-links-compatible environment variables specifying ports opened by the service proxy. There is an optional addon that provides cluster DNS for these cluster IPs.

Kube-apiserver process runs on Kubernetes master node.

Kube-proxy process runs on Kubernetes non-master node.

kube-apiserver process validates and configures data for the api objects.

kube-controller-manager embeds the core control loop which is a non-terminating loop that regulates the state of the system.

Kubernetes controllers are Replicaset, Deployment controller.

etcd is responsible for storing Kubernetes cluster data.

kube-scheduler is responsible for assigning a node to newly created pods.

Kubectl, Kubelet, and Node Controller components interacts with Kubernetes node interface. 

We can introduce probes. A liveness probe with a Pod is ideal in this scenario.

A liveness probe always checks if an application in a pod is running, if this check fails the container gets restarted. This is ideal in many scenarios where the container is running but somehow the application inside a container crash.

spec:

containers:

- name: liveness

image: k8s.gcr.io/liveness

args:

- /server

livenessProbe:

      httpGet:

        path: /healthz

By declaring pods with the label(s) and by having a selector in the service which acts as a glue to stick the service to the pods.

kind: Service

apiVersion: v1

metadata:

name: my-service

spec:

  selector:

    app: MyApp

ports:

- protocol: TCP

port: 80

Let’s say if we have a set of Pods that carry a label “app=MyApp” the service will start routing to those pods.

Etcd is a shop for the setup, state, and also metadata of Kubernetes collections. It is composed in Go shows language and also stands for the collection state at an offered factor in time. This datastore works as the foundation of dispersed systems.

Using kubectl get --raw=/healthz/etcd

Using kubectl describe configmap cluster-autoscaler-status -n kube-system

 Using kubectl get pods --field-selector=status.phase!=Running --all-namespaces

Using kubectl get pods -n sock-shop -l name=carts -o wide

Minikube is a tool that allows us to run a Kubernetes setup locally within a virtual machine. It lets us run a single-node Kubernetes cluster on our personal computer to try out Kubernetes or essential development work.

kubectl has a syntax to use as follows:

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

• kubectl get all
• kubectl get namespaces
• kubectl get configmaps
• kubectl get nodes
• kubectl get pods
• kubectl get rs
• kubectl get svc kuard
• kubectl get endpoints kuard

The types of Kubernetes volume are:

• EmptyDir
• GCE persistent disk
• Flocker
• HostPath
• NFS
• ISCSI
• Rbd
• PersistentVolumeClaim
• downwardAPI

Get logs.

kubectl logs -l app=kuard

Get logs for previously terminated container.

kubectl logs POD_NAME --previous

Watch logs in real time.

kubectl attach POD_NAME

Copy files out of pod (Requires tar binary in container).

kubectl cp POD_NAME:/var/log .

For Linux

alias k=kubectl

For Windows

Set-Alias -Name k -Value kubectl

A static IP for the Kubernetes load balancer can be achieved by changing DNS records since the Kubernetes Master can assign a new static IP address.

It is the transition of the monolithic codebase to a microservice design so that different microservices can be classified as containers. Then Kubernetes could be used for deploying and orchestrating the containers.

To create: kubectl create –f Deployment.yaml –record

To fetch: kubectl get deployments

To check the status: kubectl rollout status deployment/Deployment.

To update a deployment: kubectl set image deployment/Deployment tomcat = tomcat:6.0

 Kube-proxy is a network-proxy that runs on each and every node and also reflects as defined in the Kubernetes API. This proxy can also perform stream forwarding across a set of backends. It is one of the optional add-ons that provide the DNS cluster for the cluster APIs.

The syntax to configure Proxy is:

1. kube-proxy [flags]

They are components of the master node.

They are the work-horse / worker node of the cluster.

They are monitoring engines used widely in kubernetes.

They are docker container services.

Kubernetes:

1. Kubernetes provides an auto-scaling feature.
2. Kubernetes installation is very complicated and time-consuming.
3. GUI features are available.
4. It provides a built-in load balancing technique.
5. Load balancing settings are configured manually.

Docker Swarm:

1. Docker swarm doesn’t provide any auto-scaling feature.
2. Docker installation is very easy and fast.
3. GUI features are not available.
4. Services are maintained while updating with process scheduling
5. Load balancing is automated.

• Grafana
• Elastics stack
• Kube watch
• Jaager
• Sensu go
• Datadog
• Linkerd
• Replex
• Epsagon
• Prometheus
• Fluentd

• Minikube
• Kubeadm
• Kops
• Kubespray
• Jaas
• Amazon eks
• Kube aws
• Conjure-up