Get 100% Authentic Linux Foundation CKA Dumps with Correct Answers [Q30-Q50]

admin • March 9, 2025

Get 100% Authentic Linux Foundation CKA Dumps with Correct Answers [Q30-Q50]

Rate this post

Get 100% Authentic Linux Foundation CKA Dumps with Correct Answers

New Training Course CKA Tutorial Preparation Guide

QUESTION 30
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.

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

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

QUESTION 31
Your organization uses a private DNS server for internal services and requires all Kubernetes pods to resolve names against this DNS server. You need to configure CoreDNS to forward all DNS requests to this private server.

See the solution below with Step by Step Explanation.
Explanation:
Solution (Step by Step) :
1 . Configure CoreDNS with Forwarding:
– In the CoreDNS ConfigMap, configure the ‘forward’ plugin to forward all DNS requests to your private DNS server.

2. Test DNS Resolution: – Use the ‘nslookup’ command from a pod in your cluster to test DNS resolution for internal services. – The requests should be forwarded to the private DNS server, and the corresponding records should be returned.

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

kubectl get events –sort-by=.metadata.creationTimestamp
kubectl get events –sort-by=.metadata.creationTimestamp >
test-file.log
cat test-file.log

kubectl get events –sort-by=.metadata.creationTimestamp
// putting them into file.log
kubectl get events –sort-by=.metadata.creationTimestamp >
cat test-file.log

kubectl get events –sort-by=.metadata.creationTimestamp
// putting them into file.log
kubectl get events –sort-by=.metadata.creationTimestamp >
test-file.log
cat test-file.log

QUESTION 33
You are running a stateful application using a StatefulSet. How do you ensure that the application data is preserved during a rolling update?

See the solution below with Step by Step Explanation.
Explanation:
Solution (Step by Step) :
1. Use Persistent Volumes:
– Use Persistent Volumes (PVs) and Persistent Volume Claims (PVCs) to provide persistent storage for the stateful application data.
– Ensure that the PVCs are mounted to the pods in the StatefulSet.

2. Configure Rolling Updates: – Configure the StatefulSet’s updateStrategy’ to use a rolling update strategy. – Ensure that the ‘updateStrategy.type’ is set to ‘RollingUpdate’. 3. Validate Data Preservation: – Perform a rolling update by updating the StatefulSet. – Validate that the application data is preserved during the update process. – Check the logs and application state to confirm that the data is intact.

QUESTION 34
Create a pod as follows:
Name: non-persistent-redis
container Image: redis
Volume with name: cache-control
Mount path: /data/redis
The pod should launch in the staging namespace and the volume must not be persistent.

solution

QUESTION 35
Score: 7%

Task
Create a new nginx Ingress resource as follows:
* Name: ping
* Namespace: ing-internal
* Exposing service hi on path /hi using service port 5678

See the solution below.
Explanation
Solution:
vi ingress.yaml
#
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: ping
namespace: ing-internal
spec:
rules:
– http:
paths:
– path: /hi
pathType: Prefix
backend:
service:
name: hi
port:
number: 5678
#
kubectl create -f ingress.yaml

QUESTION 36
You have a pod that uses a PersistentVolumeClaim for its storage. The pod is deleted, but the data on the volume is still present. Explain why the data is not deleted and how you can change this behavior.

See the solution below with Step by Step Explanation.
Explanation:
Solution (Step by Step) :
When a pod is deleted, the data on the volume is not automatically deleted by default. This is because the persistentVolumeReclaimPolicy’ for the PersistentVolume is set to ‘Retain’ by default. This policy ensures that the volume is not deleted when the pod is deleted, preserving the data.
To delete the data when the pod is deleted, you need to modify the persistentVolumeReclaimPolicy’ to ‘Delete’. Here’s how:
1. Update the PersistentVolume:
– Update the ‘persistentVolumeReclaimPolicy’ to ‘Delete’ in the PersistentVolume definition.

2. Apply the Changes: – Apply the updated PersistentVolume definition using ‘kubectl apply -f my-pv.yaml’. Now, when the pod using this PersistentVolume is deleted, the volume and the data will also be deleted automatically.

QUESTION 37
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.

See the solution below.
Explanation
solution

QUESTION 38
You have a Deployment named ‘web-app’ running 3 replicas of a web server. You need to define a PodDisruptionBudget (PDB) that ensures at least 2 replicas of the ‘web-app’ are always available during a planned or unplanned disruption. Write the YAML definition for the PDB and explain how it helps to ensure availability.

See the solution below with Step by Step Explanation.
Explanation:
Solution (Step by Step) :
1. PDB YAML Definition:

2. Explanation: – ‘apiVersion: policy/vl Specifies the API version for the PodDisruptionBudget resource. – ‘kind: PodDisruptionBudget’: Specifies the type of resource, which is a PodDisruptionBudget. – ‘metadata.name: web-app-pdb’: Sets the name of the PDB. – ‘spec.selector.matchLabels: app: web-app’: This selector targets the Pods labeled with ‘app: web-app’ , ensuring the PDB applies to the ‘web-app’ Deployment’s Pods. – ‘spec.minAvailable: 2: Specifies the minimum number of Pods (replicas) that must remain available during a disruption. In this case, at least 2 replicas of ‘web-app’ must be running. 3. How it ensures availability: – Planned Disruptions: If you need to perform a maintenance operation that requires taking down a Pod, the Kubernetes scheduler will not allow it if doing so would violate the PDB. For example, if you try to delete a Pod belonging to ‘web-app’ , the scheduler will prevent it because deleting it would reduce the available replicas below the ‘minAvailable’ threshold. – Unplanned Disruptions: In case of node failures, the PDB helps to protect the application by ensuring that the minimum required number of Pods remain running on other healthy nodes. 4. Implementation: – Apply the YAML using ‘kubectl apply -f web-app-pdb.yamr 5. Verification: You can verify the PDB’s effectiveness by trying to delete Pods or simulate a node failure. You should observe that the scheduler prevents actions that would violate the ‘minAvailable’ constraint.

QUESTION 39
An administrator accidentally closed the commit window/screen before the commit was finished. Which two options could the administrator use to verify the progress or success of that commit task? (Choose two)

System Logs

Configuration Logs

Task Manager

Traffic Logs

QUESTION 40
Create a pod as follows:
Name: mongo
Using Image: mongo
In a new Kubernetes namespace named: my-website

See the solution below.
Explanation
solution
F:\Work\Data Entry Work\Data Entry\20200827\CKA\9 B.JPG

QUESTION 41
Get list of PVs and order by size and write to file – /opt/pvlist.txt

kubectl get pv –sort-by=.spec.capacity.storage > /opt/pvlist.txt

QUESTION 42
An Administrator is configuring Authentication Enforcement and they would like to create an exemption rule to exempt a specific group from authentication. Which authentication enforcement object should they select?

default-web-form

default-no-captive-port

default-browser-challenge

default-authentication-bypass

QUESTION 43
You need to set up a load balancer for your Nginx service with the following requirements:
– Session affinity: Preserve client sessions across multiple pods, even if the pod is restarted or rescheduled.
– Health checks: Regularly check the health of Nginx pods and automatically remove unhealthy pods from the load balancer pool.
– Custom header: Add a custom header with the name “X-App-Version” and value “vl .0” to all requests to your Nginx service. How would you configure your Kubernetes resources to meet these requirements?

See the solution below with Step by Step Explanation.
Explanation:
Solution (Step by Step) :
1. Define the Service:
– Create a Service of type “LoadBalancer” for your Nginx service.
– Include the sessionAffinity’ field with a value of ‘ClientlP’ to enable client IP-based session affinity.
– Example:

2. Configure the Deployment: – In your Nginx Deployment, define a liveness probe and readiness probe to check the health of your Nginx containers. – Example:

3. Implement the Custom Header: – Configure an Ingress resource with the nginx.ingress.kubernetes.io/add-request-headeo annotation. – Example:

4. Apply the Configurations: – Apply the updated Service, Deployment, and Ingress resources using ‘kubectl apply -f service.yaml -f deployment.yaml -f ingress.yamr. 5. Verify the Load Balancer: – Access the Nginx service using the external IP address provided by the LoadBalancer. – Verify session affinity by making multiple requests and observing that they are consistently routed to the same pod. – Check the “X-App-Version” header in the responses to confirm that it is set to “vl .0”.

QUESTION 44
Get the pods with label env=dev and output the labels

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

QUESTION 45
Create a pod with image nginx called nginx and allow traffic on port 80

kubectl run nginx –image=nginx –restart=Never –port=80

QUESTION 46
You have two Kubernetes clusters, ‘cluster 1’ and ‘cluster2, and you need to establish a connection between the two clusters using a NetworkPolicy. You want to allow all traffic from pods in ‘cluster 1’ to pods in ‘cluster? , and you need to implement this using an Ingress rule. What steps are required to configure this connection?

See the solution below with Step by Step Explanation.
Explanation:
Solution (Step by Step) :
1 . Create a NetworkPolicy in ‘cluster?
– Create a NetworkPolicy in ‘cluster? that allows all traffic from pods in ‘cluster 1’
– Code:

2. Create an Ingress in ‘cluster2: – Create an Ingress in ‘cluster? that routes traffic from ‘clusterl’ to the appropriate services or pods in cluster?. – Code:

3. Apply the Configurations: – Apply the NetworkPolicy and Ingress resources to the respective clusters using ‘kubectl apply -f networkpolicy.yaml’ and ‘kubectl apply -f ingress.yaml’.

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

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

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

QUESTION 48
You have a Deployment named running three replicas of a WordPress container. The WordPress application is experiencing intermittent errors, and you need to investigate the cause. You suspect that the errors might be related to issues with the logs generated by the WordPress container. How can you efficiently capture and analyze the ‘stdout’ and ‘stderr’ logs from all three pods in the ‘wordpress-deployment’ to pinpoint the root cause of the errors?

See the solution below with Step by Step Explanation.
Explanation:
Solution (Step by Step) :
1 . Use ‘kubectl logs’ to access the container logs:
– Run the following command to retrieve the logs from all pods in the deployment:
kubectl logs -l app=wordpress -f
– This command retrieves the logs from all pods that have the label , which is the label selecto for your deployment. The flag enables continuous log streaming, allowing you to see new log messages in real-time.
2. Use ‘kubectl logs -p’ for more specific pod logs:
– If you want to examine logs from a specific pod, you can provide the pod name. For example, to get the logs from the pod named ‘wordpress-deployment-795d7f7449-2c4d7’:
kubectl logs wordpress-deployment-795d7f7449-2c4d7 -p -f
– The ‘-p’ flag ensures that you are fetching logs from the previous container instance of the pod, which is helpful if the current container instance is not showing any relevant errors.
3. Utilize ‘kubectl logs –since’ for time-based log retrieval:
– If you need to analyze logs from a specific time period, use the ‘–since’ flag. For example:
kubectl logs -l app=wordpress –since=15m -f
– This command retrieves logs from the past 15 minutes from all pods with the label ‘app=wordpress’. You can adjust the time duration as needed.
4. Use ‘kubectl logs –tail’ to view the last few lines:
– To focus on the most recent log entries, you can use the ‘–tail’ flag:
kubectl logs -l app=wordpress –tail=100 -f
– This command retrieves the last 100 lines of logs from all pods with the label ‘app=wordpress’.
5. Analyze the logs:
– Once you have retrieved the logs, examine them carefully for any error messages, warning signs, or unusual activity that might indicate the source of the errors. Look for patterns, recurring errors, or timestamps that correlate with the observed issues.
6. Further investigation:
– Based on the analysis of the logs, you can take further actions to troubleshoot the problem. This might include:
– Inspecting the WordPress application logs: If the logs indicate problems within the application itself, you need to delve into the WordPress logs to get more specific insights.
– Checking the container image: If the logs point to issues with the container image, you might need to rebuild or update the image.
– Examining the Kubernetes environment: If the logs suggest problems related to Kubernetes resources, you might need to adjust configuration files, investigate other components, or troubleshoot any network issues.
7. Use tools for log analysis:
– For large volumes of logs or complex log patterns, consider using log analysis tools such as ‘grep’ , ‘ awe , ‘sed’ , or specialized log analysis tools that offer advanced features like filtering, aggregation, and visualization. These tools can help you extract relevant information and identify trends more effectively.
By following these steps, you can effectively capture and analyze the ‘stdout’ and ‘stderr’ logs from the WordPress ods enablin ou to identi the root cause of the intermittent errors and resolve the issue.

QUESTION 49
Print all pod name and all image name and write it to a file
name “/opt/pod-details.txt”

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

QUESTION 50
Create a busybox pod and add “sleep 3600” command

kubectl run busybox –image=busybox –restart=Never — /bin/sh -c “sleep 3600”

Loading …

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.

Dumps of CKA Cover all the requirements of the Real Exam: https://www.2pass4sure.com/Kubernetes-Administrator/CKA-actual-exam-braindumps.html