Free Certified Kubernetes Administrator (CKA) Practice Exam Questions

test2022-02-22T03:55:13+00:00

Want to be a Certified Kubernetes Administrator? Certified Kubernetes Administrator (CKA) certification is designed to ensure that certification holders have the skills, knowledge, and competency to perform the responsibilities of Kubernetes Administrators. FreeTestShare assists you in improving your exam preparation by providing you with the most accurate and likely CKA Practice Exam Questions. If you prepare using CKA questions and answers, you will pass on the first try.

Now it is a great time to take a free CKA practice test to see how well you know yourself!

Page 1 of 4

1. Create a busybox pod and add "sleep 3600" command

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

2. Create a pod with init container which waits for a service called "myservice" to be created. Once init container completes, the myapp-container should start and print a message "The app is running" and sleep for 3600 seconds.

Solution: vim multi-container-pod.yaml apiVersion: v1 kind: Pod metadata: name: myapp-pod labels: app: myapp spec: containers: - name: myapp-container image: busybox:1.28 command: ['sh', '-c', 'echo The app is running! && sleep 3600'] initContainers: - name: init-myservice image: busybox:1.28 command: ['sh', '-c', "until nslookup myservice.$(cat /var/run/secrets/kubernetes.io/serviceaccount/namespace).s vc.cluster.local; do echo waiting for myservice; sleep 2; done"] // Check whether service called "myservice" exists kubectl get svc Note: Pod will not start if service called "myservice" doesn't exist. // Now, Create the pod kubectl apply -f multi-container-pod.yaml

3. 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.

Solution: // create an initial yaml file with this kubectl run multi-cont-pod --image=busbox --restart=Never -- dry-run -o yaml > multi-container.yaml // edit the yml as below and create it kubectl create -f multi-container.yaml vim multi-container.yaml apiVersion: v1 kind: Pod metadata: 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' >> /var/log/index.html; sleep 5;done"] name: main-container volumeMounts: - name: var-logs mountPath: /var/log - image: nginx name: sidecar-container ports: - containerPort: 80 volumeMounts: - name: var-logs mountPath: /usr/share/nginx/html restartPolicy: Never // Create Pod kubectl apply -f multi-container.yaml //Verify kubectl get pods

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

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

5. Create the deployment redis with image=redis and expose it with "NodePort" service redis-service

Solution: kubectl create deploy redis --image=redis --dry-run -o yaml > redis-deploy.yaml Edit redis-deploy.yaml file vim redis-deploy.yaml apiVersion: apps/v1 kind: Deployment metadata: labels: app: redis name: redis spec: replicas: 1 selector: matchLabels: app: redis template: metadata: labels: app: redis spec: containers: - image: redis name: redis //Creating Service kubectl expose deploy redis --type=NodePort --port=6379 -- target-port=6379 --name redis-service // Verify kubectl get deploy,svc

6. List the nginx pod with custom columns POD_NAME and POD_STATUS

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

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

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

8. 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 > nginx.yml

// add env section below and create

vim nginx.yaml

apiVersion: v1

kind: Pod

metadata:

labels:

run: nginx

name: nginx

spec:

containers:

- image: nginx

name: nginx

envFrom:

- secretRef:

name: my-secret

restartPolicy: Never

kubectl apply -f nginx.yaml

//verify

kubectl exec -it nginx env

Solution: // create a yml file kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx.yml // add env section below and create vim nginx.yaml run: nginx name: nginx spec: containers: - image: nginx name: nginx envFrom: - secretRef: name: my-secret restartPolicy: Never kubectl apply -f nginx.yaml //verify kubectl exec -it nginx env

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

Solution: kubectl run nginx-request --image=nginx --restart=Always --dryrun -o yaml > nginx-request.yml // add the resources section and create apiVersion: v1 kind: Pod metadata: labels: run: nginx name: nginx-request spec: containers: - image: nginx name: nginx resources: requests: memory: "100Mi" cpu: "0.5" limits: memory: "200Mi" cpu: "1" restartPolicy: Always k kubectl apply -f nginx-request.yaml // Verify Kubectl top po

10. Create a redis pod, and have it use a non-persistent storage (volume that lasts for the lifetime of the Pod)

Solution: vim redis-pod-vol.yaml apiVersion: v1 kind: Pod metadata: name: redis spec: containers: - name: redis image: redis ports: - containerPort: 6379 volumeMounts: - mountPath: /data name: redis-storage volumes: - name: redis-storage emptyDir: {} kubectl apply -f redis-pod-vol.yaml

Page 2 of 4

11. Check logs of each container that "busyboxpod-{1,2,3}"

Solution: kubectl logs busybox -c busybox-container-1 kubectl logs busybox -c busybox-container-2 kubectl logs busybox -c busybox-container-3

12. Remove taint added to node "worker-2"

Solution: kubectl taint nodes worker-2 key:NoSchedule- // Verify You will see a message "node/worker-2 untainted" kubectl get nodes -o customcolumns=NAME: .metadata.name,TAINTS:.spec.taints --no-headers

13. 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

Solution: // first create single container pod with dry run flag kubectl run busybox --image=busybox --restart=Always --dry-run -o yaml -- bin/sh -c "sleep 3600; ls" > multi-container.yaml // edit the pod to following yaml and create it apiVersion: v1 kind: Pod metadata: labels: run: busybox name: busybox spec: containers: - args: - bin/sh - -c - ls; sleep 3600 image: busybox name: busybox-container-1 - args: - bin/sh - -c - echo Hello world; sleep 3600 image: busybox name: busybox-container-2 - args: - bin/sh - -c - echo this is third container; sleep 3600 image: busybox name: busybox-container-3 restartPolicy: Always // Verify Kubectl get pods

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

Solution: Kubect1 set image pod/nginx nginx=nginx:1.15-alpine kubect1 describe po nginx // another way it will open vi editor and change the version kubeclt edit po nginx kubect1 describe po nginx

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

Solution: vim nginx-pvc-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" volumeMounts: - mountPath: "/usr/share/nginx/html" name: task-pv-storage kubectl apply -f nginx-pvc-pod.yaml // Verify kubectl describe po "POD-Name" | grep -i volumes -A5 Volumes: task-pv-storage: Type: PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace) ClaimName: task-pv-claim ReadOnly: false

16. Check the Image version of nginx-dev pod using jsonpath

Solution: kubect1 get po nginx-dev -o jsonpath='{.spec.containers[].image}{"
"}'

17. 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.

Solution: kubectl run nginx --image=nginx --restart=Always --port=80 -- dry-run -o yaml > nginx-pod.yaml // add the livenessProbe section and create apiVersion: v1 kind: Pod metadata: labels: run: nginx name: nginx spec: containers: - image: nginx name: nginx ports: - containerPort: 80 livenessProbe: httpGet: path: /healthz port: 80 restartPolicy: Always kubectl create -f nginx-pod.yaml // verify kubectl describe pod nginx | grep -i readiness kubectl delete po nginx

18. Check the history of the specific revision of that deployment

Solution: kubectl rollout history deploy webapp --revision=3

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

Solution: kubectl set image deploy/webapp nginx=nginx:1.16.1 kubectl describe deploy webapp | grep Image kubectl rollout history deploy webapp

20. Get list of all the pods showing name and namespace with a jsonpath expression.

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

Page 3 of 4

21. Create a redis pod and mount "redis-config" as "redis.conf" inside redis container, name the config volume as "redis-volume" redis-config path - /opt/redis-config

Pending

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

Solution: kubectl create secret generic my-secret --fromliteral=username=user --from- literal=password=mypassword // Verify kubectl get secret --all-namespaces kubectl get secret generic my-secret -o yaml

23. Create a deployment called webapp with image nginx having 5 replicas in it, put the file in /tmp directory with named webapp.yaml

Solution: //Create a file using dry run command kubectl create deploy --image=nginx --dry-run -o yaml > /tmp/webapp.yaml // Now, edit file webapp.yaml and update replicas=5 apiVersion: apps/v1 kind: Deployment metadata: labels: app: webapp name: webapp spec: replicas: 5 selector: matchLabels: app: webapp template: metadata: labels: app: webapp spec: containers: - image: nginx name: nginx Note: Search "deployment" in kubernetes.io site , you will get the page https://kubernetes.io/docs/concepts/workloads/controllers/deplo yment/ // Verify the Deployment kubectl get deploy webapp --show-labels // Output the YAML file of the deployment webapp kubectl get deploy webapp -o yaml

24. Resume the rollout of the deployment

Solution: kubectl rollout resume deploy webapp

25. List all the pods sorted by created timestamp

Solution: kubect1 get pods--sort-by=.metadata.creationTimestamp

26. Exec into both containers and verify that main.txt exist and

Solution: NEED TO WRITE ANSWER FOR THIS

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

Solution: // create a yml file kubectl run nginx-pod --image=nginx --restart=Never --dry-run - o yaml > nginx-pod.yml // add the resources section and create vim nginx-pod.yaml apiVersion: v1 kind: Pod metadata: labels: run: nginx name: nginx spec: containers: - image: nginx name: nginx resources: requests: cpu: "0.5" limits: cpu: "1" restartPolicy: Always kubectl apply -f nginx-pod.yaml // verify

28. 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

Solution: kubectl autoscale deploy webapp --min=10 --max=20 --cpu percent=85 kubectl get hpa kubectl get pod -l app=webapp

29. List all the pods that are serviced by the service "webservice" and copy the output in /opt/$USER/webservice.targets

Note: You need to list the endpoints

Solution: kubectl descrive svc webservice | grep -i "Endpoints" > /opt/$USER/webservice.targets kubectl get endpoints webservice > /opt/$USER/webservice.targets

30. Create a nginx pod that will be deployed to node with the label "gpu=true"

Solution: kubectl run nginx --image=nginx --restart=Always --dry-run -o yaml > nodeselector-pod.yaml // add the nodeSelector like below and create the pod kubectl apply -f nodeselector-pod.yaml vim nodeselector-pod.yaml apiVersion: v1 kind: Pod metadata: name: nginx spec: nodeSelector: gpu: true containers: - image: nginx name: nginx restartPolicy: Always kubectl apply -f nodeselector-pod.yaml //Verify kubectl get no show- labels kubectl get po kubectl describe po nginx | grep Node-Selectors

Page 4 of 4

31. Create an nginx pod and set an env value as 'var1=val1'. Check the env value existence within the pod

Solution: kubectl run nginx --image=nginx --restart=Never --env=var1=val1 # then kubectl exec -it nginx -- env # or kubectl exec -it nginx -- sh -c 'echo $var1' # or kubectl describe po nginx | grep val1 # or kubectl run nginx --restart=Never --image=nginx --env=var1=val1 -it --rm - env