New 2023 Realistic Free Linux Foundation CKA Exam Dump Questions & Answer [Q24-Q48] – IT Certification Exam Questions & Answers

Rate this post

New 2023 Realistic Free Linux Foundation CKA Exam Dump Questions and Answer

CKA Practice Test Engine: Try These 68 Exam Questions

The CKA certification exam is designed to test the knowledge and skills of candidates in various aspects of Kubernetes administration, such as cluster installation and configuration, application deployment and management, networking, security, and troubleshooting. The exam is conducted online and consists of a set of performance-based tasks that require candidates to demonstrate their ability to perform various Kubernetes administration tasks in a time-bound manner.

The Linux Foundation Certified Kubernetes Administrator (CKA) program is a certification designed to test the knowledge and skills of individuals in the field of Kubernetes administration. Kubernetes is one of the most popular container orchestration platforms, and it is widely used by organizations to manage their containerized applications. The CKA program is developed and maintained by the Linux Foundation, which is a non-profit organization that promotes the use of open source technologies.

NO.24 Create a deployment named “myapp” that having 2 replicas with
nginx image and expose deployment as service named “myservice”

// Create a YAML Template
kubectl create deploy myapp –image=nginx –dry-run -o yaml >
myapp.yaml
//Update replicas=2 in myapp.yaml file
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
app: myapp
name: myapp
spec:
replicas: 2
selector:
matchLabels:
app: myapp
template:
metadata:
labels:
app: myapp
spec:
containers:
– image: nginx
name: nginx
// Create deployment
kubectl create -f myapp.yaml
// Creating YAML template for service
kubectl expose deployment myapp –type=ClusterIP –port=80 —
target-port=80 –name=myservice –dry-run -o yaml >
myservice.yaml
YAML File:
apiVersion: v1
kind: Service
metadata:
labels:
app: myapp
name: myservice
spec:
ports:
– port: 80
protocol: TCP
targetPort: 80
selector:
app: myapp
type: ClusterIP
kubectl get svc
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S)
AGE
kubernetes ClusterIP 10.2.0.1 <none> 443/TCP
158d
myservice ClusterIP 10.2.96.175 <none> 80/TCP
40s

// Create a YAML Template
kubectl create deploy myapp –image=nginx –dry-run -o yaml >
myapp.yaml
//Update replicas=2 in myapp.yaml file
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
app: myapp
name: myapp
spec:
replicas: 2
selector:
matchLabels:
app: myapp
template:
metadata:
labels:
app: myapp
spec:
containers:
– image: nginx
name: nginx
// Create deployment
kubectl create -f myapp.yaml
// Creating YAML template for service
kubectl expose deployment myapp –type=ClusterIP –port=60 —
target-port=60 –name=myservice –dry-run -o yaml >
myservice.yaml
YAML File:
apiVersion: v1
kind: Service
metadata:
labels:
app: myapp
name: myservice
spec:
ports:
– port: 60
protocol: TCP
targetPort: 80
selector:
app: myapp
type: ClusterIP
kubectl get svc
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S)
AGE
kubernetes ClusterIP 10.2.0.1 <none> 443/TCP
158d
myservice ClusterIP 10.2.96.175 <none> 80/TCP
40s

NO.25 // 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.26 Undo the deployment to the previous version 1.17.1 and verify Image has the previous version

NO.27 List all the pods sorted by name

NO.28 Create a snapshot of the etcd instance running at https://127.0.0.1:2379, saving the snapshot to the file path /srv/data/etcd-snapshot.db.
The following TLS certificates/key are supplied for connecting to the server with etcdctl:
CA certificate: /opt/KUCM00302/ca.crt
Client certificate: /opt/KUCM00302/etcd-client.crt
Client key: Topt/KUCM00302/etcd-client.key

NO.29 Given a partially-functioning Kubernetes cluster, identify symptoms of failure on the cluster.
Determine the node, the failing service, and take actions to bring up the failed service and restore the health of the cluster. Ensure that any changes are made permanently.
You can ssh to the relevant I nodes (bk8s-master-0 or bk8s-node-0) using:
[student@node-1] $ ssh <nodename>
You can assume elevated privileges on any node in the cluster with the following command:
[student@nodename] $ | sudo -i

NO.30 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 thestagingnamespace and the volumemust notbe persistent.

NO.31 Create a nginx pod with label env=test in engineering namespace

NO.32 Configure the kubelet systemd- managed service, on the node labelled with name=wk8s-node-1, to launch a pod containing a single container of Image httpd named webtool automatically. Any spec files required should be placed in the /etc/kubernetes/manifests directory on the node.
You can ssh to the appropriate node using:
[student@node-1] $ ssh wk8s-node-1
You can assume elevated privileges on the node with the following command:
[student@wk8s-node-1] $ | sudo -i

NO.33 Create a Kubernetes secret as follows:
Name: super-secret
password: bob
Create a pod named pod-secrets-via-file, using the redis Image, which mounts a secret named super-secret at
/secrets.
Create a second pod named pod-secrets-via-env, using the redis Image, which exports password as CONFIDENTIAL

NO.34 Create an nginx pod and set an env value as ‘var1=val1’. Check the env value existence within the pod

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

kubectl run nginx –image=nginx –restart=Never –env=var1=val1
# then
kubectl exec -it nginx — env
# or
kubectl run nginx –restart=Never –image=nginx –env=var1=val1
-it –rm — env

NO.35 Make the node schedulable by uncordon the node

NO.36 Check to see how many worker nodes are ready (not including nodes taintedNoSchedule) and write the number to/opt/KUCC00104/kucc00104.txt.

NO.37 Fix a node that shows as non-ready

Kubectl get nodes
// Check which node shows a not ready
kubectl describe nodes “node-name”
// Login to the node which shows as not ready and check the
process for kubelet, docker , kube-proxy.
// systemctl status kubelet (or) ps -aux | grep -i “processname”
// If the process is not started, then start using
systemctl start kubelet / docker
// Verify
ps -auxxww | grep -i “process-name”
kubectl get nodes

Kubectl get nodes
// Check which node shows a not ready
kubectl describe nodes “node-name”
// Login to the node which shows as not ready and check the
systemctl start kubelet / docker
// Verify
ps -auxxww | grep -i “process-name”
kubectl get nodes

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

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

NO.40 Configure the kubelet systemd-managed service, on the nodelabelled withname=wk8s-node-1, tolaunch a pod containing a singlecontainer of Image automatically. Any spec filesrequired should be placed in the/etc/kubernetes/manifests You canssh to theappropriate node using:
[student@node-1] $ sshwk8s-node-1
You can assume elevatedprivileges on the node with thefollowing command:
[student@wk8s-node-1] $ |sudo -i

NO.41 Create a pod with environment variables as var1=value1.Check the environment variable in pod

NO.42 Create the service as type NodePort with the port 32767 for the nginx pod with the pod selector app: my-nginx

NO.43 Create a pod with image nginx called nginx and allow traffic on port 80

NO.44 Create a nginx pod that will be deployed to node with the label
“gpu=true”

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

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
yaml
//Verify
kubectl get no -show-labels
kubectl get po
kubectl describe po nginx | grep Node-Selectors

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

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

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

NO.46 From the pod label name=cpu-utilizer, find pods running high CPU workloads and write the name of the pod consuming most CPU to the file /opt/KUTR00102/KUTR00102.txt (which already exists).

NO.47 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 be persistent.

NO.48 What are the differences between using a service versus using an application for Security Policy match?

Use of a “service” enables the firewall to take immediate action with the first observed packet based on port numbers. Use of an application allows the firewall to take action after enough packets allow for App-ID identification regardless of the ports being used

Use of a “service” enables the firewall to take action after enough packets allow for App-ID identification

Use of a “service” enables the firewall to take immediate action with the first observed packet based on port numbers. Use of an “application allows the firewall to take immediate action if the port being used is a member of the application standard port list

There are no differences between “service” or “application.” Use of an “application simplifies configuration by allowing use of a friendly application name instead of port numbers.