Pass the CKA exam with these 100 practice questions

Update the deployment image using an imperative approach with kubectl set image, updating to version 1.99.8, and verify the deployment is running with kubectl get deployment.

Update the static pod path by locating and editing the kubelet config yaml with nano, then save to manage all static pods on the node, which recreate after deletion.

Upgrade the cluster by following nine steps to update kubeadm, kubelet, and kubectl, including draining and cordoning nodes, applying upgrades, restarting kubelet, and uncordoning.

Learn to scale a deployment by creating it with kubectl create deployment and increasing replicas to two to have more pods, then verify with kubectl describe.

Create a pod and attach labels to organize and select subsets of objects. Use kubectl run to define the pod name and image, then kubectl describe to verify the labels.

Create a namespace to organize the cluster into virtual sub clusters and isolate resources. Deploy a pod with kubectl run, define the image, and assign it to the tech namespace.

Prepare for the cka exam by upgrading a one-replica deployment with rolling update, using kubectl set image, the record flag for rollback, and rollout history to verify changes.

Create a static pod on a node by locating the kubelet config, crafting a pod yaml with a sleep command, and deploying it via scp to the static pod path.

learn how to taint a node to make it unschedulable and use tolerations to schedule pods, with kubectl commands and YAML configuration to verify scheduling.

Create a service account, define a cluster role and cluster role binding, and deploy a pod from a yaml file to list persistent volumes in Kubernetes.

Isolate all pods in a namespace by allowing only port 80 via an ingress network policy, created from a YAML file and verified with kubectl describe.

Apply jsonpath using the cube ctl cheat sheet to filter cluster data, replace external with internal, and output internal ips to a text file for quick verification.

Create a multi-part pod with two containers to share data via a sidecar, add a sleep command, and save a YAML file before deploying the pod in running state.

Create a user by generating a certificate signing request and private key, save the CSR in YAML, then approve the CSR and apply a role binding in the tech namespace.

Start a pod-backed service and run a DNS lookup to verify connectivity, expose the service with a defined name and port, and confirm the result by inspecting the output.

Create a secret with kubectl, mount it to the pod as a volume via yaml, and verify the secret is attached, noting secrets are preferred over config maps for security.

Learn to sort persistent volumes by capacity with kubectl, using the Kubernetes documentation and cheat sheet to copy the command and write results to a text file.

Learn to identify the pod with the highest cpu usage using kubectl top, sorting by cpu for pods labeled environment=process, and capture results to a text file.

Use jsonpath to extract all node names with kubectl, save output to a text file, and verify the file contents for exam-ready familiarity.

learn to retrieve container logs using kubectl, selecting the correct pod and container in devnet, saving logs to a file, and verifying the log content.

Create and configure an ingress resource to expose service on path, copy YAML from docs, set namespace and service name, use port 5678, and deploy with kubectl create -f.

Override the pod label with kubectl label using the override flag, set environment to true, and verify the new label with a describe command.

Upgrade the deployment image from BusyBox 1.27 to 1.28 with kubectl set image, verify the version in the deployment, then roll back and confirm the previous image.

Learn to select pods by their labels to filter running pods, verify three pods are running, and save the results to a text file.

Troubleshoot pod failures with practical steps: diagnose crash loop back off, delete and recreate the pod, fix the sleep command in the yaml, apply the changes, and verify it runs.

Label a node and use a node selector in yaml to ensure a pod is scheduled only on that labeled node.

Learn to create and attach a persistent volume to a pod by configuring a persistent volume claim and mounting it, then verify the binding.

Remove the taint from a node by adding a dash to the taint, then describe the node to verify the taint is gone.

Learn to back up and restore etcd in a Kubernetes environment by verifying data across nodes, capturing etcd snapshots, and restoring from backup on minikube.

Learn how to use tolerations to schedule a pod on tainted nodes, create and edit a pod yaml with tolerations, and verify the pod lands on the correct node.

Apply autoscaling to automate deployment scaling, reducing manual effort and costs in large projects. Verify deployments and confirm the green deployment runs correctly after scaling.

Learn to verify how many nodes are in ready state using kubectl, describe, and grep, then save and review the results for effective troubleshooting.

Create and set an environment variable in a pod with kubectl, then verify it by echoing inside the container; secrets or config maps are the usual store.

Create and configure a config map, inspect it with kubectl describe, and wire it into a pod via a yaml file, then deploy, run, and verify the environment.

Sort all events by timestamp using kubectl get events, following the kubectl cheat sheet, copy the command, run it in the terminal, and save and verify the log file.

Create a pod with a non-persistent volume using a yaml file and kubectl create -f, verify the pod runs, and describe the volume to confirm non-persistent storage suitable for logging.

Investigate why a node is not ready, check its status and description, ssh into the node, adjust the route, restart the kubelet, and bring the node back to ready.

Cordon and drain a Kubernetes node to mark it unavailable and reschedule all pods, enabling safe node upgrades and ensuring pods run on other nodes.

Create a pod that echoes a sentence and deletes itself automatically using kubectl run with restart policy never, ensuring the pod does not persist after execution.

Explore how to apply annotations to a running Kubernetes pod to attach non-identifying metadata, compare annotations with labels, and retrieve the annotated values.

Learn to retrieve all pods across all namespaces with kubectl get pods --all-namespaces, save the output to a text file, and verify the results.

Update an existing config map by editing and replacing the old password, then verify with kubectl describe, kubectl replace -f --force, and exec into the pod to confirm new password.

fix a typo in the node selector to resolve a pending pod, verify labels, and kubectl replace -f after saving a yaml file.

Create a Kubernetes network policy in yaml to allow a pod to egress to two services on ports 8080 and 5432, using an internal policy in the default namespace.

Configure a pod with sys_time in a Kubernetes security context, edit the yaml, remove net admin, create with -f, and verify the pod and sleep command for CKA exam prep.

Create a cluster role and a cluster role binding by defining their names and adding get, watch, and list for pods, then verify by listing pods.

Use Jsonpath to filter pod details, verify the green pot is running, extract the blue pot's IP address, and save the result for easy verification.

Determine the cluster version with kubectl get nodes, see version 1.25.2, and save the output to a text file for upgrading the cluster.

Prepare for CKA exam by updating a stateful set's mount path via deleting and recreating it after editing a yaml file and applying kubectl replace, then verify readiness and update.

Create a Kubernetes cronjob that prints the date and Running every minute by copying a YAML example, applying it with kubectl -f, and verifying with kubectl describe.

Label the namespace, write and save a network policy in YAML, then create the policy from the file to practice Kubernetes networking.

Learn to create a pod with port 80 and a liveness probe, which restarts the container on failure; save the configuration to a YAML file, verify, and delete the pod.

Monitor the logs of a pod by retrieving logs with kubectl, filter with grep, and save the results to a file for inspection.

Learn how to rollback a deployment to a previous revision using kubectl rollout history and defining the revision, ensuring stability when deployments crash.

Inspect pod status and metadata by listing running pods, filter to the orange pod with custom columns, save results to the statistics file, and verify the file content.

Explore resource management in Kubernetes by setting cpu and memory requests and limits for a pod, updating a yaml file, and recreating the pod with kubectl to verify resource changes.

Learn to create a pod with non-persistent storage for logging by defining an empty volume and a volume mount named readers, then verify the pod runs and storage exists.

Troubleshoot a failed pod by checking status, using describe to identify issues, fix a YAML typo, delete the old pod, recreate it from the updated file, and verify it runs.

Expose a pod internally and create a test-pod for look-up, enabling internal service access and quick verification to master Kubernetes concepts for the CKA exam.

Create a daemonset by adapting a deployment YAML, deploy a pod on all nodes, and verify it runs on every node across a three-node cluster.

Learn to diagnose and fix a non-schedulable node by verifying scheduling status, editing the note and pod yaml, redeploying, and confirming successful deployment.

Learn to list all objects in a cluster with kubectl get all all namespaces, spotting what's running and what's not, and save the output to a text file.

Create a pod and assign it to the node by adding node name to yaml file, save as dev.yaml, and verify the pod is deployed on the node mini cube.

Learn to find all pods with a specific label using kubectl get pods, save the output to a label text file, and verify the file.

Apply a taint to a node to block scheduling without tolerations, then use tolerations to allow pods. Verify the minikube node is ready and confirm the taint, key red, NoSchedule.

Learn how to use tolerations to schedule a pod on tainted nodes by inspecting node taints, editing a YAML file, and creating the pod, then verify its node placement.

Use kubectl with jsonpath to filter the gray pot's image version and check it. Save output to gray image.txt and verify that the image version is 1.14.2.

Create a pod with a sidecar container for logging by adapting a Kubernetes sidecar example from the documentation, editing the yaml file, deploying with kubectl, and verifying it's running.

Find out where the Kubernetes Master and Cube DNS are running by using kubectl cluster info, save the output to info.txt, and verify the results.

Use jsonpath to extract the start times of all pods with kubectl get pods, define the json path status.startTime, save the output to start text, and verify the result.

Create and run a pod with kubectl by defining a YAML file, adding a command that sleeps for 100 seconds, then verify the pod is running and review the logs.

Create a pod with CPU requests and limits by using the documented example, save the configuration to a file, and verify the pod with kubectl create f.

Scale a deployment to five replicas using kubectl, verify the pod count and deployment replicas, and describe the deployment to confirm the update.

Learn to enumerate all secrets and configmaps across every namespace using kubectl get with --all-namespaces, save the output to a text file, and verify results.

The lecture demonstrates denying all ingress traffic by applying a default deny network policy, creating a policy file with kubectl create f, and verifying the result.

Create an init container in a pod using a YAML file to run a setup script before the main container starts, then deploy with kubectl and verify.

Learn to collect logs from pods, verify the dev green pod is running, grab the pod name, search for the pattern 'start', and save and verify the output.

Expose a deployment using kubectl expose, verify it is running, and describe the resource to confirm the configuration.

Create two pods with different labels to practice labeling and verification in a green environment, then verify two pods exist with distinct labels.

Practice creates a cluster role, a service account, and a cluster role binding for deployments. Bind the role to the service account and verify all components.

Locate the static pod path by sshing into the minikube node, using ps6 to find the config file, copy it, extract the pod path, and verify.

Learn how to quickly delete a pod by using a grace period of zero and force delete. First, check which pods are running, then delete and verify no resources remain.

Learn to determine your current kubernetes context with kubectl, note the minikube cluster, and save the context output from the config file to a text file for verification.

Identify recently deleted pods by tracking events with cube CTL get events, filter results with cut, save output to recent delete text, and verify findings.

Troubleshoot a pod crash loop by using kubectl get pods and describe, fix a typo in the yaml, delete and recreate the pod, and verify it runs.

Create a pod with non-persistent storage using an emptyDir volume, configure a yaml file with image and name, deploy with kubectl -f, and verify the pod runs.

Create a pod and define a security context with runAsUser and fsGroup to improve privilege and access control. Save the manifest, apply with kubectl -f, and verify.

Troubleshoot a kubeconfig file by validating cluster pods, identifying host port issues, and correcting the port to 8443, then saving and verifying the config.

Learn to grant the net admin capability in a pod by editing the security context in a yaml file and creating the pod with kubectl.

Identify all running pods labeled orange, delete those pods, and verify no resources remain afterward.

Master three-container pod setup by editing and saving a multi-part yaml, deleting and adding resources, then creating the pod with kubectl from a yaml file.

Replace a pod with a new pod of the same name using a YAML file, verify it's running, and confirm the image updates to 1.16.1 with a describe command.

Learn to resize an existing persistent volume claim by inspecting persistent volume claims, editing the yaml file to update storage, applying changes with kubectl replace, and verifying the update.

Edit an existing pod and add a command. Check running pods, save output to a yaml file, modify it, and recreate with kubectl create f to verify with describe.

Add a readiness probe to an existing deployment, edit the yaml to set the probe with port 80 and a three-attempt success threshold, then redeploy.

Gather all contexts and write them to a file by examining the config file and running the specified command. Save the output to a text file and verify.

Create and configure a replica set using a deployment template; edit the yaml to three replicas, remove the strategy, deploy, and verify three pods stay running after deleting one.

List all control plane components by running kubectl get pods in the kube-system namespace, save the output to a text file, and verify the results.