Unique Top-selling CKA Exams - New 2025 Linux Foundation Pratice Exam [Q35-Q53]

Unique Top-selling CKA Exams - New 2025 Linux Foundation Pratice Exam

Kubernetes Administrator Dumps CKA Exam for Full Questions - Exam Study Guide

The CKA certification is recognized globally and is highly valued by organizations that use Kubernetes in their production environments. Certified Kubernetes Administrator (CKA) Program Exam certification provides IT professionals with a competitive edge in the job market and opens up new career opportunities. The Linux Foundation offers comprehensive training and preparation materials to help candidates prepare for the CKA certification exam. The training includes hands-on labs, online courses, and study materials that cover all the topics and skills required for the exam.

Linux Foundation CKA (Certified Kubernetes Administrator) Program Certification Exam is a valuable certification for professionals seeking to demonstrate their expertise in managing Kubernetes clusters. Certified Kubernetes Administrator (CKA) Program Exam certification exam tests the candidate's practical skills in deploying and managing Kubernetes clusters effectively. Certified Kubernetes Administrator (CKA) Program Exam certification has become a benchmark for Kubernetes expertise in the industry and provides a competitive edge to the candidate. Passing the CKA certification exam demonstrates the candidate's commitment to keeping up with the latest industry trends and technologies.

The CKA exam is designed to test the knowledge and proficiency of professionals in Kubernetes administration. CKA exam consists of a set of performance-based tasks that assess the candidate's ability to deploy, configure, manage, and troubleshoot Kubernetes clusters. CKA exam is conducted online and requires candidates to complete a set of practical tasks within a specified time frame. CKA exam covers a wide range of Kubernetes administration topics, including cluster architecture, networking, storage, security, and troubleshooting.

NEW QUESTION # 35
Create a persistent volume with nameapp-data, of capacity2Giandaccess modeReadWriteMany. Thetype of volume ishostPathand itslocation is/srv/app-data.

Answer:

Explanation:
See the solution below.
Explanation
solution
Persistent Volume
A persistent volume is a piece of storage in aKubernetes cluster. PersistentVolumes are a cluster-level resource like nodes, which don't belong to any namespace. It is provisioned by the administrator and has a particular file size. This way, a developer deploying their app on Kubernetes need not knowthe underlying infrastructure.
When the developer needs a certain amount of persistent storage for their application, the system administrator configures the cluster so that they consume the PersistentVolume provisioned in an easy way.
Creating PersistentVolume
kind: PersistentVolumeapiVersion: v1metadata:name:app-dataspec:capacity: # defines the capacity of PV we are creatingstorage:2Gi#the amount of storage we are tying to claimaccessModes: # defines the rights of the volumewe are creating-ReadWriteManyhostPath:path: "/srv/app-data" # path to which we are creating the volume Challenge
* Create a Persistent Volume named ReadWriteMany, storage classname
shared,2Giof storage capacity and the host path

2. Save the file and create the persistent volume.
Image for post

3. View the persistent volume.

* Our persistent volume status is available meaning it is available and it has not been mounted yet. This status willchange when we mount the persistentVolume to a persistentVolumeClaim.
PersistentVolumeClaim
In a real ecosystem, a system admin will create the PersistentVolume then a developer will create a PersistentVolumeClaim which will be referenced in a pod. A PersistentVolumeClaim is created by specifying the minimum size and the access mode they require from the persistentVolume.
Challenge
* Create a Persistent Volume Claim that requests the Persistent Volume we had created above. The claim should request 2Gi. Ensurethat the Persistent Volume Claim has the same storageClassName as the persistentVolume you had previously created.
kind: PersistentVolumeapiVersion: v1metadata:name:
spec:
accessModes:-ReadWriteManyresources:
requests:storage:2Gi
storageClassName:shared
2. Save and create the pvc
njerry191@cloudshell:~(extreme-clone-2654111)$ kubect1 create -f app-data.yaml persistentvolumeclaim/app-data created
3. View the pvc
Image for post

4. Let's see what has changed in the pv we had initially created.
Image for post

Our status has now changed fromavailabletobound.
5. Create a new pod named myapp with image nginx that will be used to Mount the Persistent Volume Claim with the path /var/app/config.
Mounting a Claim
apiVersion: v1kind: Podmetadata:creationTimestamp: nullname: app-dataspec:volumes:- name:congigpvcpersistenVolumeClaim:claimName: app-datacontainers:- image: nginxname:
appvolumeMounts:- mountPath: "

NEW QUESTION # 36
Create a pod with init container which create a file "test.txt"
in "workdir" directory. Main container should check a file
"test.txt" exists and execute sleep 9999 if the file exists.

A. // create an initial yaml file with this
kubectl run init-cont-pod --image=alpine --restart=Never --dry-run -o
yaml > init-cont-pod.yaml
// edit the yml as below and create it
vim init-cont-pod.yaml
apiVersion: v1
kind: Pod
metadata:
name: init-cont-pod
labels:
app: myapp
spec:
volumes:
- name: test-volume
emptyDir: {}
containers:
- name: main-container
image: busybox:1.28
command: ['sh', '-c', 'if [ -f /workdir/test.txt ]; then sleep
9999; fi']
volumeMounts:
image: busybox:1.28
command: ['sh', '-c', "mkdir /workdir; echo >
/workdir/test.txt"]
volumeMounts:
- name: test-volume
mountPath: /workdir
// Create the pod
kubectl apply -f init-cont-pod.yaml
kubectl get pods
// Check Events by doing
kubectl describe po init-cont-pod
Init Containers:
init-myservice:
Container ID:
docker://ebdbf5fad1c95111d9b0e0e2e743c2e347c81b8d4eb5abcccdfe1dd74524
0d4f
Image: busybox:1.28
Image ID: dockerpullable://busybox@sha256:141c253bc4c3fd0a201d32dc1f493bcf3fff003b6df
416dea4f41046e0f37d47
Port: <none>
Host Port: <none>
Command:
sh
-c
mkdir /workdir; echo > /workdir/test.txt
State: Terminated Reason: Completed
B. // create an initial yaml file with this
kubectl run init-cont-pod --image=alpine --restart=Never --dry-run -o
yaml > init-cont-pod.yaml
// edit the yml as below and create it
vim init-cont-pod.yaml
apiVersion: v1
kind: Pod
metadata:
name: init-cont-pod
labels:
app: myapp
spec:
volumes:
- name: test-volume
emptyDir: {}
containers:
- name: main-container
image: busybox:1.28
command: ['sh', '-c', 'if [ -f /workdir/test.txt ]; then sleep
9999; fi']
volumeMounts:
- name: test-volume
mountPath: /workdir
initContainers:
- name: init-myservice
image: busybox:1.28
command: ['sh', '-c', "mkdir /workdir; echo >
/workdir/test.txt"]
volumeMounts:
- name: test-volume
mountPath: /workdir
// Create the pod
kubectl apply -f init-cont-pod.yaml
kubectl get pods
// Check Events by doing
kubectl describe po init-cont-pod
Init Containers:
init-myservice:
Container ID:
docker://ebdbf5fad1c95111d9b0e0e2e743c2e347c81b8d4eb5abcccdfe1dd74524
0d4f
Image: busybox:1.28
Image ID: dockerpullable://busybox@sha256:141c253bc4c3fd0a201d32dc1f493bcf3fff003b6df
416dea4f41046e0f37d47
Port: <none>
Host Port: <none>
Command:
sh
-c
mkdir /workdir; echo > /workdir/test.txt
State: Terminated Reason: Completed

Answer: B

NEW QUESTION # 37
You are setting up a Kubernetes cluster and you need to configure a NetworkPolicy to allow all traffic from pods in a specific namespace to other namespaces, but block all traffic from other namespaces to this specific namespace. How can you achieve this using NetworkPolicies?

Answer:

Explanation:
See the solution below with Step by Step Explanation.
Explanation:
Solution (Step by Step) :
1 . Create a NetworkPolicy:
- Create a NetworkPolicy in the specific namespace where you want to restrict incoming traffic.
- Code:

2. Apply the NetworkPolicy: - Apply the NetworkPolicy using 'kubectl apply -f networkpolicy.yaml'

NEW QUESTION # 38
Create a pod with image nginx called nginx and allow traffic on port 80

Answer:

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

NEW QUESTION # 39
Perform the following tasks:
* Add an init container tohungry-bear(which has beendefined in spec file
/opt/KUCC00108/pod-spec-KUCC00108.yaml)
* The init container should createan empty file named/workdir/calm.txt
* If/workdir/calm.txtis notdetected, the pod should exit
* Once the spec file has beenupdatedwith the init containerdefinition, the pod should becreated

Answer:

Explanation:
See the solution below.
Explanation
solution

NEW QUESTION # 40
Your team has deployed a containerized application on Kubernetes. You have configured a deployment with a replica count of 3 pods. The application uses a resource-intensive process that consumes a significant amount of CPU resources. You are experiencing performance issues and suspect that the pods are competing for resources. Explain how you can use resource quotas and limits to address this problem.

Answer:

Explanation:
See the solution below with Step by Step Explanation.
Explanation:
Solution (Step by Step) :
1. Define Resource Limits for Pods:
- Modify the deployment configuration to set resource limits for each pod, specifying the maximum CPU and memory resources they can consume. This prevents pods from exceeding their resource allocations, ensuring fairer resource distribution.

2. Implement Resource Quotas at the Namespace Level: - Define resource quotas for the namespace where your application is running. This limits the overall resource consumption within the namespace, preventing any single pod from monopolizing resources.

3. Monitor Resource Usage and Adjust Limits: - Continuously monitor the resource usage of your pods and the namespace. Analyze the CPU and memory utilization to identify any resource contention. - Adjust resource limits and quotas as needed to fine-tune the resource allocation and improve performance.

NEW QUESTION # 41
Create an nginx pod and list the pod with different levels of verbosity

Answer:

Explanation:
// 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

NEW QUESTION # 42
Create a file:
/opt/KUCC00302/kucc00302.txtthatlists all pods that implement servicebazin namespacedevelopment.
The format of the file should be onepod name per line.

Answer:

Explanation:
See the solution below.
Explanation
solution

NEW QUESTION # 43
Print all pod name and all image name and write it to a file
name "/opt/pod-details.txt"

Answer:

Explanation:
kubectl get pods -o=custom-columns='Pod Name:metadata.name','Image:spec.containers[*].image' > /opt/pod-details.txt

NEW QUESTION # 44
You have a Kubernetes cluster with a variety of namespaces: 'default', 'development', 'production', and 'testing'. You need to implement granular role-based access control (RBAC) to ensure that:
- Developers in the 'development' namespace can only create and delete pods within that namespace.
- Developers in the 'testing' namespace can only create, delete and scale pods within that namespace.
- Production team members in the 'production' namespace can only view pods and deployments.
Provide the necessary YAML files for the Role, RoleBinding, and ServiceAccount objects to enforce these permissions. Ensure that the service accounts are bound to specific namespaces and that the RoleBindings are correctly defined to grant the necessary access to each group.

Answer:

Explanation:
See the solution below with Step by Step Explanation.
Explanation:
Solution (Step by Step) :
1 . Create a ServiceAccount for Developers in the 'development' namespace:

2. Create a ServiceAccount for Developers in the 'testing' namespace:

3. Create a ServiceAccount for Production Team members in the 'production' namespace:

4. Create a Role for Developers in the 'development' namespace:

5. Create a Role for Developers in the 'testing' namespace:

6. Create a Role for Production Team members in the 'production' namespace:

7. Create a RoleBinding for Developers in the 'development' namespace:

8. Create a RoleBinding for Developers in the 'testing' namespace:

9. Create a RoleBinding for Production Team members in the 'production' namespace:

10. Apply the YAML files using 'kubectl apply -f' ,

NEW QUESTION # 45
Monitor the logs of pod foo and:
* Extract log lines corresponding unable-to-access-website
* Write them to/opt/KULM00201/foo

Answer:

Explanation:
See the solution below.
Explanation
solution

NEW QUESTION # 46
Create an nginx pod with container Port 80 and it should only receive traffic only it checks the endpoint / on port 80 and verify and delete the pod.

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

Answer: A

NEW QUESTION # 47
Remove taint added to node "worker-2"

Answer:

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

NEW QUESTION # 48
Score: 7%

Task
Create a new NetworkPolicy named allow-port-from-namespace in the existing namespace echo. Ensure that the new NetworkPolicy allows Pods in namespace my-app to connect to port 9000 of Pods in namespace echo.
Further ensure that the new NetworkPolicy:
* does not allow access to Pods, which don't listen on port 9000
* does not allow access from Pods, which are not in namespace my-app

Answer:

Explanation:
See the solution below.
Explanation
Solution:
#network.yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-port-from-namespace
namespace: internal
spec:
podSelector:
matchLabels: {
}
policyTypes:
- Ingress
ingress:
- from:
- podSelector: {
}
ports:
- protocol: TCP
port: 8080
#spec.podSelector namespace pod
kubectl create -f network.yaml

NEW QUESTION # 49
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

A. // first create a configmap cfgvolume
kubectl create cm cfgvolume --from-literal=var1=val1 --fromliteral=var2=val2
// verify the configmap
kubectl describe cm cfgvolume
// create the config map
kubectl create -f nginx-volume.yml
vim nginx-configmap-pod.yaml
apiVersion: v1
kind: Pod
- name: nginx-volume
configMap:
name: cfgvolume
containers:
- image: nginx
name: nginx
volumeMounts:
- name: nginx-volume
mountPath: /etc/cfg
restartPolicy: Always
k kubectl apply -f nginx-configmap-pod.yaml
/ // Verify
// exec into the pod
kubectl exec -it nginx -- /bin/sh
// check the path
cd /etc/cfg
B. // first create a configmap cfgvolume
kubectl create cm cfgvolume --from-literal=var1=val1 --fromliteral=var2=val2
// verify the configmap
kubectl describe cm cfgvolume
// create the config map
kubectl create -f nginx-volume.yml
vim nginx-configmap-pod.yaml
apiVersion: v1
kind: Pod
metadata:
labels:
run: nginx
name: nginx
spec:
volumes:
- name: nginx-volume
configMap:
name: cfgvolume
containers:
- image: nginx
name: nginx
volumeMounts:
- name: nginx-volume
mountPath: /etc/cfg
restartPolicy: Always
k kubectl apply -f nginx-configmap-pod.yaml
/ // Verify
// exec into the pod
kubectl exec -it nginx -- /bin/sh
// check the path
cd /etc/cfg

Answer: B

NEW QUESTION # 50
Create PersistentVolume named task-pv-volume with storage 10Gi, access modes ReadWriteMany, storageClassName manual, and volume at /mnt/data and Create a PersistentVolumeClaim of at least 3Gi storage and access mode ReadWriteOnce and verify

A. vim task-pv-volume.yaml
apiVersion: v1
kind: PersistentVolume
metadata:
name: task-pv-volume
labels:
type: local
spec:
storageClassName: manual
capacity:
storage: 10Gi
accessModes:
- ReadWriteMany
hostPath:
path: "/mnt/data"
kubectl apply -f task-pv-volume.yaml
//Verify
kubectl get pv
vim task-pvc-volume.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: task-pv-claim
spec:
storageClassName: manual
accessModes:
- ReadWriteMany
resources:
requests:
storage: 3Gi
kubectl apply -f task-pvc-volume.yaml
//Verify
Kuk kubectl get pvc
B. vim task-pv-volume.yaml
apiVersion: v1
kind: PersistentVolume
metadata:
name: task-pv-volume
labels:
type: local
spec:
storageClassName: manual
capacity:
storage: 10Gi
accessModes:
- ReadWriteMany
hostPath:
path: "/mnt/data"
kubectl apply -f task-pv-volume.yaml
//Verify
kubectl get pv
vim task-pvc-volume.yaml
apiVersion: v1
- ReadWriteMany
resources:
requests:
storage: 3Gi
kubectl apply -f task-pvc-volume.yaml
//Verify
Kuk kubectl get pvc

Answer: A

NEW QUESTION # 51
You have a Deployment named 'frontend-deployment' with 5 replicas of a frontend container. You need to implement a rolling update strategy that allows for a maximum of 2 pods to be unavailable at any given time. You also want to ensure that the update process is completed within a specified timeout of 8 minutes. If the update fails to complete within the timeout, the deployment should revert to the previous version. Additionally, you want to configure a 'post-start' hook for the frontend container that executes a health check script to verify the application's readiness before it starts accepting traffic.

Answer:

Explanation:
See the solution below with Step by Step Explanation.
Explanation:
Solution (Step by Step) :
1. Update the Deployment YAML:
- Update the 'replicas' to 5.
- Define 'maxUnavailable: 2' and 'maxSurge: 0' in the 'strategy.rollingUpdate' section to control the rolling update process.
- Configure a 'strategy.type' to 'RollingUpdate' to trigger a rolling update when the deployment is updated.
- Set Always' to ensure that the new image is pulled even if
it exists in the pod's local cache.
- Add a 'spec.progressDeadlineSeconds: 480' to set a timeout of 8 minutes for the update process.
- Add a 'spec.template.spec.containers[0].lifecycle.postStart' hook to define a script that executes a health check script before the container starts accepting traffic.

2. Create the Deployment: - Apply the updated YAML file using 'kubectl apply -f frontend-deployment.yaml' 3. Verify the Deployment: - Check the status of the deployment using 'kubectl get deployments frontend-deployment' to confirm the rollout and updated replica count. 4. Trigger the Automatic Update: - Push a new image to the 'my.org/frontend:latest' Docker Hub repository. 5. Monitor the Deployment: - Use 'kubectl get pods -l app=frontend' to monitor the pod updates during the rolling update process. 6. Observe Rollback if Timeout Exceeds: - If the update process takes longer than 8 minutes to complete, the deployment will be rolled back to the previous version. This can be observed using 'kubectl describe deployment frontend-deployment' and checking the 'updatedReplicas' and 'availableReplicas' fields.,

NEW QUESTION # 52
Create a deployment as follows:
Name: nginx-app
Using container nginx with version 1.11.10-alpine
The deployment should contain 3 replicas
Next, deploy the application with new version 1.11.13-alpine, by performing a rolling update.
Finally, rollback that update to the previous version 1.11.10-alpine.

Answer:

Explanation:
solution