{"id":21061,"date":"2026-09-24T10:33:02","date_gmt":"2026-09-24T10:33:02","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=21061"},"modified":"2026-09-24T10:33:02","modified_gmt":"2026-09-24T10:33:02","slug":"cncf-cka-practice-test-questions-and-exam-dumps-part4-q61-80","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/cncf-cka-practice-test-questions-and-exam-dumps-part4-q61-80\/","title":{"rendered":"CNCF CKA Practice Test Questions and Exam Dumps Part4 Q61-80"},"content":{"rendered":"

View Full <\/b>CNCF CKA Exam Dumps<\/b><\/a> and Practice Test Dumps<\/b><\/h2>\n

 <\/p>\n

Question 61<\/b><\/h3>\n

Which command creates a namespace directly from kubectl?<\/b><\/p>\n

    \n
  1. kubectl make namespace<\/span><\/li>\n
  2. kubectl namespace create<\/span><\/li>\n
  3. kubectl create namespace<\/span><\/li>\n
  4. kubectl new namespace<\/span><\/li>\n<\/ol>\n

    Correct Answer: 3<\/b><\/p>\n

    Explanation:<\/b><\/p>\n

    The kubectl create namespace command creates a new Kubernetes namespace directly from the command line. Namespaces provide logical separation for resources within a cluster and are commonly used to organize applications, teams, or environments. Administrators can subsequently specify the namespace when creating or querying resources. Namespaces also work with mechanisms such as ResourceQuota and RBAC to establish resource and access boundaries. Using the correct command syntax is important during practical cluster administration tasks.<\/span><\/p>\n

    Question 62<\/b><\/h3>\n

    Which field identifies a Pod’s controlling workload through metadata?<\/b><\/p>\n

      \n
    1. ownerReferences<\/span><\/li>\n
    2. resourceVersion<\/span><\/li>\n
    3. generation<\/span><\/li>\n
    4. managedFields<\/span><\/li>\n<\/ol>\n

      Correct Answer: 1<\/b><\/p>\n

      Explanation:<\/b><\/p>\n

      The ownerReferences field identifies resources that own or control another Kubernetes object. For example, a ReplicaSet can own Pods, while a Deployment can own a ReplicaSet. Kubernetes uses ownership relationships for lifecycle management and garbage collection. When troubleshooting unexpectedly recreated resources, examining ownership can reveal which controller is responsible. Other metadata fields serve different purposes: resourceVersion tracks object versions, generation reflects desired-state changes, and managedFields records field management information.<\/span><\/p>\n

      Question 63<\/b><\/h3>\n

      Which Pod phase indicates that containers are currently executing?<\/b><\/p>\n

        \n
      1. Pending<\/span><\/li>\n
      2. Failed<\/span><\/li>\n
      3. Running<\/span><\/li>\n
      4. Succeeded<\/span><\/li>\n<\/ol>\n

        Correct Answer: 3<\/b><\/p>\n

        Explanation:<\/b><\/p>\n

        The Running Pod phase indicates that the Pod has been bound to a node and that its containers have started, although they may not necessarily be ready to serve application traffic. Pending indicates that the Pod has not yet completed scheduling or startup preparation. Succeeded means containers terminated successfully, while Failed means the containers terminated unsuccessfully. Understanding Pod phases helps administrators quickly interpret workload state during troubleshooting and cluster monitoring.<\/span><\/p>\n

        Question 64<\/b><\/h3>\n

        Which probe checks whether an application has started successfully?<\/b><\/p>\n

          \n
        1. Readiness probe<\/span><\/li>\n
        2. Startup probe<\/span><\/li>\n
        3. Liveness probe<\/span><\/li>\n
        4. Exec command<\/span><\/li>\n<\/ol>\n

          Correct Answer: 2<\/b><\/p>\n

          Explanation:<\/b><\/p>\n

          A startup probe determines whether an application inside a container has successfully started. It is especially useful for applications that require substantial initialization time. When a startup probe is configured, Kubernetes can delay liveness and readiness evaluation until startup succeeds. A readiness probe determines whether traffic should be sent to the Pod, while a liveness probe determines whether the container should be restarted. Proper probe selection prevents Kubernetes from incorrectly treating slow-starting applications as failed.<\/span><\/p>\n

          Question 65<\/b><\/h3>\n

          Which command displays container resource usage in a cluster?<\/b><\/p>\n

            \n
          1. kubectl metrics<\/span><\/li>\n
          2. kubectl usage<\/span><\/li>\n
          3. kubectl top<\/span><\/li>\n
          4. kubectl resources<\/span><\/li>\n<\/ol>\n

            Correct Answer: 3<\/b><\/p>\n

            Explanation:<\/b><\/p>\n

            kubectl top displays resource usage information for nodes or Pods when the required metrics infrastructure is available. Administrators can use it to inspect CPU and memory consumption and identify workloads or nodes experiencing significant resource usage. This information complements declared requests and limits because actual consumption may differ from configured values. If metrics are unavailable, the command may return an error rather than useful usage data, so the metrics pipeline must also be considered during troubleshooting.<\/span><\/p>\n

            Question 66<\/b><\/h3>\n

            Which Kubernetes object controls default resource settings for containers?<\/b><\/p>\n

              \n
            1. ResourceQuota<\/span><\/li>\n
            2. LimitRange<\/span><\/li>\n
            3. PriorityClass<\/span><\/li>\n
            4. PodDisruptionBudget<\/span><\/li>\n<\/ol>\n

              Correct Answer: 2<\/b><\/p>\n

              Explanation:<\/b><\/p>\n

              A LimitRange can establish default resource requests and limits and impose constraints on resource usage within a namespace. This helps administrators maintain consistent resource policies when individual workloads do not specify complete values. ResourceQuota instead controls aggregate consumption across a namespace. PriorityClass affects scheduling priority, while PodDisruptionBudget addresses voluntary disruptions. LimitRange is therefore particularly useful for establishing sensible resource defaults and preventing workloads from being created with inappropriate resource configurations.<\/span><\/p>\n

              Question 67<\/b><\/h3>\n

              Which container state commonly indicates an image retrieval failure?<\/b><\/p>\n

                \n
              1. Waiting<\/span><\/li>\n
              2. Running<\/span><\/li>\n
              3. Terminated<\/span><\/li>\n
              4. Completed<\/span><\/li>\n<\/ol>\n

                Correct Answer: 1<\/b><\/p>\n

                Explanation:<\/b><\/p>\n

                A container in the Waiting state may be unable to start because Kubernetes is performing preparatory actions or encountering a problem such as an image-pull failure. The detailed reason can be examined using kubectl describe pod, which often displays useful events such as authentication errors, unavailable repositories, or invalid image references. Running means the container has started, while Terminated means its process has stopped. Understanding container states helps distinguish startup problems from runtime failures.<\/span><\/p>\n

                Question 68<\/b><\/h3>\n

                Which command streams logs continuously from a running container?<\/b><\/p>\n

                  \n
                1. kubectl logs –watch<\/span><\/li>\n
                2. kubectl logs –stream<\/span><\/li>\n
                3. kubectl logs –follow<\/span><\/li>\n
                4. kubectl logs –tail<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 3<\/b><\/p>\n

                  Explanation:<\/b><\/p>\n

                  The –follow option causes kubectl logs to continue streaming new log output as it becomes available. This is useful when observing an application during startup, testing, or troubleshooting. Instead of retrieving only the existing log content, the command remains attached and displays subsequent output. The –tail option limits how many recent lines are shown but does not provide the same streaming behavior. Continuous log observation can help identify intermittent application failures.<\/span><\/p>\n

                  Question 69<\/b><\/h3>\n

                  Which Kubernetes feature can terminate lower-priority Pods for scheduling?<\/b><\/p>\n

                    \n
                  1. Pod affinity<\/span><\/li>\n
                  2. Preemption<\/span><\/li>\n
                  3. Service discovery<\/span><\/li>\n
                  4. Volume binding<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 2<\/b><\/p>\n

                    Explanation:<\/b><\/p>\n

                    Preemption allows Kubernetes scheduling to make room for a higher-priority Pod by removing lower-priority Pods when the necessary scheduling conditions are met. It works together with Pod priority settings. Preemption is intended to help satisfy important workload placement requirements when resources are constrained. Administrators should understand its impact because a high-priority workload may cause lower-priority workloads to be evicted. Affinity, service discovery, and volume binding address different scheduling or networking concerns.<\/span><\/p>\n

                    Question 70<\/b><\/h3>\n

                    Which command applies resources described in a YAML manifest?<\/b><\/p>\n

                      \n
                    1. kubectl submit<\/span><\/li>\n
                    2. kubectl deploy<\/span><\/li>\n
                    3. kubectl apply<\/span><\/li>\n
                    4. kubectl commit<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 3<\/b><\/p>\n

                      Explanation:<\/b><\/p>\n

                      kubectl apply creates or updates Kubernetes resources based on declarative configuration. It allows administrators to manage resource definitions as manifests and repeatedly reconcile the cluster with the desired configuration. This differs from imperative commands that directly perform individual operations. Declarative management is central to Kubernetes administration because configuration can be stored, reviewed, versioned, and reused. Administrators should verify the target cluster and namespace before applying manifests to avoid unintended changes.<\/span><\/p>\n

                      Question 71<\/b><\/h3>\n

                      Which field determines a container’s maximum CPU consumption?<\/b><\/p>\n

                        \n
                      1. CPU limit<\/span><\/li>\n
                      2. CPU request<\/span><\/li>\n
                      3. Memory request<\/span><\/li>\n
                      4. Pod priority<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 1<\/b><\/p>\n

                        Explanation:<\/b><\/p>\n

                        A CPU limit defines the maximum CPU resource a container is permitted to consume according to Kubernetes resource enforcement. A CPU request serves primarily as a scheduling requirement, helping Kubernetes select a node with sufficient allocatable capacity. Memory requests and Pod priority serve different purposes. Correctly distinguishing requests from limits is important when diagnosing scheduling behavior and runtime performance. An overly restrictive CPU limit can also affect application responsiveness when workloads experience increased demand.<\/span><\/p>\n

                        Question 72<\/b><\/h3>\n

                        Which Kubernetes resource maps an external hostname to HTTP services?<\/b><\/p>\n

                          \n
                        1. EndpointSlice<\/span><\/li>\n
                        2. Ingress<\/span><\/li>\n
                        3. Namespace<\/span><\/li>\n
                        4. ReplicaSet<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 2<\/b><\/p>\n

                          Explanation:<\/b><\/p>\n

                          An Ingress can define HTTP or HTTPS routing rules that map external requests to Kubernetes Services. Rules may use hostnames and URL paths to determine the appropriate backend. An Ingress requires a compatible controller to implement the defined routing behavior. EndpointSlice tracks backend endpoints, Namespace organizes resources, and ReplicaSet maintains replicated Pods. Ingress is therefore commonly used when administrators need controlled external HTTP or HTTPS access to application services.<\/span><\/p>\n

                          Question 73<\/b><\/h3>\n

                          Which command shows the current cluster contexts?<\/b><\/p>\n

                            \n
                          1. kubectl config get-contexts<\/span><\/li>\n
                          2. kubectl contexts list<\/span><\/li>\n
                          3. kubectl show contexts<\/span><\/li>\n
                          4. kubectl get clusters<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1<\/b><\/p>\n

                            Explanation:<\/b><\/p>\n

                            kubectl config get-contexts lists the contexts configured in the kubeconfig file. A context combines information such as a cluster, user, and namespace, allowing administrators to switch between different Kubernetes environments. The command is especially useful when working with multiple clusters because it helps verify which contexts are available before selecting one. Confusing contexts can result in commands being executed against an unintended cluster, so context verification is an important administrative habit.<\/span><\/p>\n

                            Question 74<\/b><\/h3>\n

                            Which scheduling object expresses a preference rather than a strict requirement?<\/b><\/p>\n

                              \n
                            1. Required affinity<\/span><\/li>\n
                            2. Preferred affinity<\/span><\/li>\n
                            3. Node taint<\/span><\/li>\n
                            4. Pod toleration<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 2<\/b><\/p>\n

                              Explanation:<\/b><\/p>\n

                              Preferred node affinity expresses a scheduling preference rather than an absolute requirement. The scheduler attempts to honor the preference when possible but can still place the Pod elsewhere if necessary. Required affinity, in contrast, must be satisfied for the Pod to be scheduled. Taints repel Pods unless tolerated, while tolerations permit Pods to run on matching tainted nodes. Understanding the difference between preference and requirement helps administrators design flexible workload placement policies.<\/span><\/p>\n

                              Question 75<\/b><\/h3>\n

                              Which object tracks individual backend addresses for a Service?<\/b><\/p>\n

                                \n
                              1. EndpointSlice<\/span><\/li>\n
                              2. ConfigMap<\/span><\/li>\n
                              3. Lease<\/span><\/li>\n
                              4. ResourceQuota<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 1<\/b><\/p>\n

                                Explanation:<\/b><\/p>\n

                                EndpointSlice stores information about network endpoints associated with a Kubernetes Service. It provides a scalable way to represent backend addresses and related endpoint information, particularly for Services with many endpoints. Kubernetes networking components can use this information to determine where traffic should be directed. ConfigMaps store configuration, Leases support coordination and leadership mechanisms, and ResourceQuota manages namespace consumption. EndpointSlice is therefore an important resource when investigating Service backend behavior.<\/span><\/p>\n

                                Question 76<\/b><\/h3>\n

                                Which object coordinates orderly deployment of stateful replicas?<\/b><\/p>\n

                                  \n
                                1. ReplicaSet<\/span><\/li>\n
                                2. StatefulSet<\/span><\/li>\n
                                3. DaemonSet<\/span><\/li>\n
                                4. CronJob<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 2<\/b><\/p>\n

                                  Explanation:<\/b><\/p>\n

                                  A StatefulSet manages stateful applications that need stable Pod identities and predictable deployment characteristics. It can maintain stable network identities and persistent storage associations while controlling the creation and termination order of replicas. ReplicaSets are primarily used to maintain interchangeable replicated Pods, DaemonSets associate workloads with nodes, and CronJobs create scheduled Jobs. StatefulSets are therefore appropriate for workloads where identity and ordered behavior are important operational requirements.<\/span><\/p>\n

                                  Question 77<\/b><\/h3>\n

                                  Which command removes a node from active scheduling and evicts workloads?<\/b><\/p>\n

                                    \n
                                  1. kubectl drain<\/span><\/li>\n
                                  2. kubectl cordon<\/span><\/li>\n
                                  3. kubectl isolate<\/span><\/li>\n
                                  4. kubectl evacuate<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 1<\/b><\/p>\n

                                    Explanation:<\/b><\/p>\n

                                    kubectl drain prepares a node for maintenance by marking it unschedulable and attempting to evict suitable Pods. It is commonly used before rebooting, upgrading, or replacing a node. Some workloads may require special handling, and drain can encounter blockers such as unmanaged Pods or restrictive disruption policies. kubectl cordon only prevents new scheduling and does not evict existing workloads. Understanding this distinction helps administrators perform node maintenance safely.<\/span><\/p>\n

                                    Question 78<\/b><\/h3>\n

                                    Which field identifies the namespace of a Kubernetes object?<\/b><\/p>\n

                                      \n
                                    1. namespace<\/span><\/li>\n
                                    2. scope<\/span><\/li>\n
                                    3. tenant<\/span><\/li>\n
                                    4. domain<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 1<\/b><\/p>\n

                                      Explanation:<\/b><\/p>\n

                                      The namespace field in an object’s metadata identifies the namespace containing a namespaced Kubernetes resource. Namespaces provide logical boundaries within a cluster and allow administrators to organize resources and apply policies. When creating manifests, specifying the namespace can ensure the object is created in the intended location, although command-line options can also select namespaces. Cluster-scoped resources, such as Nodes, do not belong to a namespace.<\/span><\/p>\n

                                      Question 79<\/b><\/h3>\n

                                      Which command lists Pods with their assigned node names?<\/b><\/p>\n

                                        \n
                                      1. kubectl get pods –nodes<\/span><\/li>\n
                                      2. kubectl get pods -o wide<\/span><\/li>\n
                                      3. kubectl get pods –placement<\/span><\/li>\n
                                      4. kubectl show pods -n<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 2<\/b><\/p>\n

                                        Explanation:<\/b><\/p>\n

                                        kubectl get pods -o wide provides additional Pod information, including the node on which each Pod is scheduled. This is useful when troubleshooting workload distribution, node-specific failures, or unexpected placement. Standard Pod listings provide less detail, while wide output exposes additional fields such as Pod IP and node information. Administrators can combine this output with labels or namespace selection to narrow investigations to specific workloads or environments.<\/span><\/p>\n

                                        Question 80<\/b><\/h3>\n

                                        Which Kubernetes object stores non-sensitive application settings?<\/b><\/p>\n

                                          \n
                                        1. Secret<\/span><\/li>\n
                                        2. ConfigMap<\/span><\/li>\n
                                        3. CertificateSigningRequest<\/span><\/li>\n
                                        4. Lease<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 2<\/b><\/p>\n

                                          Explanation:<\/b><\/p>\n

                                          A ConfigMap stores non-sensitive configuration information that applications can consume through environment variables, command arguments, or mounted files. It helps separate configuration from the container image, allowing the same application image to operate with different settings in different environments. Secrets should be used for sensitive information such as credentials. CertificateSigningRequest relates to certificate requests, while Lease objects support coordination mechanisms. Proper separation of configuration and application code improves deployment flexibility and administration.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full CNCF CKA Exam Dumps and Practice Test Dumps   Question 61 Which command creates a namespace directly from kubectl? kubectl make namespace kubectl namespace create kubectl create namespace kubectl new namespace Correct Answer: 3 Explanation: The kubectl create namespace command creates a new Kubernetes namespace directly from the command line. Namespaces provide logical […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1648,1647],"tags":[],"_links":{"self":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/21061"}],"collection":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/comments?post=21061"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/21061\/revisions"}],"predecessor-version":[{"id":21062,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/21061\/revisions\/21062"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=21061"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=21061"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=21061"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}