Kubernetes - Core Concepts & Deployment Strategies Flashcards

Question 1

What is Kubernetes?

Accepted Answer

Kubernetes (K8s) is an open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications. It groups containers into logical units for easy management and discovery.

Question 2

Explain the difference between declarative and imperative configuration in Kubernetes.

Accepted Answer

•   **Declarative**: You describe the *desired state* of your system (e.g., "I want 3 Nginx pods running"). Kubernetes continuously works to achieve and maintain that state. This is primarily done using YAML manifest files.
•   **Imperative**: You execute *commands* to perform actions (e.g., `kubectl run nginx --image=nginx`). This directly manipulates the current state.

Question 3

What is the primary purpose of YAML in Kubernetes?

Accepted Answer

YAML (YAML Ain't Markup Language) is the standard human-readable data serialization format used to define Kubernetes objects. It allows users to declaratively specify the desired state of their applications and infrastructure (e.g., Pods, Deployments, Services).

Question 4

Name the key components of the Kubernetes Control Plane.

Accepted Answer

The Kubernetes Control Plane manages the cluster and its worker nodes. Its key components are:
•   `kube-apiserver`
•   `etcd`
•   `kube-scheduler`
•   `kube-controller-manager`

Question 5

What is the role of the `kube-apiserver`?

Accepted Answer

The `kube-apiserver` is the front-end of the Kubernetes control plane. It exposes the Kubernetes API, allowing users and other components to interact with the cluster. It validates and configures data for API objects like Pods, Services, etc.

Question 6

What is `etcd` and why is it crucial for Kubernetes?

Accepted Answer

`etcd` is a consistent and highly available key-value store used by Kubernetes to store all cluster data, including configuration data, state information, and metadata about objects (Pods, Deployments, Services, etc.). It acts as the single source of truth for the cluster.

Question 7

Explain the function of the `kube-scheduler`.

Accepted Answer

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

Question 8

What does the `kube-controller-manager` do?

Accepted Answer

The `kube-controller-manager` runs various controller processes that regulate the state of the cluster. Each controller (e.g., Node Controller, Replication Controller, Endpoints Controller, Service Account Controller) watches a specific resource and works to move the current state closer to the desired state.

Question 9

Name the key components running on a Kubernetes Worker Node.

Accepted Answer

A Kubernetes Worker Node (or Minion) runs the actual containerized applications. Its key components are:
•   `kubelet`
•   `kube-proxy`
•   Container Runtime (e.g., Docker, containerd, CRI-O)

Question 10

What is the purpose of `kubelet` on a worker node?

Accepted Answer

`kubelet` is an agent that runs on each worker node. It ensures that containers described in PodSpecs are running and healthy. It communicates with the `kube-apiserver` to receive Pod definitions and manages the Pods' lifecycle on its node.

Question 11

How does `kube-proxy` facilitate networking in Kubernetes?

Accepted Answer

`kube-proxy` runs on each worker node and maintains network rules (e.g., using `iptables` or IPVS) on the node. These rules enable network communication to your Pods from inside or outside the cluster, implementing the Kubernetes Service abstraction.

Question 12

Define 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 (which share network namespace, IP address, and storage), storage resources, and options for how to run the containers.

Question 13

When would you use a multi-container Pod (e.g., a sidecar pattern)?

Accepted Answer

A multi-container Pod is used when containers are tightly coupled and need to share resources (network, storage) and lifecycle. A common example is the **sidecar pattern**, where a helper container (e.g., a log shipper, an adapter, a proxy) runs alongside the main application container to augment its functionality.

Question 14

What is a Kubernetes `Deployment`?

Accepted Answer

A `Deployment` is a higher-level abstraction that manages a set of identical Pods. It provides declarative updates for Pods and ReplicaSets. Deployments allow you to define the desired state for your application (e.g., number of replicas, image version) and handle rolling updates, rollbacks, and scaling.

Question 15

What is a `ReplicaSet` and how does it relate to a `Deployment`?

Accepted Answer

A `ReplicaSet` ensures that a specified number of Pod replicas are running at any given time. It's a lower-level controller. A `Deployment` manages `ReplicaSets` to provide declarative updates and rollbacks, meaning you typically interact with Deployments, which then manage the underlying ReplicaSets.

Question 16

What is a Kubernetes `Service` and why is it needed?

Accepted Answer

A `Service` is an abstraction that defines a logical set of Pods and a policy by which to access them (sometimes called a micro-service). Services enable stable network endpoints for Pods, which are ephemeral and can change IP addresses. It provides load balancing and service discovery.

Question 17

Name and briefly describe three common Kubernetes `Service` types.

Accepted Answer

• `ClusterIP`: Exposes the Service on an internal IP in the cluster. Only reachable from within the cluster. Default type. • `NodePort`: Exposes the Service on each Node's IP at a static port (the `NodePort`). Makes the Service accessible from outside the cluster using `:`. • `LoadBalancer`: Exposes the Service externally using a cloud provider's load balancer. Only works with cloud providers that support it. • `ExternalName`: Maps the Service to the contents of the `externalName` field (e.g., `my.database.example.com`) by returning a `CNAME` record.

Question 18

What is a Kubernetes `Namespace`?

Accepted Answer

A `Namespace` provides a mechanism for isolating groups of resources within a single Kubernetes cluster. It's used for organizational purposes, to divide cluster resources between multiple users or teams, and to provide a scope for resource names. Resources within a Namespace must be unique, but can be duplicated across Namespaces.

Question 19

How do `ConfigMap` and `Secret` differ in Kubernetes?

Accepted Answer

•   `ConfigMap`: Used to store non-confidential configuration data in key-value pairs. It's ideal for application settings, environment variables, or command-line arguments.
•   `Secret`: Used to store sensitive data, such as passwords, OAuth tokens, and SSH keys. Secrets are base64 encoded by default (not encrypted at rest without additional configuration) and mounted as files or environment variables into Pods.

Question 20

Explain the concept of a `PersistentVolume (PV)` in Kubernetes.

Accepted Answer

A `PersistentVolume (PV)` is a piece of storage in the cluster that has been provisioned by an administrator or dynamically provisioned using StorageClasses. It's a cluster-wide resource, independent of any specific Pod, and represents the actual storage resource (e.g., NFS share, AWS EBS volume).

Question 21

What is a `PersistentVolumeClaim (PVC)`?

Accepted Answer

A `PersistentVolumeClaim (PVC)` is a request for storage by a user. It's a request for a specific amount of storage with specific access modes (e.g., ReadWriteOnce, ReadOnlyMany). A PVC consumes a PV resource. Pods then use PVCs to access the underlying storage.

Question 22

How do `StorageClass` objects simplify storage provisioning?

Accepted Answer

A `StorageClass` provides a way for administrators to describe the "classes" of storage they offer (e.g., "fast", "slow", "SSD"). When a `PVC` requests a `StorageClass`, the `StorageClass` dynamically provisions a `PV` that matches the request, abstracting away the underlying storage details from the user.

Question 23

Describe the "Rolling Update" deployment strategy.

Accepted Answer

A "Rolling Update" is a deployment strategy where new versions of an application are gradually rolled out by replacing old Pods with new ones, one by one or in small batches. This ensures zero downtime, as the application remains available throughout the update process. Kubernetes Deployments manage this automatically.

Question 24

What is the Horizontal Pod Autoscaler (HPA)?

Accepted Answer

The `Horizontal Pod Autoscaler (HPA)` automatically scales the number of Pod replicas in a Deployment, ReplicaSet, or StatefulSet based on observed CPU utilization or other select metrics (e.g., custom metrics). It ensures that applications have enough resources to handle varying loads.

Question 25

What is `Ingress` in Kubernetes?

Accepted Answer

`Ingress` exposes HTTP and HTTPS routes from outside the cluster to services within the cluster. It provides external access to your services with features like load balancing, SSL termination, and name-based virtual hosting. An `Ingress` resource requires an `Ingress Controller` (e.g., Nginx, Traefik) to be running in the cluster.

Kubernetes - Core Concepts & Deployment Strategies

Cards in this deck

Related Flashcard Sets

Korean TOPIK I - Essential Vocabulary & Grammar (Levels 1-2)

TypeScript - Advanced Types, Interfaces & Generics

Organic Chemistry Mechanisms - SN1/SN2 & E1/E2 Reactions

Cisco CCNA (200-301) - Enterprise Networking & IP Services