DEV Community: Vijay Daswani

Sharing folder and files with python http_server and ngrok to get an external url.

Vijay Daswani — Fri, 06 Aug 2021 23:48:04 +0000

Python standard library comes with a in-built webserver which can be invoked for simple web client server communication. The port number can be assigned programmatically and the web server is accessed through this port. Though it is not a full featured web server which can parse many kinds of file, it can parse simple static html files and serve them by responding them with required response codes.

Make sure you have python installed on the machine.

Run below command, it will serve the current folder in web browser.

Go into a folder which you want to share.

if you have python 2.7 run below command.

python -m SimpleHTTPServer

if you have python 3+ then try below command.

python3 -m http.server

Output shown below.

And now the best part is to share it with other than localhost.
Install ngrok. https://ngrok.com/download

Once you have the ngrok.
run below command.

ngrok http 8000

Output.

Paste local tunnel url/ forwarding url to the browser and url can be share with anyone and they can download the files from anywhere.

Thanks for reading. :)

CKAD Exam Practice Exercise : Services and Networking

Vijay Daswani — Sun, 07 Jun 2020 13:31:20 +0000

Services and Networking (13%)

Practice questions based on these concepts

Understand Services
Demonstrate a basic understanding of NetworkPolicies

Exercise

Create an nginx pod with a yaml file with label my-nginx and expose the port 80

kubectl run nginx --image=nginx --restart=Never --port=80 --dry-run -o yaml &gt; nginx.yaml

// edit the label app: my-nginx and create the pod
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    app: my-nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f nginx.yaml

Create the service for this nginx pod with the pod selector app: my-nginx

// create the below service
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my-nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 9376

kubectl create -f nginx-svc.yaml

Find out the label of the pod and verify the service has the same label

// get the pod with labels
kubectl get po nginx --show-labels

// get the service and chekc the selector column
kubectl get svc my-service -o wide

Delete the service and create the service with kubectl expose command and verify the label

// delete the service
kubectl delete svc my-service

// create the service again
kubectl expose po nginx --port=80 --target-port=9376

// verify the label
kubectl get svc -l app=my-nginx

Delete the service and create the service again with type NodePort

// delete the service
kubectl delete svc nginx

// create service with expose command
kubectl expose po nginx --port=80 --type=NodePort

Create the temporary busybox pod and hit the service. Verify the service that it should return the nginx page index.html

// get the clusterIP from this command
kubectl get svc nginx -o wide

// create temporary busybox to check the nodeport
kubectl run busybox --image=busybox --restart=Never -it --rm -- wget -o- :80

Create a NetworkPolicy which denies all ingress traffic

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
spec:
  podSelector: {}
  policyTypes:
  - Ingress

CKAD Exam Practice Exercise : Observability

Vijay Daswani — Sun, 07 Jun 2020 13:22:42 +0000

Observability (18%)

Practice questions based on these concepts

Understand LivenessProbes and ReadinessProbes
Understand Container Logging
Understand how to monitor applications in kubernetes
Understand Debugging in Kubernetes

Exercise

Create an nginx pod with containerPort 80 and it should only receive traffic only it checks the endpoint / on port 80 and verify and delete the pod

kubectl run nginx --image=nginx --restart=Never --port=80 --dry-run -o yaml &gt; nginx-pod.yaml

// add the readinessProbe section and create
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    ports:
    - containerPort: 80
    readinessProbe:
      httpGet:
        path: /
        port: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f nginx-pod.yaml

// verify
kubectl describe pod nginx | grep -i readiness
kubectl delete po nginx

Create an nginx pod with containerPort 80 and it should check the pod running at endpoint / healthz on port 80 and verify and delete the pod

kubectl run nginx --image=nginx --restart=Never --port=80 --dry-run -o yaml &gt; nginx-pod.yaml

// add the livenessProbe section and create
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    ports:
    - containerPort: 80
    livenessProbe:
      httpGet:
        path: /healthz
        port: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f nginx-pod.yaml

// verify
kubectl describe pod nginx | grep -i readiness
kubectl delete po nginx

Create an nginx pod with containerPort 80 and it should check the pod running at endpoint /healthz on port 80 and it should only receive traffic only it checks the endpoint / on port 80. verify the pod

kubectl run nginx --image=nginx --restart=Never --port=80 --dry-run -o yaml &gt; nginx-pod.yaml

// add the livenessProbe and readiness section and create
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    ports:
    - containerPort: 80
    livenessProbe:
      httpGet:
        path: /healthz
        port: 80
    readinessProbe:
      httpGet:
        path: /
        port: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f nginx-pod.yaml

// verify
kubectl describe pod nginx | grep -i readiness
kubectl describe pod nginx | grep -i liveness

Check what all are the options that we can configure with readiness and liveness probes

kubectl explain Pod.spec.containers.livenessProbe
kubectl explain Pod.spec.containers.readinessProbe

Create the pod nginx with the above liveness and readiness probes so that it should wait for 20 seconds before it checks liveness and readiness probes and it should check every 25 seconds.

// nginx-pod.yaml

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    ports:
    - containerPort: 80
    livenessProbe:
      initialDelaySeconds: 20
      periodSeconds: 25
      httpGet:
        path: /healthz
        port: 80
    readinessProbe:
      initialDelaySeconds: 20
      periodSeconds: 25
      httpGet:
        path: /
        port: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f nginx-pod.yaml

Create a busybox pod with this command “echo I am from busybox pod; sleep 3600;” and verify the logs

kubectl run busybox --image=busybox --restart=Never -- /bin/sh -c "echo I am from busybox pod; sleep 3600;"

kubectl logs busybox

copy the logs of the above pod to the busybox-logs.txt and verify

kubectl logs busybox &gt; busybox-logs.txt

cat busybox-logs.txt

List all the events sorted by timestamp and put them into file.log and verify

kubectl get events --sort-by=.metadata.creationTimestamp

// putting them into file.log
kubectl get events --sort-by=.metadata.creationTimestamp &gt; file.log

cat file.log

Create a pod with an image alpine which executes this command ”while true; do echo ‘Hi I am from alpine’; sleep 5; done” and verify and follow the logs of the pod

// create the pod
kubectl run hello --image=alpine --restart=Never  -- /bin/sh -c "while true; do echo 'Hi I am from Alpine'; sleep 5;done"

// verify and follow the logs
kubectl logs --follow hello

Get the memory and CPU usage of all the pods and find out top 3 pods which have the highest usage and put them into the cpu-usage.txt file

// get the top 3 hungry pods
kubectl top pod --all-namespaces | sort --reverse --key 3 --numeric | head -3

// putting into file
kubectl top pod --all-namespaces | sort --reverse --key 3 --numeric | head -3 &gt; cpu-usage.txt

// verify
cat cpu-usage.txt

CKAD Exam Practice Exercise : Configuration

Vijay Daswani — Sun, 07 Jun 2020 13:18:06 +0000

Configuration (18%)

Practice questions based on these concepts

Understand ConfigMaps
Understand SecurityContexts
Define an application’s resource requirements
Create & Consume Secrets
Understand ServiceAccounts

Exercise

List all the configmaps in the cluster

kubectl get cm
     or
kubectl get configmap

Create a configmap called myconfigmap with literal value appname=myapp

kubectl create cm myconfigmap --from-literal=appname=myapp

Verify the configmap we just created has this data

// you will see under data
kubectl get cm -o yaml
         or
kubectl describe cm

delete the configmap myconfigmap we just created

kubectl delete cm myconfigmap

Create a file called config.txt with two values key1=value1 and key2=value2 and verify the file

cat &gt;&gt; config.txt &lt;&lt; EOF
key1=value1
key2=value2
EOF

cat config.txt

Create a configmap named keyvalcfgmap and read data from the file config.txt and verify that configmap is created correctly

kubectl create cm keyvalcfgmap --from-file=config.txt

kubectl get cm keyvalcfgmap -o yaml

Create an nginx pod and load environment values from the above configmap keyvalcfgmap and exec into the pod and verify the environment variables and delete the pod

// first run this command to save the pod yml
kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml &gt; nginx-pod.yml

// edit the yml to below file and create
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    resources: {}
    envFrom:
    - configMapRef:
        name: keyvalcfgmap
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f nginx-pod.yml

// verify
kubectl exec -it nginx -- env
kubectl delete po nginx

Create an env file file.env with var1=val1 and create a configmap envcfgmap from this env file and verify the configmap

echo var1=val1 &gt; file.env
cat file.env

kubectl create cm envcfgmap --from-env-file=file.env
kubectl get cm envcfgmap -o yaml --export

Create an nginx pod and load environment values from the above configmap envcfgmap and exec into the pod and verify the environment variables and delete the pod

// first run this command to save the pod yml
kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml &gt; nginx-pod.yml

// edit the yml to below file and create
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    resources: {}
    env:
    - name: ENVIRONMENT
      valueFrom:
        configMapKeyRef:
          name: envcfgmap
          key: environment
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f nginx-pod.yml

// verify
kubectl exec -it nginx -- env
kubectl delete po nginx

Create a configmap called cfgvolume with values var1=val1, var2=val2 and create an nginx pod with volume nginx-volume which reads data from this configmap cfgvolume and put it on the path /etc/cfg

// first create a configmap cfgvolume
kubectl create cm cfgvolume --from-literal=var1=val1 --from-literal=var2=val2

// verify the configmap
kubectl describe cm cfgvolume

// create the config map 
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  volumes:
  - name: nginx-volume
    configMap:
      name: cfgvolume
  containers:
  - image: nginx
    name: nginx
    resources: {}
    volumeMounts:
    - name: nginx-volume
      mountPath: /etc/cfg
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f nginx-volume.yml

// exec into the pod
kubectl exec -it nginx -- /bin/sh

// check the path
cd /etc/cfg
ls

Create a pod called secbusybox with the image busybox which executes command sleep 3600 and makes sure any Containers in the Pod, all processes run with user ID 1000 and with group id 2000 and verify.

// create yml file with dry-run
kubectl run secbusybox --image=busybox --restart=Never --dry-run -o yaml -- /bin/sh -c "sleep 3600;" &gt; busybox.yml

// edit the pod like below and create
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: secbusybox
  name: secbusybox
spec:
  securityContext: # add security context
    runAsUser: 1000
    runAsGroup: 2000
  containers:
  - args:
    - /bin/sh
    - -c
    - sleep 3600;
    image: busybox
    name: secbusybox
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f busybox.yml

// verify
kubectl exec -it secbusybox -- sh
id // it will show the id and group

Create the same pod as above this time set the securityContext for the container as well and verify that the securityContext of container overrides the Pod level securityContext.

// create yml file with dry-run
kubectl run secbusybox --image=busybox --restart=Never --dry-run -o yaml -- /bin/sh -c "sleep 3600;" &gt; busybox.yml

// edit the pod like below and create
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: secbusybox
  name: secbusybox
spec:
  securityContext:
    runAsUser: 1000
  containers:
  - args:
    - /bin/sh
    - -c
    - sleep 3600;
    image: busybox
    securityContext:
      runAsUser: 2000
    name: secbusybox
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f busybox.yml

// verify
kubectl exec -it secbusybox -- sh
id // you can see container securityContext overides the Pod level

Create pod with an nginx image and configure the pod with capabilities NET_ADMIN and SYS_TIME verify the capabilities

// create the yaml file
kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml &gt; nginx.yml

// edit as below and create pod
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    securityContext:
      capabilities:
        add: ["SYS_TIME", "NET_ADMIN"]
    name: nginx
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f nginx.yml

// exec and verify
kubectl exec -it nginx -- sh
cd /proc/1
cat status

// you should see these values
CapPrm: 00000000aa0435fb
CapEff: 00000000aa0435fb

Create a Pod nginx and specify a memory request and a memory limit of 100Mi and 200Mi respectively.

// create a yml file
kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml &gt; nginx.yml

// add the resources section and create
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    resources: 
      requests:
        memory: "100Mi"
      limits:
        memory: "200Mi"
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f nginx.yml

// verify
kubectl top pod

Create a Pod nginx and specify a CPU request and a CPU limit of 0.5 and 1 respectively.

// create a yml file
kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml &gt; nginx.yml

// add the resources section and create
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    resources:
      requests:
        cpu: "0.5"
      limits:
        cpu: "1"
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f nginx.yml

// verify
kubectl top pod

Create a Pod nginx and specify both CPU, memory requests and limits together and verify.

// create a yml file
kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml &gt; nginx.yml

// add the resources section and create
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    resources:
      requests:
        memory: "100Mi"
        cpu: "0.5"
      limits:
        memory: "200Mi"
        cpu: "1"
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f nginx.yml

// verify
kubectl top pod

Create a Pod nginx and specify a memory request and a memory limit of 100Gi and 200Gi respectively which is too big for the nodes and verify pod fails to start because of insufficient memory

// create a yml file
kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml &gt; nginx.yml

// add the resources section and create
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    resources:
      requests:
        memory: "100Gi"
        cpu: "0.5"
      limits:
        memory: "200Gi"
        cpu: "1"
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f nginx.yml

// verify
kubectl describe po nginx // you can see pending state

Create a secret mysecret with values user=myuser and password=mypassword

kubectl create secret generic my-secret --from-literal=username=user --from-literal=password=mypassword

List the secrets in all namespaces

kubectl get secret --all-namespaces

Output the yaml of the secret created above

kubectl get secret my-secret -o yaml

Create an nginx pod which reads username as the environment variable

// create a yml file
kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml &gt; nginx.yml

// add env section below and create
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    env:
    - name: USER_NAME
      valueFrom:
        secretKeyRef:
          name: my-secret
          key: username
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f nginx.yml

//verify
kubectl exec -it nginx -- env

Create an nginx pod which loads the secret as environment variables

// create a yml file
kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml &gt; nginx.yml

// add env section below and create
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    envFrom:
    - secretRef:
        name: my-secret
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f nginx.yml

//verify
kubectl exec -it nginx -- env

List all the service accounts in the default namespace

kubectl get sa

List all the service accounts in all namespaces

kubectl get sa --all-namespaces

Create a service account called admin

kubectl create sa admin

Output the YAML file for the service account we just created

kubectl get sa admin -o yaml

Create a busybox pod which executes this command sleep 3600 with the service account admin and verify

kubectl run busybox --image=busybox --restart=Never --dry-run -o yaml -- /bin/sh -c "sleep 3600" &gt; busybox.yml

kubectl create -f busybox.yml

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: busybox
  name: busybox
spec:
  serviceAccountName: admin
  containers:
  - args:
    - /bin/sh
    - -c
    - sleep 3600
    image: busybox
    name: busybox
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

// verify
kubectl describe po busybox

CKAD Exam Practice Exercise : State Persistence

Vijay Daswani — Sun, 07 Jun 2020 13:14:19 +0000

State Persistence (8%)

Practice questions based on these concepts

Understand PersistentVolumeClaims for Storage

Questions

List Persistent Volumes in the cluster

kubectl get pv

Create a hostPath PersistentVolume named task-pv-volume with storage 10Gi, access modes ReadWriteOnce, storageClassName manual, and volume at /mnt/data and verify

// task-pv-volume.yaml

apiVersion: v1
kind: PersistentVolume
metadata:
  name: task-pv-volume
  labels:
    type: local
spec:
  storageClassName: manual
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"

kubectl create -f task-pv-volume.yaml

kubectl get pv

Create a PersistentVolumeClaim of at least 3Gi storage and access mode ReadWriteOnce and verify status is Bound

// task-pv-claim.yaml

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: task-pv-claim
spec:
  storageClassName: manual
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 3Gi

kubectl create -f task-pv-claim.yaml

kubectl get pvc

Delete persistent volume and PersistentVolumeClaim we just created

kubectl delete pvc task-pv-claim
kubectl delete pv task-pv-volume

Create a Pod with an image Redis and configure a volume that lasts for the lifetime of the Pod

// emptyDir is the volume that lasts for the life of the pod

apiVersion: v1
kind: Pod
metadata:
  name: redis
spec:
  containers:
  - name: redis
    image: redis
    volumeMounts:
    - name: redis-storage
      mountPath: /data/redis
  volumes:
  - name: redis-storage
    emptyDir: {}

kubectl create -f redis-storage.yaml

Exec into the above pod and create a file named file.txt with the text ‘This is called the file’ in the path /data/redis and open another tab and exec again with the same pod and verifies file exist in the same path.

// first terminal
kubectl exec -it redis-storage /bin/sh
cd /data/redis
echo 'This is called the file' &gt; file.txt

//open another tab
kubectl exec -it redis-storage /bin/sh
cat /data/redis/file.txt

Delete the above pod and create again from the same yaml file and verifies there is no file.txt in the path /data/redis.

kubectl delete pod redis

kubectl create -f redis-storage.yaml
kubectl exec -it redis-storage /bin/sh
cat /data/redis/file.txt // file doesn't exist

Create PersistentVolume named task-pv-volume with storage 10Gi, access modes ReadWriteOnce, storageClassName manual, and volume at /mnt/data and Create a PersistentVolumeClaim of at least 3Gi storage and access mode ReadWriteOnce and verify status is Bound

kubectl create -f task-pv-volume.yaml
kubectl create -f task-pv-claim.yaml

kubectl get pv
kubectl get pvc

Create an nginx pod with containerPort 80 and with a PersistentVolumeClaim task-pv-claim and has a mouth path "/usr/share/nginx/html"

// task-pv-pod.yaml

apiVersion: v1
kind: Pod
metadata:
  name: task-pv-pod
spec:
  volumes:
    - name: task-pv-storage
      persistentVolumeClaim:
        claimName: task-pv-claim
  containers:
    - name: task-pv-container
      image: nginx
      ports:
        - containerPort: 80
          name: "http-server"
      volumeMounts:
        - mountPath: "/usr/share/nginx/html"
          name: task-pv-storage

kubectl create -f task-pv-pod.yaml

CKAD Exam Practice Exercise : Pod Design

Vijay Daswani — Sun, 07 Jun 2020 13:12:11 +0000

Pod Design (20%)

Practice questions based on these concepts

Understand how to use Labels, Selectors and Annotations
Understand Deployments and how to perform rolling updates
Understand Deployments and how to perform rollbacks
Understand Jobs and CronJobs

Questions

Get the pods with label information

kubectl get pods --show-labels

Create 5 nginx pods in which two of them is labeled env=prod and three of them is labeled env=dev

kubectl run nginx-dev1 --image=nginx --restart=Never --labels=env=dev
kubectl run nginx-dev2 --image=nginx --restart=Never --labels=env=dev
kubectl run nginx-dev3 --image=nginx --restart=Never --labels=env=dev
kubectl run nginx-prod1 --image=nginx --restart=Never --labels=env=prod
kubectl run nginx-prod2 --image=nginx --restart=Never --labels=env=prod

Verify all the pods are created with correct labels

kubeclt get pods --show-labels

Get the pods with label env=dev

kubectl get pods -l env=dev

Get the pods with label env=dev and also output the labels

kubectl get pods -l env=dev --show-labels

Get the pods with label env=prod

kubectl get pods -l env=prod

Get the pods with label env=prod and also output the labels

kubectl get pods -l env=prod --show-labels

Get the pods with label env

kubectl get pods -L env

Get the pods with labels env=dev and env=prod

kubectl get pods -l 'env in (dev,prod)'

Get the pods with labels env=dev and env=prod and output the labels as well

kubectl get pods -l 'env in (dev,prod)' --show-labels

Change the label for one of the pod to env=uat and list all the pods to verify

kubectl label pod/nginx-dev3 env=uat --overwrite

kubectl get pods --show-labels

Remove the labels for the pods that we created now and verify all the labels are removed

kubectl label pod nginx-dev{1..3} env-
kubectl label pod nginx-prod{1..2} env-

kubectl get po --show-labels

Let’s add the label app=nginx for all the pods and verify

kubectl label pod nginx-dev{1..3} app=nginx
kubectl label pod nginx-prod{1..2} app=nginx

kubectl get po --show-labels

Get all the nodes with labels (if using minikube you would get only master node)

kubectl get nodes --show-labels

Label the node (minikube if you are using) nodeName=nginxnode

kubectl label node minikube nodeName=nginxnode

Create a Pod that will be deployed on this node with the label nodeName=nginxnode

kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml &gt; pod.yaml

// add the nodeSelector like below and create the pod

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  nodeSelector:
    nodeName: nginxnode
  containers:
  - image: nginx
    name: nginx
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f pod.yaml

Verify the pod that it is scheduled with the node selector

kubectl describe po nginx | grep Node-Selectors

Verify the pod nginx that we just created has this label

kubectl describe po nginx | grep Labels

Annotate the pods with name=webapp

kubectl annotate pod nginx-dev{1..3} name=webapp
kubectl annotate pod nginx-prod{1..2} name=webapp

Verify the pods that have been annotated correctly

kubectl describe po nginx-dev{1..3} | grep -i annotations
kubectl describe po nginx-prod{1..2} | grep -i annotations

Remove the annotations on the pods and verify

kubectl annotate pod nginx-dev{1..3} name-
kubectl annotate pod nginx-prod{1..2} name-

kubectl describe po nginx-dev{1..3} | grep -i annotations
kubectl describe po nginx-prod{1..2} | grep -i annotations

Remove all the pods that we created so far

kubectl delete po --all

Create a deployment called webapp with image nginx with 5 replicas

kubectl create deploy webapp --image=nginx --dry-run -o yaml &gt; webapp.yaml

// change the replicas to 5 in the yaml and create it

apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: webapp
  name: webapp
spec:
  replicas: 5
  selector:
    matchLabels:
      app: webapp
  strategy: {}
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: webapp
    spec:
      containers:
      - image: nginx
        name: nginx
        resources: {}
status: {}

kubectl create -f webapp.yaml

Get the deployment you just created with labels

kubectl get deploy webapp --show-labels

Output the yaml file of the deployment you just created

kubectl get deploy webapp -o yaml

Get the pods of this deployment

// get the label of the deployment
kubectl get deploy --show-labels

// get the pods with that label
kubectl get pods -l app=webapp

Scale the deployment from 5 replicas to 20 replicas and verify

kubectl scale deploy webapp --replicas=20

kubectl get po -l app=webapp

Get the deployment rollout status

kubectl rollout status deploy webapp

Get the replicaset that created with this deployment

kubectl get rs -l app=webapp

Get the yaml of the replicaset and pods of this deployment

kubectl get rs -l app=webapp -o yaml

kubectl get po -l app=webapp -o yaml

Delete the deployment you just created and watch all the pods are also being deleted

kubectl delete deploy webapp

kubectl get po -l app=webapp -w

Create a deployment of webapp with image nginx:1.17.1 with container port 80 and verify the image version

kubectl create deploy webapp --image=nginx:1.17.1 --dry-run -o yaml &gt; webapp.yaml

// add the port section and create the deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: webapp
  name: webapp
spec:
  replicas: 1
  selector:
    matchLabels:
      app: webapp
  strategy: {}
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: webapp
    spec:
      containers:
      - image: nginx:1.17.1
        name: nginx
        ports:
        - containerPort: 80
        resources: {}
status: {}

kubectl create -f webapp.yaml

// verify
kubectl describe deploy webapp | grep Image

Update the deployment with the image version 1.17.4 and verify

kubectl set image deploy/webapp nginx=nginx:1.17.4

kubectl describe deploy webapp | grep Image

Check the rollout history and make sure everything is ok after the update

kubectl rollout history deploy webapp

kubectl get deploy webapp --show-labels
kubectl get rs -l app=webapp
kubectl get po -l app=webapp

Undo the deployment to the previous version 1.17.1 and verify Image has the previous version

kubectl rollout undo deploy webapp

kubectl describe deploy webapp | grep Image

Update the deployment with the image version 1.16.1 and verify the image and also check the rollout history

kubectl set image deploy/webapp nginx=nginx:1.16.1

kubectl describe deploy webapp | grep Image

kubectl rollout history deploy webapp

Update the deployment to the Image 1.17.1 and verify everything is ok

kubectl rollout undo deploy webapp --to-revision=3

kubectl describe deploy webapp | grep Image

kubectl rollout status deploy webapp

Update the deployment with the wrong image version 1.100 and verify something is wrong with the deployment

kubectl set image deploy/webapp nginx=nginx:1.100

kubectl rollout status deploy webapp (still pending state)

kubectl get pods (ImagePullErr)

Undo the deployment with the previous version and verify everything is Ok

kubectl rollout undo deploy webapp
kubectl rollout status deploy webapp

kubectl get pods

Check the history of the specific revision of that deployment

kubectl rollout history deploy webapp --revision=7

Pause the rollout of the deployment

kubectl rollout pause deploy webapp

Update the deployment with the image version latest and check the history and verify nothing is going on

kubectl set image deploy/webapp nginx=nginx:latest

kubectl rollout history deploy webapp (No new revision)

Resume the rollout of the deployment

kubectl rollout resume deploy webapp

Check the rollout history and verify it has the new version

kubectl rollout history deploy webapp

kubectl rollout history deploy webapp --revision=9

Apply the autoscaling to this deployment with minimum 10 and maximum 20 replicas and target CPU of 85% and verify hpa is created and replicas are increased to 10 from 1

kubectl autoscale deploy webapp --min=10 --max=20 --cpu-percent=85

kubectl get hpa

kubectl get pod -l app=webapp

Clean the cluster by deleting deployment and hpa you just created

kubectl delete deploy webapp

kubectl delete hpa webapp

Create a Job with an image node which prints node version and also verifies there is a pod created for this job

kubectl create job nodeversion --image=node -- node -v

kubectl get job -w
kubectl get pod

Get the logs of the job just created

kubectl logs  // created from the job

Output the yaml file for the Job with the image busybox which echos “Hello I am from job”

kubectl create job hello-job --image=busybox --dry-run -o yaml -- echo "Hello I am from job"

Copy the above YAML file to hello-job.yaml file and create the job

kubectl create job hello-job --image=busybox --dry-run -o yaml -- echo "Hello I am from job" &gt; hello-job.yaml

kubectl create -f hello-job.yaml

Verify the job and the associated pod is created and check the logs as well

kubectl get job
kubectl get po

kubectl logs hello-job-*

Delete the job we just created

kubectl delete job hello-job

Create the same job and make it run 10 times one after one

kubectl create job hello-job --image=busybox --dry-run -o yaml -- echo "Hello I am from job" &gt; hello-job.yaml

// edit the yaml file to add completions: 10

apiVersion: batch/v1
kind: Job
metadata:
  creationTimestamp: null
  name: hello-job
spec:
  completions: 10
  template:
    metadata:
      creationTimestamp: null
    spec:
      containers:
      - command:
        - echo
        - Hello I am from job
        image: busybox
        name: hello-job
        resources: {}
      restartPolicy: Never
status: {}

kubectl create -f hello-job.yaml

Watch the job that runs 10 times one by one and verify 10 pods are created and delete those after it’s completed

kubectl get job -w
kubectl get po

kubectl delete job hello-job

Create the same job and make it run 10 times parallel

kubectl create job hello-job --image=busybox --dry-run -o yaml -- echo "Hello I am from job" &gt; hello-job.yaml

// edit the yaml file to add parallelism: 10

apiVersion: batch/v1
kind: Job
metadata:
  creationTimestamp: null
  name: hello-job
spec:
  parallelism: 10
  template:
    metadata:
      creationTimestamp: null
    spec:
      containers:
      - command:
        - echo
        - Hello I am from job
        image: busybox
        name: hello-job
        resources: {}
      restartPolicy: Never
status: {}

kubectl create -f hello-job.yaml

Watch the job that runs 10 times parallelly and verify 10 pods are created and delete those after it’s completed

kubectl get job -w
kubectl get po

kubectl delete job hello-job

Create a Cronjob with busybox image that prints date and hello from kubernetes cluster message for every minute

kubectl create cronjob date-job --image=busybox --schedule="*/1 * * * *" -- bin/sh -c "date; echo Hello from kubernetes cluster"

Output the YAML file of the above cronjob

kubectl get cj date-job -o yaml

Verify that CronJob creating a separate job and pods for every minute to run and verify the logs of the pod

kubectl get job
kubectl get po

kubectl logs date-job--

Delete the CronJob and verify all the associated jobs and pods are also deleted

kubectl delete cj date-job

// verify pods and jobs
kubectl get po
kubectl get job

CKAD Exam Practice Exercise : Multi Container Pods

Vijay Daswani — Sun, 07 Jun 2020 13:02:22 +0000

Multi-Container Pods (10%)

Practice questions based on these concepts

Understand Multi-container pod design patterns (eg: ambassador, adaptor, sidecar)

Questions

Create a Pod with three busy box containers with commands “ls; sleep 3600;”, “echo Hello World; sleep 3600;” and “echo this is the third container; sleep 3600” respectively and check the status

// first create single container pod with dry run flag
kubectl run busybox --image=busybox --restart=Never --dry-run -o yaml -- bin/sh -c "sleep 3600; ls" &gt; multi-container.yaml

// edit the pod like below

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: busybox
  name: busybox
spec:
  containers:
  - args:
    - bin/sh
    - -c
    - ls; sleep 3600
    image: busybox
    name: busybox1
    resources: {}
  - args:
    - bin/sh
    - -c
    - echo Hello world; sleep 3600
    image: busybox
    name: busybox2
    resources: {}
  - args:
    - bin/sh
    - -c
    - echo this is third container; sleep 3600
    image: busybox
    name: busybox3
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

// create it
kubectl create -f multi-container.yaml

kubectl get po busybox

Check the logs of each container that you just created

kubectl logs busybox -c busybox1
kubectl logs busybox -c busybox2
kubectl logs busybox -c busybox3

Check the previous logs of the second container busybox2 if any

kubectl logs busybox -c busybox2 --previous

Run command ls in the third container busybox3 of the above pod

kubectl exec busybox -c busybox3 -- ls

Show metrics of the above pod containers and puts them into the file.log and verify

kubectl top pod busybox --containers

// putting them into file
kubectl top pod busybox --containers &gt; file.log
cat file.log

Create a Pod with main container busybox and which executes this “while true; do echo ‘Hi I am from Main container’ >> /var/log/index.html; sleep 5; done” and with sidecar container with nginx image which exposes on port 80. Use emptyDir Volume and mount this volume on path /var/log for busybox and on path /usr/share/nginx/html for nginx container. Verify both containers are running.

// create an initial yaml file with this
kubectl run multi-cont-pod --image=busbox --restart=Never --dry-run -o yaml &gt; multi-container.yaml

// edit the yml as below and create it
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: multi-cont-pod
  name: multi-cont-pod
spec:
  volumes:
  - name: var-logs
    emptyDir: {}
  containers:
  - image: busybox
    command: ["/bin/sh"]
    args: ["-c", "while true; do echo 'Hi I am from Main container' &gt;&gt; /var/log/index.html; sleep 5;done"]
    name: main-container
    resources: {}
    volumeMounts:
    - name: var-logs
      mountPath: /var/log
  - image: nginx
    name: sidecar-container
    resources: {}
    ports:
      - containerPort: 80
    volumeMounts:
    - name: var-logs
      mountPath: /usr/share/nginx/html
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

kubectl create -f multi-container.yaml

kubectl get po multi-cont-pod

Exec into both containers and verify that main.txt exist and query the main.txt from sidecar container with curl localhost

// exec into main container
kubectl exec -it  multi-cont-pod -c main-container -- sh
cat /var/log/main.txt

// exec into sidecar container
kubectl exec -it  multi-cont-pod -c sidecar-container -- sh
cat /usr/share/nginx/html/index.html

// install curl and get default page
kubectl exec -it  multi-cont-pod -c sidecar-container -- sh
# apt-get update &amp;&amp; apt-get install -y curl
# curl localhost

CKAD Exam Practice Exercise : Core Concepts

Vijay Daswani — Sun, 07 Jun 2020 12:40:02 +0000

Core Concepts (13%)

Practice questions based on these concepts

Understand Kubernetes API Primitives
Create and Configure Basic Pods

Exercise

List all the namespaces in the cluster


kubectl get namespaces

kubectl get ns

List all the pods in all namespaces

kubectl get po --all-namespaces

List all the pods in the particular namespace

kubectl get po -n <namespace name>

List all the services in the particular namespace

kubectl get svc -n <namespace name>

List all the pods showing name and namespace with a json path expression

kubectl get pods -o=jsonpath="{.items[*]['metadata.name', 'metadata.namespace']}"

Create an rabbitmq pod in a default namespace and verify the pod running

// creating a pod
kubectl run rabbitmq --image=rabbitmq --restart=Never

// List the pod
kubectl get po

Create the nginx pod with a yaml file

// get the yaml file with --dry-run flag
kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx-pod.yaml

// cat nginx-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

// create a pod 
kubectl create -f nginx-pod.yaml

Output the yaml file of the pod you just created

kubectl get po nginx -o yaml

Output the yaml file of the pod you just created without the cluster-specific information

kubectl get po nginx -o yaml --export

Get the complete details of the pod you just created

kubectl describe pod nginx

Delete the pod you just created

kubectl delete po nginx

kubectl delete -f nginx-pod.yaml

Delete the pod you just created without any delay (force delete)

kubectl delete po nginx --grace-period=0 --force

Create the nginx pod with version 1.17.4 and expose it on port 80

kubectl run nginx --image=nginx:1.17.4 --restart=Never --port=80

Change the Image version to 1.15-alpine for the pod you just created and verify the image version is updated

kubectl set image pod/nginx nginx=nginx:1.15-alpine

kubectl describe po nginx

// another way it will open vi editor and change the version
kubeclt edit po nginx

kubectl describe po nginx

Change the Image version back to 1.17.1 for the pod you just updated and observe the changes

kubectl set image pod/nginx nginx=nginx:1.17.1

kubectl describe po nginx

kubectl get po nginx -w # watch it

Check the Image version without the describe command

kubectl get po nginx -o jsonpath='{.spec.containers[].image}{"\n"}'

Create the nginx pod and execute the simple shell on the pod

// creating a pod
kubectl run nginx --image=nginx --restart=Never

// exec into the pod
kubectl exec -it nginx /bin/sh

Get the IP Address of the pod you just created

kubectl get po nginx -o wide

Create a busybox pod and run command ls while creating it and check the logs

kubectl run busybox --image=busybox --restart=Never -- ls

kubectl logs busybox

If pod crashed check the previous logs of the pod

kubectl logs busybox -p

Create a busybox pod with command sleep 3600

kubectl run busybox --image=busybox --restart=Never -- /bin/sh -c "sleep 3600"

Check the connection of the nginx pod from the busybox pod

kubectl get po nginx -o wide

// check the connection
kubectl exec -it busybox -- wget -o- <IP Address>

Create a busybox pod and echo message ‘How are you’ and delete it manually

kubectl run busybox --image=nginx --restart=Never -it -- echo "How are you"

kubectl delete po busybox

Create a busybox pod and echo message ‘How are you’ and have it deleted immediately

// notice the --rm flag
kubectl run busybox --image=nginx --restart=Never -it --rm -- echo "How are you"

Create an nginx pod and list the pod with different levels of verbosity

// create a pod
kubectl run nginx --image=nginx --restart=Never --port=80

// List the pod with different verbosity
kubectl get po nginx --v=7
kubectl get po nginx --v=8
kubectl get po nginx --v=9

List the nginx pod with custom columns POD_NAME and POD_STATUS

kubectl get po -o=custom-columns="POD_NAME:.metadata.name, POD_STATUS:.status.containerStatuses[].state"

List all the pods sorted by name

kubectl get pods --sort-by=.metadata.name

List all the pods sorted by created timestamp

kubectl get pods--sort-by=.metadata.creationTimestamp

Multi Container Pod Section based exercise to be continued in the next post.

CKAD Exam : Practice Exercise

Vijay Daswani — Sat, 06 Jun 2020 20:12:03 +0000

Lot of people asked, how i prepared for CKAD. I'd like to share with you my experience.

A set of exercises that helped me prepare for the Certified Kubernetes Application Developer exam, offered by the Cloud Native Computing Foundation, organized by curriculum domain. They may as well serve as learning and practicing with Kubernetes.

During the exam, you are allowed to keep only one other browser tab open to refer official documentation. Make a mental note of the breadcrumb at the start of the excercise section, to quickly locate the relevant document in kubernetes.io. It is recommended that you read official documents before attempting exercises below it.

CKAD is a performance-based exam and it’s all about completing 19 questions within 2 hours. No matter how much you know kubernetes, but time is important in this exam the more you practice the more comfortable you feel during the exam. Practice. Practice. Practice.
I can’t stress this enough because the more you practice, the faster you will be in the exam. It’s all about how fast you could complete each question with the right answer. It wouldn’t be possible without practice.

Course sections.

Core Concepts - 13%
Multi-container pods - 10%
Pod design - 20%
Configuration - 18%
Observability - 18%
Services and networking - 13%
State persistence - 8%

Section based exercise to be continued in the series of posts.