Kubernetes & Docker - Container Orchestration & Deployment Flashcards

Question 1

Docker vs. Kubernetes

Accepted Answer

**Docker** is a containerization platform used to package applications and their dependencies into lightweight, isolated containers.

**Kubernetes** (K8s) is a container orchestration engine that automates the deployment, scaling, load balancing, networking, and management of containerized workloads across a cluster of nodes.

Question 2

Control Plane (Master Node) Components

Accepted Answer

The Control Plane manages the global state of the Kubernetes cluster:

- `kube-apiserver`: Exposes the Kubernetes API (front end of the control plane).
- `etcd`: Consistent, highly available key-value store for all cluster data.
- `kube-scheduler`: Selects optimal Worker Nodes for unscheduled Pods.
- `kube-controller-manager`: Runs controller loops (e.g., Node, ReplicaSet controllers).

Question 3

Worker Node Components

Accepted Answer

Worker Nodes run application containers and report state back to the Control Plane:

- `kubelet`: Primary agent that ensures containers defined in PodSpecs are running and healthy.
- `kube-proxy`: Maintains network rules on nodes to allow network communication to Pods.
- **Container Runtime**: Underlying engine executing containers (e.g., `containerd`, `CRI-O`).

Question 4

Kubernetes Pod

Accepted Answer

The smallest, basic deployable object in Kubernetes. A **Pod** represents a single instance of a running process in your cluster and encapsulates one or more containers that share:
- Network IP address and port space (`localhost` communication)
- Storage volumes
- Container execution options

Question 5

Kubernetes Deployment

Accepted Answer

A declarative API object used to manage stateless applications. A `Deployment` manages a `ReplicaSet` underneath to maintain a specified count of identical Pods, handling automated rolling updates, rollbacks, and self-healing.

Question 6

Kubernetes StatefulSet

Accepted Answer

A workload object designed for stateful applications (e.g., Databases like PostgreSQL, Kafka). Key characteristics:
- Stable, unique network identifiers (e.g., `pod-0`, `pod-1`).
- Ordered, graceful deployment and scaling.
- Persistent storage binding via `volumeClaimTemplates` per Pod replica.

Question 7

Kubernetes DaemonSet

Accepted Answer

Ensures that all (or a subset of) Nodes run a copy of a specific Pod. As new nodes are added to the cluster, Pods are automatically added to them.

*Common Use Cases*: Cluster log collection (e.g., Fluentd), metric collection (e.g., Prometheus Node Exporter), CNI network plugins.

Question 8

Kubernetes Service Types

Accepted Answer

Services expose a set of Pods as a network service:

- `ClusterIP` (Default): Exposes the Service on an internal cluster IP.
- `NodePort`: Exposes the Service on each Node's IP at a static port (typically 30000-32767).
- `LoadBalancer`: Provisions an external Cloud Load Balancer (e.g., AWS ELB, GCP CLB) pointing to `NodePort`/`ClusterIP` endpoints.

Question 9

Kubernetes Ingress & Ingress Controller

Accepted Answer

**Ingress**: An API object defining rules for routing external HTTP/HTTPS traffic to internal Services.

**Ingress Controller**: The actual load balancer/reverse proxy (e.g., NGINX, Traefik, HAProxy) that reads Ingress rules and executes the traffic routing.

Question 10

ConfigMaps vs. Secrets

Accepted Answer

- `ConfigMap`: Stores non-confidential configuration data as key-value pairs in plain text.
- `Secret`: Stores sensitive data (passwords, tokens, TLS certificates) stored as Base64-encoded values.

Both can be mounted into Pods as environment variables or volume files.

Question 11

PersistentVolume (PV) vs. PersistentVolumeClaim (PVC)

Accepted Answer

- `PersistentVolume` (PV): A cluster-wide storage resource provisioned by an administrator or dynamically via a `StorageClass`.
- `PersistentVolumeClaim` (PVC): A user's request for storage that specifies size, access modes (`ReadWriteOnce`, `ReadWriteMany`), and dynamic provisioning parameters.

Question 12

Container Health Probes

Accepted Answer

- `Liveness Probe`: Determines if the container needs a restart (failure causes Pod container restart).
- `Readiness Probe`: Determines if the container is ready to service traffic (failure removes Pod from Service endpoints).
- `Startup Probe`: Disables liveness/readiness checks until slow-starting applications finish initialization.

Question 13

Essential `kubectl` Inspection Commands

Accepted Answer

```bash # List all Pods in a specific namespace kubectl get pods -n # Detailed inspection of resource state and events kubectl describe pod # Stream live logs from a specific container kubectl logs -f -c ```

Question 14

Essential `kubectl` Execution & Debugging Commands

Accepted Answer

```bash # Open an interactive shell inside a container kubectl exec -it -- /bin/sh # Forward local port 8080 to container port 80 kubectl port-forward pod/ 8080:80 # Declaratively apply configuration files kubectl apply -f deployment.yaml ```

Question 15

Docker Multi-Stage Builds

Accepted Answer

A Dockerfile technique using multiple `FROM` instructions. It optimizes container image size by building application binaries in a heavy SDK image and copying *only* the compiled artifacts into a lightweight final image (e.g., `alpine` or `distroless`).

Question 16

Copy-on-Write (CoW) in Docker Containers

Accepted Answer

Docker image layers are read-only. When a container runs, a thin, writable container layer is added on top. If a container modifies an existing file, it copies the file from the lower read-only layer to the top writable layer before editing, conserving disk space and speeding up image creation.

Question 17

Kubernetes Namespaces

Accepted Answer

Virtual isolation partitions within a single physical Kubernetes cluster. Used to scope resources, assign Role-Based Access Control (RBAC) permissions, and set compute resource limits (`ResourceQuota`) across environments (e.g., `dev`, `staging`, `prod`).

Question 18

Resource Requests vs. Resource Limits

Accepted Answer

- **Requests**: The minimum CPU and memory guaranteed to a container. The `kube-scheduler` uses requests to decide which node to place the Pod on.
- **Limits**: The maximum CPU and memory allowed. Exceeding memory limits results in Out-Of-Memory (`OOMKilled`); exceeding CPU limits results in CPU throttling.

Question 19

Horizontal Pod Autoscaler (HPA)

Accepted Answer

A Kubernetes controller that automatically scales the number of Pod replicas in a `Deployment` or `StatefulSet` based on observed metrics like CPU/memory utilization or custom metric targets.

Question 20

Kubernetes NetworkPolicy

Accepted Answer

An API object defining how groups of Pods are allowed to communicate with each other and other network endpoints (ingress/egress). Requires a CNI plugin that supports NetworkPolicies (e.g., Calico, Cilium) to enforce non-flat, zero-trust network boundaries.

Kubernetes & Docker - Container Orchestration & Deployment

Cards in this deck

Related Flashcard Sets

HSK 1 - Basic Chinese Vocabulary, Pinyin & Character Recognition

Functional Programming - Immutability, Pure Functions & Higher-Order Functions

Neuroscience - Neuroanatomy & Brain Function

Microsoft Azure Administrator (AZ-104) - Compute, Storage & Networking