DEV Community: Deepak Sabhrawal

Latest CKAD Tips 2023

Deepak Sabhrawal — Wed, 08 Nov 2023 17:52:12 +0000

Finally, I was able to clear my CKAD certification with good 92% marks. Although passing is just 66% but these marks shows how seriously I have prepared for this certification because of it's practical nature as compared to the other certification exams.

Courses:
Udemy Course by Mumshad is very good and I think sufficient enough as it covers all the topics: https://www.udemy.com/course/certified-kubernetes-application-developer/

Mock Exam Series: (A must have)
I have purchase the mock exam series from the KodeKloud. https://kodekloud.com/lessons/certified-kubernetes-application-developer-mock-exam-series/

It's bit costly as compared to the course but it is a must have to boost the confidence for the exam.

A nice free source as well: https://killercoda.com/killer-shell-ckad
You can also use their free 1 hour sandbox environment for practice and reset it unlimited times.

TIPS:

Practice thoroughly after completing the theory.
It's confirmed that we get partial marks as well. When I got to know this it was a huge relief for me. Because, the Kodekloud labs only consider a question complete if all the sub-tasks are completed.
I spent good amount of time for one Month and completed theory twice before starting with the Mock exam series.
Just try to complete the labs as many times as you start to feel comfortable with the questions. Mock series will give you a much needed boost to schedule the exam.
Approach I usually follow - Go through one round of theory at a descent pace with proper discipline, it will give you an idea where do you stand and how much time it can take for you to get the certification.
Set the target then and start working on topics you feel you are weak. Try to refer different resources for those topics and prepare well.
Start with the Mock test series, it has 10 tests but halfway only you will start feeling comfortable then you can schedule your exam and go for a final sprint of few days.
I went through theory twice and Mock test series twice. This was enough for me to get the confidence to face the real exam.
Make good amount of use of free killer.sh shell mock exams. You get 2 session and each session has similar questions. My suggestion is to use only one and keep the another session for later on if you are unfortunate to clear in the first attempt.
Always use VIM setting in your practice exams so that you can easily memorise and setup that in your real exam. These VIM settings and alias are great helper in time saving as time is the key in this exam.
Don't stuck with the question, Flag it and keep moving. yes you get the flagging option and that is clearly visible how many questions you have flagged to revisit.
Vim settings I guess enough for the exam: (~/.vimrc)
- set st=2 (preloaded)
- set sw=2 (preloaded)
- set expandtab (preloaded)
- set ai (Auto Indentation)
- set si (Smart Indentaton)
- set ic (Ignore case in search)
- set nu (Number line)
- set ru (Ruler)
- syntax on
- set cursorline (I didn't find it that useful)
- set cursorcolumn (I didn't find it that useful - but sometimes it is just give it a try)
Alias options you can set in bash profile: (~/.bashrc)
- alias kn="kubectl config set-context --current -- namespace"
- alias kf="kubectl create file -f"
- alias kr="kubectl replace file -f"
- alias kgp="kubectl get pod"
- alias kga="kubectl get all"
- export dr="--dry-run=client -oyaml"
- export now="--force --grace-period=0"

Let me know in the comments if you have any specific question or need to discuss anything.

Happy Learning...

Create Multinode Kubernetes Cluster Using Kind

Deepak Sabhrawal — Sun, 17 Sep 2023 15:25:35 +0000

When it comes to running a Kubernetes cluster on a local system there are multiple options but Kind provides simplicity with a near-to-real Kubernetes cluster experience as we can create a multi-node cluster as well. Minikube is another super simple option but I found it a little bit resource-heavy and slow in comparison and abstracts to only a single master node cluster.

To install Kind, follow the instructions here
We can use Kind to create a super simple Kubernetes cluster as well which competes Minikube's simplicity.

kind create cluster --name demo

(base) ~/code/devops/kubernetes/CKAD (master ✗) kind create cluster --name demo 
Creating cluster "demo" ...
 ✓ Ensuring node image (kindest/node:v1.25.3) 🖼 
 ✓ Preparing nodes 📦  
 ✓ Writing configuration 📜 
 ✓ Starting control-plane 🕹️ 
 ✓ Installing CNI 🔌 
 ✓ Installing StorageClass 💾 
Set kubectl context to "kind-demo"
You can now use your cluster with:

kubectl cluster-info --context kind-demo

Have a nice day! 👋

(base) ~/code/devops/kubernetes/CKAD (master ✗) kubectl cluster-info
Kubernetes control plane is running at https://127.0.0.1:53789
CoreDNS is running at https://127.0.0.1:53789/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
(base) ~/code/devops/kubernetes/CKAD (master ✗)

Kind uses docker to host the Kubernetes cluster. Check the docker containers

(base) ~/code/devops/kubernetes/CKAD (master ✗) docker ps
CONTAINER ID   IMAGE                  COMMAND                  CREATED         STATUS         PORTS                       NAMES
9e4a6223159d   kindest/node:v1.25.3   "/usr/local/bin/entr…"   6 minutes ago   Up 6 minutes   127.0.0.1:53789->6443/tcp   demo-control-plane

Now, to create a multi-node cluster we have to use a config file. Save the file content as kind-cluster.yaml

apiVersion: kind.x-k8s.io/v1alpha4
kind: Cluster
nodes:
- role: control-plane
- role: worker
- role: worker

Now create a cluster with following command

kind create cluster --config kind-cluster.yaml

~/code/devops/kubernetes/CKAD (master ✗) kind create cluster --config kind-cluster.yaml 
Creating cluster "kind" ...
 ✓ Ensuring node image (kindest/node:v1.25.3) 🖼 
 ✓ Preparing nodes 📦 📦 📦  
 ✓ Writing configuration 📜 
 ✓ Starting control-plane 🕹️ 
 ✓ Installing CNI 🔌 
 ✓ Installing StorageClass 💾 
 ✓ Joining worker nodes 🚜 
Set kubectl context to "kind-kind"
You can now use your cluster with:

kubectl cluster-info --context kind-kind

Have a question, bug, or feature request? Let us know! https://kind.sigs.k8s.io/#community 🙂

you notice, this time cluster name is kind the default one if we do not provide any name.
You can explore this cluster which has one master node and two worker nodes. You can provide many other configurations as well based on your needs. Check here.

~/code/devops/kubernetes/CKAD (master ✗) kubectl get nodes -o wide
NAME                 STATUS   ROLES           AGE     VERSION   INTERNAL-IP   EXTERNAL-IP   OS-IMAGE             KERNEL-VERSION      CONTAINER-RUNTIME
kind-control-plane   Ready    control-plane   5m48s   v1.25.3   172.18.0.4    <none>        Ubuntu 22.04.1 LTS   5.10.124-linuxkit   containerd://1.6.9
kind-worker          Ready    <none>          5m28s   v1.25.3   172.18.0.3    <none>        Ubuntu 22.04.1 LTS   5.10.124-linuxkit   containerd://1.6.9
kind-worker2         Ready    <none>          5m29s   v1.25.3   172.18.0.2    <none>        Ubuntu 22.04.1 LTS   5.10.124-linuxkit   containerd://1.6.9

~/code/devops/kubernetes/CKAD (master ✗) docker ps 
CONTAINER ID   IMAGE                  COMMAND                  CREATED         STATUS         PORTS                       NAMES
32dc5ba3b1b5   kindest/node:v1.25.3   "/usr/local/bin/entr…"   6 minutes ago   Up 6 minutes   127.0.0.1:53879->6443/tcp   kind-control-plane
68b9e9732f8d   kindest/node:v1.25.3   "/usr/local/bin/entr…"   6 minutes ago   Up 6 minutes                               kind-worker2
616c6893f374   kindest/node:v1.25.3   "/usr/local/bin/entr…"   6 minutes ago   Up 6 minutes                               kind-worker

Happy learning...

Running Custom Docker Images Inside Kind Cluster

Deepak Sabhrawal — Sun, 17 Sep 2023 14:56:33 +0000

We are going to build a docker image locally and then run a Pod inside the Kubernetes cluster with that image.

Build a docker image locally using dockerfile.

Save the following docker file ubuntu-sleep.dockerfile

 FROM ubuntu

 ENTRYPOINT ["sleep"]
 CMD ["5"]

Build image docker build -t ubuntu-sleep -f ubuntu-sleep.dockerfile .

(base) ~/code/devops/kubernetes/CKAD (master ✗) docker build -t ubuntu-sleep -f ubuntu-sleep.dockerfile .
[+] Building 0.1s (5/5) FINISHED                                                                                                  
 => [internal] load build definition from ubuntu-sleeper.dockerfile                                                          0.0s
 => => transferring dockerfile: 51B                                                                                          0.0s
 => [internal] load .dockerignore                                                                                            0.0s
 => => transferring context: 2B                                                                                              0.0s
 => [internal] load metadata for docker.io/library/ubuntu:latest                                                             0.0s
 => CACHED [1/1] FROM docker.io/library/ubuntu                                                                               0.0s
 => exporting to image                                                                                                       0.0s
 => => exporting layers                                                                                                      0.0s
 => => writing image sha256:b739783c0472bbc0008474a0e9f1c5a55dc0419fd4d7851bed8b08fec7596332                                 0.0s
 => => naming to docker.io/library/ubuntu-sleep

Create a Kind Cluster with the name demo.

kind create cluster --name=demo

(base) ~/code/devops/kubernetes/CKAD (master ✗) kind create cluster --name=demo 
Creating cluster "demo" ...
 ✓ Ensuring node image (kindest/node:v1.25.3) 🖼 
 ✓ Preparing nodes 📦  
 ✓ Writing configuration 📜 
 ✓ Starting control-plane 🕹️ 
 ✓ Installing CNI 🔌 
 ✓ Installing StorageClass 💾 
Set kubectl context to "kind-demo"
You can now use your cluster with:

kubectl cluster-info --context kind-demo

Have a nice day! 👋

Load the docker image to the kind cluster demo
kind load docker-image ubuntu-sleep --name demo

(base) ~/code/devops/kubernetes/CKAD (master ✗) kind load docker-image ubuntu-sleep --name demo
Image: "" with ID "sha256:b739783c0472bbc0008474a0e9f1c5a55dc0419fd4d7851bed8b08fec7596332" not yet present on node "demo-control-plane", loading...

Kind load is a very useful command and provides multiple options as well. To get more info about the kind load command use the -h option.

Run a pod inside the demo cluster with the following command
kubectl run ubuntu-sleep --image=ubuntu-sleep

(base) ~/code/devops/kubernetes/CKAD (master ✗) kubectl run ubuntu-sleep --image=ubuntu-sleep
pod/ubuntu-sleep created
(base) ~/code/devops/kubernetes/CKAD (master ✗) kubectl get pod ubuntu-sleep
NAME           READY   STATUS             RESTARTS   AGE
ubuntu-sleep   0/1     ImagePullBackOff   0          14s

When we check the pod status it is ImagePullBackOff which means it is failing in running the container with the given image. Wait, what did we do wrong?
Lets, try to debug the problem. As we all know the Kind runs a kubernetes cluster inside docker right? KIND (Kubernetes Inside Docker)

Run the following command to check if the image is already available.

(base) ~/code/devops/kubernetes/CKAD (master ✗) docker exec -it demo-control-plane crictl images
IMAGE                                      TAG                  IMAGE ID            SIZE
docker.io/kindest/kindnetd                 v20221004-44d545d1   7ba9b35cf55e6       23.7MB
docker.io/kindest/local-path-helper        v20220607-9a4d8d2a   304f67e47fc80       2.75MB
docker.io/kindest/local-path-provisioner   v0.0.22-kind.0       7902f9a1c54fa       15.6MB
docker.io/library/ubuntu-sleep             latest               b739783c0472b       71.8MB
registry.k8s.io/coredns/coredns            v1.9.3               b19406328e70d       13.4MB
registry.k8s.io/etcd                       3.5.4-0              8e041a3b0ba8b       81.1MB
registry.k8s.io/kube-apiserver             v1.25.3              feafd6a91eb52       74.2MB
registry.k8s.io/kube-controller-manager    v1.25.3              05b17bba8656e       62.3MB
registry.k8s.io/kube-proxy                 v1.25.3              aa31a9b19ccdf       59.6MB
registry.k8s.io/kube-scheduler             v1.25.3              253d0aeea8c69       50.6MB
registry.k8s.io/pause                      3.7                  e5a475a038057       268kB

Yeah! it's there. Then what the hack problem is?
If we sit back and relax and look again at the pod events we see it is trying to pull the image, but why? we already have that in our local system.
ahhh! we didn't specify the pull policy and the default one is imagePullPolicy: Always

Events:
  Type     Reason     Age                   From               Message
  ----     ------     ----                  ----               -------
  Normal   Scheduled  12m                   default-scheduler  Successfully assigned default/ubuntu-sleep to demo-control-plane
  Normal   Pulling    10m (x4 over 12m)     kubelet            Pulling image "ubuntu-sleep"
  Warning  Failed     10m (x4 over 12m)     kubelet            Failed to pull image "ubuntu-sleep": rpc error: code = Unknown desc = failed to pull and unpack image "docker.io/library/ubuntu-sleep:latest": failed to resolve reference "docker.io/library/ubuntu-sleep:latest": pull access denied, repository does not exist or may require authorization: server message: insufficient_scope: authorization failed
  Warning  Failed     10m (x4 over 12m)     kubelet            Error: ErrImagePull
  Warning  Failed     10m (x6 over 12m)     kubelet            Error: ImagePullBackOff
  Normal   BackOff    2m19s (x43 over 12m)  kubelet            Back-off pulling image "ubuntu-sleep"

Run the pod again, this time with image-pull-policy option
kubectl run ubuntu-sleep-1 --image=ubuntu-sleep --image-pull-policy=Never

(base) ~/code/devops/kubernetes/CKAD (master ✗) kubectl run ubuntu-sleep-1 --image=ubuntu-sleep --image-pull-policy=Never
pod/ubuntu-sleep-1 created
(base) ~/code/devops/kubernetes/CKAD (master ✗) kubectl get pod 
NAME             READY   STATUS             RESTARTS   AGE
ubuntu-sleep     0/1     ImagePullBackOff   0          8m16s
ubuntu-sleep-1   1/1     Running            0          5s
(base) ~/code/devops/kubernetes/CKAD (master ✗)

woala!!! It is working and the container is running!

Happy Learning...

Kubernetes - Basics

Deepak Sabhrawal — Sat, 09 Sep 2023 11:06:29 +0000

Features:

Container management - Can manage docker containers and other vendor containers as well so it is container-native orchestration tool.
HA - Create a container on a healthy node if any container goes down.
Scaling & Load Balancing - Scale containers based on load and other various parameters, hence balancing the load.
Rolling Update - Update containers without impacting and support many other update strategies.
Rollback - Rollback updates if something went wrong without impact.

Architecture:

K8s Cluster has two main nodes:

Master node (Control Plane): Manages nodes and whole cluster.
K8S Nodes/ Minions (Worker Nodes): Actual worker nodes where Pods are scheduled to run containers.

Cluster Components:

API-Server- Api server facilitates the communication with Kubernetes cluster through the Kubectl command. We provide the manifest yaml file through Kubectl and API-server works accordingly. It interacts with scheduler, Controller, and Key-value store (etcd).
Controller- Manages the health of the cluster and controls everything. Suppose 100 nodes are defined in the manifest file then the controller keeps track to ensure that 100 nodes are running.
Scheduler- Schedules the nodes/pods in the cluster according to the manifest file.
Key-value store (etcd) - This is the true source of information and store nodes information in the form of Key-value. Any node information can be fetched from this store.
Kublet- Kublet is like a manager on a minion node. API-Server interacts with Kublet to deploy the containers. The Kublet interacts with the controller and reports everything about the minion node. All the decisions are then taken by the controller.
Pod- Pod is the wrapping around the container. A pod is a basic unit in a Kubernetes cluster. We do not deploy a Container, always a Pod is deployed and Container runs inside Pod. A pod can have multiple Containers but in general, a single Pod contains a single Container as a best practice. Pod is assigned an IP that is shared among Containers running inside Pod. A pod is also the scaling unit in Kubernetes.
Kube-Proxy- Kube-Proxy acts like a network brain of the cluster and manages the network communication within the cluster.
Runtime- Every node has its own runtime that might differ from other nodes. The most commonly used runtime is docker. This runtime is used to run the containers.

Interaction with a K8s Cluster:

API: Everything happens through API requests.
Native Libraries: If you are a developer and have a used case to manage the cluster using a coding language then you have native libraries to interact with the cluster.
Kube controler (kubectl): This is the main and most used way to connect with a k8s cluster and get the job done.

Kubernetes Config Map

Deepak Sabhrawal — Sun, 18 Apr 2021 05:14:20 +0000

Kubernetes ConfigMap resource is a piece of simple key-value pair information that can be passed to any application running on K8S.

Sample file to create config map on a running cluster:

apiVersion: v1
kind: ConfigMap
metadata:
  name: my-config-map #name of the config map
data:
  myKey1: myValue1
  myKey2: myValue2

Save this file as my-config-map.yaml and create config map on a cluster:

kubectl create -f my-config-map.yaml

Now, ref the values from config map inside a pod.
Lets create a sample busybox pod.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-pod
    image: busybox
    command: ["sh", "-c", "echo $MY_VAR"]
    env:
    - name: MY_VAR
      valueFrom:
        configMapKeyRef:
          name: my-config-map 
          key: myKey1

Save this as my-pod.yaml and create a pod.

kubectl create -f my-pod.yaml

check the logs to see what is printed.

kubectl logs my-pod.   #myValue1

docker swarm cluster using docker-machine

Deepak Sabhrawal — Thu, 30 Apr 2020 19:15:24 +0000

The docker swarm tool is used for managing docker host clusters or orchestration of docker hosts. Today, in this post we will see how we can create a docker swarm cluster locally using Virtualbox and docker-machine. The docker-machine creates docker hosted virtual nodes that are way faster than running virtual machines natively on Virtualbox.

Why docker swarm?

High availability
Container scaling
Load Balancing

We can have many nodes in a cluster but at least one manager node is required to manage multiple worker nodes. Version 1.2 onwards the docker swarm comes natively with the docker and no separate installation is required.

The manager node is responsible for all the operations like high availability, scaling, Load Balancing, etc. and can also act as a worker node to run the load if required.

We will be using docker-machine here, click to learn more about docker-machine and installation guide

Create docker hosted nodes and attach to current shell

Create one manager node using docker-machine
$docker-machine create --driver virtualbox manager
#Get the IP address of the manager node
$ docker-machine ip manager
192.168.99.105
#attach current shell with the worker shell
$eval $(docker-machine env manager)
#activate the manager shell
$docker-machine active
manager
#The current shell is now attached to the manager node

Initialize the docker swarm cluster on the manager node

$ docker swarm init --advertise-addr 192.168.99.105
Swarm initialized: current node (jrivcbnx4jh6opbrm1qed84ue) is now a manager.

To add a worker to this swarm, run the following command:

   docker swarm join --token SWMTKN-1-2wb0sivbsxsx0t3va8wv0qywa303q1mcc2syplrwj0q1301kfs-8qfc9yhwst06y8c1gusftrjkl 192.168.99.105:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

Check Manager Node

$docker node ls
ID                            HOSTNAME            STATUS              AVAILABILITY        MANAGER STATUS      ENGINE VERSION
jrivcbnx4jh6opbrm1qed84ue *   manager             Ready               Active              Leader              19.03.5

Till now we created one manager node using docker-machine and initialized the docker swarm cluster on it.
Now, we will create the worker nodes. You can open another shell to run these commands or run below command to detach the current shell from the docker-machine manager node or switch between the docker-machine environments.

#You will be back to the main shell, unset the environment
$eval $(docker-machine env -u)

Now, let's create a worker node and switch working environment.

$docker-machine create --driver virtualbox worker1
Running pre-create checks...
Creating machine...
(worker1) Copying /home/deepak/.docker/machine/cache/boot2docker.iso to /home/deepak/.docker/machine/machines/worker1/boot2docker.iso...
(worker1) Creating VirtualBox VM...
(worker1) Creating SSH key...
(worker1) Starting the VM...
(worker1) Check network to re-create if needed...
(worker1) Waiting for an IP...
Waiting for machine to be running, this may take a few minutes...
Detecting operating system of created instance...
Waiting for SSH to be available...
Detecting the provisioner...
Provisioning with boot2docker...
Copying certs to the local machine directory...
Copying certs to the remote machine...
Setting Docker configuration on the remote daemon...
Checking connection to Docker...
Docker is up and running!
To see how to connect your Docker Client to the Docker Engine running on this virtual machine, run: docker-machine env worker1

# Run this command to configure your shell to attach to worker1 
$eval $(docker-machine env worker1)
$docker-machine active
worker1

Register this worker node with the docker-swarm cluster with the command we have got in the output of the activating the manager node.

$docker swarm join --token SWMTKN-1-2wb0sivbsxsx0t3va8wv0qywa303q1mcc2syplrwj0q1301kfs-8qfc9yhwst06y8c1gusftrjkl 192.168.99.105:2377
#output: This node joined a swarm as a worker.

Now, switch the docker-machine environment and check the registration on the manager node.

#switch to the manager node & check
$eval $(docker-machine env manager)
$docker-machine active
manager
$docker node ls
ID                            HOSTNAME            STATUS              AVAILABILITY        MANAGER STATUS      ENGINE VERSION
jrivcbnx4jh6opbrm1qed84ue *   manager             Ready               Active              Leader              19.03.5
ymq8yt76ogpywk2eb6rzt9au1     worker1             Ready               Active                                  19.03.5

Repeat the same steps to add another worker node to the swarm cluster.
The $docker node ls command on manager node should return

ID                            HOSTNAME            STATUS              AVAILABILITY        MANAGER STATUS      ENGINE VERSION
jrivcbnx4jh6opbrm1qed84ue *   manager             Ready               Active              Leader              19.03.5
ymq8yt76ogpywk2eb6rzt9au1     worker1             Ready               Active                                  19.03.5
ovr9a15sv0gw2lc68k756qth2     worker2             Ready               Active                                  19.03.5

Now, we have one manager node and two worker nodes active in our swarm cluster. We can add as many nodes as a manager or a worker. To add a manager and a worker node run the below commands to get the join token.
Use the join token to get the node registered in the cluster.

$docker swarm join-token manager
To add a manager to this swarm, run the following command:
    docker swarm join --token SWMTKN-1-2wb0sivbsxsx0t3va8wv0qywa303q1mcc2syplrwj0q1301kfs-0kpbj4agn8ptyzcmegg6c4hnk 192.168.99.105:2377

$docker swarm join-token worker
To add a worker to this swarm, run the following command:
    docker swarm join --token SWMTKN-1-2wb0sivbsxsx0t3va8wv0qywa303q1mcc2syplrwj0q1301kfs-8qfc9yhwst06y8c1gusftrjkl 192.168.99.105:2377

Now, we will create services on our nodes. To create a service run the below command

$ docker service create --name webservice -p 8001:80 nginx:latest
#Check the service
$ docker service ls
ID                  NAME                MODE                REPLICAS            IMAGE               PORTS
05ggmfg0n3o4        webservice          replicated          1/1                 nginx:latest        *:8001->80/tcp

This service can run anywhere in the docker cluster on port 8001, hence 8001 is the cluster-wide port. Let's check where the service is running and if that is running on manager node we can set manager node availability to drain and then the service run on worker nodes only.

$docker service ps webservice
ID                  NAME                IMAGE               NODE                DESIRED STATE       CURRENT STATE                ERROR               PORTS
9tt1y854e55p        webservice.1        nginx:latest        manager             Running             Running about a minute ago                       
#It is running on manager node, set the manager availability to drain 
$docker node update --availability drain manager
manager
$docker service ps webservice
ID                  NAME                IMAGE               NODE                DESIRED STATE       CURRENT STATE             ERROR               PORTS
ns6xellg2hgc        webservice.1        nginx:latest        worker2             Running             Preparing 7 seconds ago                       
9tt1y854e55p         \_ webservice.1    nginx:latest        manager             Shutdown            Shutdown 4 seconds ago  
#The service automatically moved to worker2 node and load removed from manager

Irrespective of where the service is running, if we hit any node in our cluster on port 8001 we should be able to see the nginx welcome page.

Auto Scaling & Load Balancing
Now, we will see how the docker swarm manages the scaling, Load Balancing. To scale the service run below command and it will scale up throughout out the cluster on all available active nodes. Our manager node is in drain state hence no service will be running over there.

$docker service scale webservice=10
webservice scaled to 10
overall progress: 10 out of 10 tasks 
1/10: running   [==================================================>] 
2/10: running   [==================================================>] 
3/10: running   [==================================================>] 
4/10: running   [==================================================>] 
5/10: running   [==================================================>] 
6/10: running   [==================================================>] 
7/10: running   [==================================================>] 
8/10: running   [==================================================>] 
9/10: running   [==================================================>] 
10/10: running   [==================================================>] 
verify: Service converged 

#Verify where these are running
$docker service ps webservice
ID                  NAME                IMAGE               NODE                DESIRED STATE       CURRENT STATE                ERROR               PORTS
ns6xellg2hgc        webservice.1        nginx:latest        worker2             Running             Running 16 minutes ago                           
9tt1y854e55p         \_ webservice.1    nginx:latest        manager             Shutdown            Shutdown 16 minutes ago                          
nza4dxb4gq5t        webservice.2        nginx:latest        worker2             Running             Running about a minute ago                       
tddgybed5mon        webservice.3        nginx:latest        worker2             Running             Running about a minute ago                       
lqgjvagrmscc        webservice.4        nginx:latest        worker1             Running             Running 57 seconds ago                           
0vt8ou31sxds        webservice.5        nginx:latest        worker1             Running             Running 57 seconds ago                           
xrmvbrbir68e        webservice.6        nginx:latest        worker1             Running             Running 57 seconds ago                           
k0f1agcqz11u        webservice.7        nginx:latest        worker1             Running             Running 57 seconds ago                           
y8oa9b9pug0u        webservice.8        nginx:latest        worker2             Running             Running about a minute ago                       
266sik5ude24        webservice.9        nginx:latest        worker1             Running             Running 57 seconds ago                           
mb4jpa4fcigk        webservice.10       nginx:latest        worker2             Running             Running about a minute ago

If you see the service is automatically load-balanced among the active nodes, this is the beauty of the docker swarm automatic load balancer.

High Availability

$docker node update --availability drain worker1
worker1
$docker service ps webservice
ID                  NAME                IMAGE               NODE                DESIRED STATE       CURRENT STATE             ERROR               PORTS
ns6xellg2hgc        webservice.1        nginx:latest        worker2             Running             Running 20 minutes ago                        
9tt1y854e55p         \_ webservice.1    nginx:latest        manager             Shutdown            Shutdown 20 minutes ago                       
nza4dxb4gq5t        webservice.2        nginx:latest        worker2             Running             Running 5 minutes ago                         
tddgybed5mon        webservice.3        nginx:latest        worker2             Running             Running 5 minutes ago                         
fl1649e0h1vj        webservice.4        nginx:latest        worker2             Running             Running 5 seconds ago                         
lqgjvagrmscc         \_ webservice.4    nginx:latest        worker1             Shutdown            Shutdown 7 seconds ago                        
z8bjrweqq676        webservice.5        nginx:latest        worker2             Running             Running 5 seconds ago                         
0vt8ou31sxds         \_ webservice.5    nginx:latest        worker1             Shutdown            Shutdown 7 seconds ago                        
r4q56ukiyz93        webservice.6        nginx:latest        worker2             Running             Running 5 seconds ago                         
xrmvbrbir68e         \_ webservice.6    nginx:latest        worker1             Shutdown            Shutdown 7 seconds ago                        
00vbb5b7dk7s        webservice.7        nginx:latest        worker2             Running             Running 5 seconds ago                         
k0f1agcqz11u         \_ webservice.7    nginx:latest        worker1             Shutdown            Shutdown 7 seconds ago                        
y8oa9b9pug0u        webservice.8        nginx:latest        worker2             Running             Running 5 minutes ago                         
0gaahurh7d81        webservice.9        nginx:latest        worker2             Running             Running 5 seconds ago                         
266sik5ude24         \_ webservice.9    nginx:latest        worker1             Shutdown            Shutdown 7 seconds ago                        
mb4jpa4fcigk        webservice.10       nginx:latest        worker2             Running             Running 5 minutes ago

If you see that, when we set one of our worker nodes to drain state, how high availability is handled. All the load from worker1 node automatically shifted to worker2 node to maintain HA.

Holla! here it comes to an end with the learning of creating docker host using docker-machine and managing nodes, services using docker swarm.

Happy dockering! & Keep learning!

create docker hosted nodes using docker-machine

Deepak Sabhrawal — Sun, 26 Apr 2020 13:05:21 +0000

docker-machine is a component of docker, used to create docker hosted virtual nodes using different drivers like GCP, AWS, Azure, or Virtualbox. Docker hosted nodes are the machines running docker daemon and used to run the docker containers. The Docker machine tool is useful when you want to create a docker cluster on any of the drivers mentioned above using docker swarm.

Today, we will learn to create a virtual machine using docker-machine

Step 1: Check the latest release version available here.
Step 2: Run below command to install docker-machine (change the latest version you find from step 1)

$base=https://github.com/docker/machine/releases/download/v0.16.2 &&
curl -L $base/docker-machine-$(uname -s)-$(uname -m) >/tmp/docker-machine && 
sudo mv /tmp/docker-machine /usr/local/bin/docker-machine 
&& chmod +x /usr/local/bin/docker-machine

Click here for installation on Windows or Mac.

Step 3: Check successful installation

$docker-machine ls
NAME   ACTIVE   DRIVER       STATE     URL     SWARM     DOCKER     ERRORS

*Run last command chmod +x /usr/local/bin/docker-machine if you see any permission issue

Step 4: Install Virtualbox driver for local installation of virtual machines

$sudo apt update && apt upgrade && apt install virtualbox

Step 5: Create virtual machine on Virtualbox with name dev

$docker-machine create --driver virtualbox dev

Step 6: Now, the $docker-machine ls command should return with running machine

$docker-machine ls
NAME   ACTIVE   DRIVER       STATE     URL                       SWARM   DOCKER  ERRORS
dev    -        virtualbox   Running   tcp://192.168.99.100:2376           v19.03.5

You successfully installed docker hosted virtual machine using Virtualbox driver locally, this node can be used for docker swarm worker nodes.

Happy dockering! Keep Learning!

Install docker on Linux

Deepak Sabhrawal — Sat, 25 Apr 2020 02:26:50 +0000

Run the following command to install docker on Linux.

Ubuntu

$sudo apt install docker.io

Arch Linux

$sudo pacman -S docker

Fedora

$sudo dnf install docker

CentOS

$sudo yum install docker

Check if the docker is running with the following command
$sudo docker ps

But, if you will run it without sudo you will get the following error:

Got permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock: Get http://%2Fvar%2Frun%2Fdocker.sock/v1.40/containers/json: dial unix /var/run/docker.sock: connect: permission denied

This happens due to the permission issue as the current user is not having permission to run docker.

Run the below command to add the current user to docker group
$sudo usermod -a -G docker $USER

You must logout and login or restart to let the system run group policy again and add the current user to the docker group
Run below command after re-login

$docker ps -a (to see all processes - running/exited)

To check successful installation of the docker
$docker run hello-world

Output

Hello from Docker!
This message shows that your installation appears to be working correctly.

Congratulations! you successfully installed docker on your system