Oct-2025 Pass Your CKA Exam at the First Try with 100% Real Exam [Q31-Q55]

NO.31 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.

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

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

NO.32 Set the node named ek8s-node-1 as unavailable and reschedule all the pods running on it.

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

NO.34 You are running a Kubernetes cluster with a NodePort service exposing a web application on port 80. You want to access the web application from a client machine outside the cluster. However, the client machine is behind a NAT gateway and you cannot directly configure firewall rules on the gateway. How can you configure the Kubernetes cluster to allow the client machine to access the web application?

NO.35 You have a ‘NodePort’ service named ‘my-service’ exposed on port 30000. You need to configure a NetworkPolicy to only allow access to the service from specific nodes in the cluster based on their node labels.

NO.36 Updates to dynamic user group membership are automatic therefore using dynamic user groups instead of static group objects allows you to:

respond to changes in user behavior or potential threats using manual policy changes

respond to changes in user behavior and confirmed threats with manual policy changes

respond to changes in user behavior or potential threats without manual policy changes

respond to changes in user behavior or potential threats without automatic policy changes

NO.37 Resume the rollout of the deployment

NO.38 You have a Deployment running on a Kubernetes cluster with limited resources. How can you adjust the Deployment to use resources more efficiently and prevent resource contention?

NO.39 You are deploying an application on Kubernetes. You need to ensure that a minimum of three pods are always running for this application. How can you achieve this? Describe how to configure the deployment with a replica count and a liveness probe to monitor the health of the pods.

NO.40 One of the nodes in your Kubernetes cluster is experiencing high CPU usage, which is affecting the performance of the entire cluster. The node is running multiple pods, and you need to identify which pod is responsible for the high CPU consumption and take steps to resolve the issue.

NO.41 Monitor the logs of pod foo and:
Extract log lines corresponding to error
unable-to-access-website
Write them to /opt/KULM00201/foo

NO.42 Create a deployment as follows:
* Name:nginx-random
* Exposed via a servicenginx-random
* Ensure that the service & podare accessible via theirrespective DNS records
* The container(s) within anypod(s) running as a part of thisdeployment should use thenginxImage Next, use the utilitynslookupto lookup the DNS records of the service &pod and write the output to
/opt/KUNW00601/service.dnsand/opt/KUNW00601/pod.dnsrespectively.

NO.43 Perform the following tasks:
Add an init container to hungry-bear (which has been defined in spec file /opt/KUCC00108/pod-spec-KUC C00108.yaml ) The init container should create an empty file named /workdir/calm.txt If /workdir/calm.txt is not detected, the pod should exit Once the spec file has been updated with the init container definition, the pod should be created

NO.44 Ensure a single instance of pod nginx is running on each node of the Kubernetes cluster where nginx also represents the Image name which has to be used. Do not override any taints currently in place.
Use DaemonSet to complete this task and use ds-kusc00201 as DaemonSet name.

NO.45 Schedule a pod as follows:
Name: nginx-kusc00101
Image: nginx
Node selector: disk=ssd

NO.46 A Kubernetes worker node, named wk8s-node-0 is in state NotReady. Investigate why this is the case, and perform any appropriate steps to bring the node to a Ready state, ensuring that any changes are made permanent.
You can ssh to the failed node using:
[student@node-1] $ | ssh Wk8s-node-0
You can assume elevated privileges on the node with the following command:
[student@w8ks-node-0] $ | sudo -i

NO.47 You are setting up a new Kubernetes cluster with a highly sensitive application that requires access control at the pod level. Explain how you can use NetworkPolicy to restrict access to pods within your cluster.

NO.48 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 > nginx.yml
// add env section below and create
apiVersion: v1
kind: Pod
metadata:
labels:
run: nginx
name: nginx
spec:
containers:
– image: nginx
name: nginx
env:
– name: USER_NAME
restartPolicy: Never
kubectl create -f nginx.yml
//Verify
kubectl exec -it nginx – env

// create a yml file
kubectl run nginx –image=nginx –restart=Never –dry-run -o
yaml > nginx.yml
// add env section below and create
apiVersion: v1
kind: Pod
metadata:
labels:
run: nginx
name: nginx
spec:
containers:
– image: nginx
name: nginx
env:
– name: USER_NAME
valueFrom:
secretKeyRef:
name: my-secret
key: username
restartPolicy: Never
kubectl create -f nginx.yml
//Verify
kubectl exec -it nginx – env

NO.49 Score: 4%

Task
Check to see how many nodes are ready (not including nodes tainted NoSchedule ) and write the number to
/opt/KUSC00402/kusc00402.txt

NO.50 You are managing a Kubernetes cluster with several namespaces. You need to restrict access to the ‘production’ namespace, ensuring only authorized users can access resources within that namespace. Create a Role and RoleBinding that allows users in the ‘developers’ group to access pods and deployments within the ‘production’ namespace.

NO.51 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

NO.52 // Create a configmap
kubectl create configmap redis-config –from-file=/opt/redisconfig
// Verify
kubectl get configmap redis-config -o yaml
// first run this command to save the pod yml
kubectl run redis-pod –image=redis –restart=Always –dry-run
-o yaml > redis-pod.yml
// edit the yml to below file and create
apiVersion: v1
kind: Pod
metadata:
name: redis
spec:
containers:
– name: redis
image: redis
env:
– name: MASTER
value: “true”
ports:
– containerPort: 6379
volumeMounts:
– mountPath: /redis-master-data
name: data
– mountPath: /redis-master
name: config
volumes:
– name: data
emptyDir: {}
– name: config
configMap:
name: example-redis-config

items:
– key: redis-config
path: redis.conf
cf
kk kubectl apply -f redis-pod.yml
// // Verify
K kubectl exec -it redis – cat /redis-master-data/redis.conf

items:
– key: redis-config
path: redis.conf
cf
// // Verify
K kubectl exec -it redis – cat /redis-master-data/redis.conf

NO.53 Score: 4%

Task
Set the node named ek8s-node-1 as unavailable and reschedule all the pods running on it.

NO.54 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 > 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

// 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:
– 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:
mountPath: /usr/share/nginx/html
restartPolicy: Never
// Create Pod
kubectl apply -f multi-container.yaml
//Verify
kubectl get pods

NO.55 Score: 4%

Task
Create a pod named kucc8 with a single app container for each of the following images running inside (there may be between 1 and 4 images specified): nginx + redis + memcached .

Leave a Reply Cancel reply