Kubernetes & Container Orchestration Essentials (CKA Prep) Flashcards

Question 1

What is Kubernetes?

Accepted Answer

Kubernetes (K8s) is an open-source system for automating deployment, scaling, and management of containerized applications. It groups containers that make up an application into logical units for easy management and discovery.

Question 2

What are the main components of the Kubernetes Control Plane?

Accepted Answer

The Kubernetes Control Plane manages the worker nodes and the Pods in the cluster. Its main components are `kube-apiserver`, `etcd`, `kube-scheduler`, and `kube-controller-manager`.

Question 3

Explain the role of `kube-apiserver`.

Accepted Answer

The `kube-apiserver` is the front-end for the Kubernetes control plane. It exposes the Kubernetes API, which is used by various tools and libraries (like `kubectl`) to communicate with the cluster. It validates and configures data for API objects like Pods, Services, etc.

Question 4

Explain the role of `etcd`.

Accepted Answer

`etcd` is a consistent and highly-available key-value store used as Kubernetes' backing store for all cluster data. It stores the cluster's configuration data, state, and metadata.

Question 5

Explain the role of `kube-scheduler`.

Accepted Answer

The `kube-scheduler` watches for newly created Pods with no assigned node and selects a node for them to run on. It considers factors like resource requirements, hardware/software/policy constraints, affinity/anti-affinity specifications, and data locality.

Question 6

Explain the role of `kube-controller-manager`.

Accepted Answer

The `kube-controller-manager` runs controller processes. Each controller is a control loop that watches the shared state of the cluster through the API server and makes changes attempting to move the current state towards the desired state. Examples include Node Controller, Replication Controller, Endpoints Controller, and Service Account & Token Controllers.

Question 7

Explain the role of `kubelet`.

Accepted Answer

The `kubelet` is an agent that runs on each node in the cluster. It ensures that containers are running in a Pod. It takes a set of PodSpecs that are provided through various mechanisms and ensures that the containers described in those PodSpecs are running and healthy.

Question 8

Explain the role of `kube-proxy`.

Accepted Answer

The `kube-proxy` runs on each node and maintains network rules on nodes. These rules allow network communication to your Pods from network sessions inside or outside of the cluster. It handles Service abstraction by forwarding traffic to the correct Pods.

Question 9

What is a Kubernetes Pod?

Accepted Answer

A Pod is the smallest deployable unit in Kubernetes. It represents a single instance of a running process in your cluster. A Pod encapsulates one or more containers (e.g., Docker containers), storage resources, a unique network IP, and options that govern how the containers should run.

Question 10

What is a Kubernetes Deployment?

Accepted Answer

A Deployment provides declarative updates for Pods and ReplicaSets. You describe a desired state in a Deployment, and the Deployment Controller changes the actual state to the desired state at a controlled rate. It's commonly used for stateless applications and handles rolling updates and rollbacks.

Question 11

What is a Kubernetes Service?

Accepted Answer

A Kubernetes Service is an abstract way to expose an application running on a set of Pods as a network service. It defines a logical set of Pods and a policy by which to access them (sometimes called a micro-service). Services enable loose coupling between dependent Pods.

Question 12

Explain the 'ClusterIP' Service type.

Accepted Answer

A `ClusterIP` Service exposes the Service on an internal IP in the cluster. It's the default Service type. This Service is only reachable from within the cluster. It's ideal for internal communication between services.

Question 13

Explain the 'NodePort' Service type.

Accepted Answer

A `NodePort` Service exposes the Service on each Node's IP at a static port (the `NodePort`). A `ClusterIP` Service, to which the `NodePort` Service routes, is automatically created. You can contact the `NodePort` Service from outside the cluster by requesting `:`.

Question 14

Explain the 'LoadBalancer' Service type.

Accepted Answer

A `LoadBalancer` Service exposes the Service externally using a cloud provider's load balancer. It automatically provisions an external load balancer, which routes external traffic to the `NodePort` and `ClusterIP` Services. This type is only available with cloud providers that support external load balancers.

Question 15

What is Kubernetes Ingress?

Accepted Answer

Ingress exposes HTTP and HTTPS routes from outside the cluster to services within the cluster. It provides external reachability, load balancing, SSL termination, and name-based virtual hosting, typically managed by an Ingress Controller (e.g., NGINX Ingress Controller).

Question 16

What is a ConfigMap?

Accepted Answer

A `ConfigMap` is an API object used to store non-confidential data in key-value pairs. It allows you to decouple configuration artifacts from image content to keep containerized applications portable. Pods can consume ConfigMaps as environment variables, command-line arguments, or as files in a volume.

Question 17

What is a Secret, and how does it differ from a ConfigMap?

Accepted Answer

A `Secret` is an API object used to store sensitive information, such as passwords, OAuth tokens, and SSH keys. It's similar to a `ConfigMap` but is designed for confidential data. Secrets are base64 encoded by default (not encrypted) and can be mounted as files or exposed as environment variables to Pods. They differ from `ConfigMaps` primarily in their intended use for sensitive data and some security-related features.

Question 18

What is a Liveness Probe?

Accepted Answer

A Liveness Probe determines if a container is still running. If the probe fails, Kubernetes restarts the container. This helps to catch deadlocks where an application is running but unable to make progress.

Question 19

What is a Readiness Probe?

Accepted Answer

A Readiness Probe determines if a container is ready to serve requests. If the probe fails, Kubernetes removes the Pod's IP address from the endpoints of all Services, preventing traffic from being sent to it. Once the probe succeeds, the Pod is added back to the Service endpoints. This is useful during startup or temporary outages.

Question 20

What is a NetworkPolicy?

Accepted Answer

A `NetworkPolicy` specifies how groups of Pods are allowed to communicate with each other and with other network endpoints. NetworkPolicies are implemented by a network plugin (e.g., Calico, Cilium) and allow you to define ingress and egress rules for Pods, enhancing cluster security.

Question 21

Explain PersistentVolumes (PV) and PersistentVolumeClaims (PVC).

Accepted Answer

A `PersistentVolume` (PV) is a piece of storage in the cluster that has been provisioned by an administrator or dynamically provisioned. A `PersistentVolumeClaim` (PVC) is a request for storage by a user. PVCs consume PV resources. This abstraction allows users to request storage without knowing the underlying infrastructure details.

Question 22

What is Kubernetes RBAC?

Accepted Answer

RBAC (Role-Based Access Control) is a method of regulating access to computer or network resources based on the roles of individual users within an enterprise. In Kubernetes, RBAC uses `Roles` (or `ClusterRoles`) to define permissions and `RoleBindings` (or `ClusterRoleBindings`) to grant those permissions to users or service accounts.

Question 23

List essential `kubectl` CLI flags for output formatting.

Accepted Answer

Essential `kubectl` flags for output formatting include:
- `-o wide`: Provides additional information, such as node names for Pods.
- `-o yaml`: Outputs the resource in YAML format.
- `-o json`: Outputs the resource in JSON format.
- `--show-labels`: Shows labels for resources.
Example: `kubectl get pods -o wide` or `kubectl get deployment my-app -o yaml`.

Question 24

List essential `kubectl` commands for debugging Pods.

Accepted Answer

Essential `kubectl` commands for debugging Pods include: - `kubectl logs `: Prints the logs for a container in a Pod. - `kubectl exec -it -- `: Executes a command in a container within a Pod (e.g., `kubectl exec -it my-pod -- bash`). - `kubectl describe pod `: Shows detailed information about a Pod, including events, status, and resource usage.

Kubernetes & Container Orchestration Essentials (CKA Prep)

Cards in this deck

Related Flashcard Sets

German B1 - Intermediate Conversational Phrases & Structures

French A1/A2 - Essential Grammar & Vocab

Rust - Ownership, Borrowing & Lifetimes: Memory Safety Concepts

Neuroscience - Neurotransmitters & Synaptic Transmission