Kubernetes Fundamentals - Pods, Deployments & Services Flashcards

Question 1

What is Kubernetes?

Accepted Answer

Kubernetes (K8s) is an open-source container orchestration platform that automates the 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 key benefits of using Kubernetes?

Accepted Answer

Key benefits include automated rollouts & rollbacks, self-healing capabilities, service discovery & load balancing, horizontal scaling, secret & configuration management, and resource utilization optimization.

Question 3

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 run.

Question 4

What is the relationship between a Pod and a container?

Accepted Answer

A Pod is a wrapper around one or more containers. While containers are the fundamental building blocks for applications, Pods provide the environment and resources for these containers to run within Kubernetes, sharing their network namespace and storage.

Question 5

Why are Pods considered the smallest deployable unit in Kubernetes?

Accepted Answer

Pods are the smallest deployable unit because they are the atomic unit of scheduling. Kubernetes schedules and manages Pods, not individual containers. All containers within a Pod are co-located and co-scheduled on the same node.

Question 6

How do containers within the same Pod communicate?

Accepted Answer

Containers within the same Pod share the same network namespace and localhost. They can communicate with each other using `localhost` and their respective ports. They can also share storage volumes.

Question 7

Provide a basic YAML manifest for a Kubernetes Pod.

Accepted Answer

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: my-nginx-pod
  labels:
    app: nginx
spec:
  containers:
  - name: nginx-container
    image: nginx:latest
    ports:
    - containerPort: 80
```

Question 8

What is a Kubernetes ReplicaSet?

Accepted Answer

A ReplicaSet is a Kubernetes controller that ensures a specified number of Pod replicas are running at any given time. Its primary purpose is to maintain the stability and availability of a set of Pods.

Question 9

What is the primary purpose of a ReplicaSet?

Accepted Answer

The primary purpose of a ReplicaSet is to guarantee the availability of a specified number of identical Pods. If a Pod fails, the ReplicaSet will automatically create a new one to replace it, ensuring the desired replica count is maintained.

Question 10

How does a ReplicaSet ensure high availability?

Accepted Answer

By continuously monitoring the running Pods that match its selector, a ReplicaSet ensures that the desired number of replicas is always available. If a Pod crashes or is deleted, the ReplicaSet detects this and creates a new Pod to maintain the specified count, thus ensuring high availability.

Question 11

What is a Kubernetes Deployment?

Accepted Answer

A Deployment is a higher-level abstraction that manages ReplicaSets and provides declarative updates to Pods and ReplicaSets. It allows you to describe the desired state of your application and handles the process of changing the actual state to the desired state.

Question 12

How does a Deployment relate to a ReplicaSet and Pods?

Accepted Answer

A Deployment manages ReplicaSets, and ReplicaSets manage Pods. When you create a Deployment, it creates a ReplicaSet to bring up the Pods. When you update a Deployment, it creates a new ReplicaSet with the updated configuration and gracefully scales down the old one, ensuring zero downtime.

Question 13

What are the key features of a Deployment?

Accepted Answer

Key features include rolling updates (updating Pods gradually), rollbacks (reverting to a previous version), scaling (changing the number of Pod replicas), and self-healing (restarting failed Pods via its underlying ReplicaSet).

Question 14

Provide a basic YAML manifest for a Kubernetes Deployment.

Accepted Answer

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-deployment
  labels:
    app: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app-container
        image: my-app-image:v1.0
        ports:
        - containerPort: 8080
```

Question 15

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, providing a stable IP address and DNS name for a dynamic set of Pods.

Question 16

Why are Services necessary in Kubernetes?

Accepted Answer

Pods are ephemeral and have dynamic IP addresses. Services provide a stable, persistent IP address and DNS name, allowing other applications or external users to reliably access the application running on the Pods, even as Pods are created, deleted, or moved.

Question 17

What is a `ClusterIP` Service?

Accepted Answer

A `ClusterIP` Service exposes the Service on an internal IP address within the cluster. This type of Service is only reachable from within the cluster. It's the default Service type and is used for internal communication between different services or components within your Kubernetes cluster.

Question 18

When would you use a `ClusterIP` Service?

Accepted Answer

You would use a `ClusterIP` Service for backend services that only need to be accessed by other services or Pods within the same Kubernetes cluster, not directly from outside the cluster (e.g., a database service or an internal API).

Question 19

What is a `NodePort` Service?

Accepted Answer

A `NodePort` Service exposes the Service on each Node's IP at a static port (the `NodePort`). This makes the Service accessible from outside the cluster by requesting `:`. Kubernetes automatically routes external traffic to the correct Pods.

Question 20

When would you use a `NodePort` Service?

Accepted Answer

You would use a `NodePort` Service when you need to expose a service to external traffic and you have control over the network infrastructure to route traffic to the cluster nodes. It's often used for development, testing, or in environments where a `LoadBalancer` is not available or desired.

Question 21

What is a `LoadBalancer` Service?

Accepted Answer

A `LoadBalancer` Service exposes the Service externally using a cloud provider's load balancer. When you create a `LoadBalancer` Service, Kubernetes provisions an external load balancer (e.g., AWS ELB, GCP Load Balancer) that routes traffic to your Nodes and Pods.

Question 22

When would you use a `LoadBalancer` Service?

Accepted Answer

You would use a `LoadBalancer` Service for public-facing applications that require a dedicated, external IP address and robust load balancing provided by your cloud infrastructure. It's ideal for production web applications.

Question 23

Provide a basic YAML manifest for a `ClusterIP` Service.

Accepted Answer

```yaml
apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: ClusterIP
```

Question 24

What is a Kubernetes Namespace?

Accepted Answer

A Namespace provides a mechanism for isolating groups of resources within a single Kubernetes cluster. It's a way to divide cluster resources between multiple users or teams, providing a scope for names and preventing naming collisions.

Question 25

What is the primary purpose of Namespaces?

Accepted Answer

The primary purpose of Namespaces is to provide logical isolation and organization for resources within a Kubernetes cluster. They allow multiple virtual clusters to exist on top of a single physical cluster, enabling resource quotas, access control, and preventing naming conflicts.

Kubernetes Fundamentals - Pods, Deployments & Services

Cards in this deck

Related Flashcard Sets

Kubernetes Fundamentals - Container Orchestration & Deployment

Kubernetes Fundamentals & Orchestration

TypeScript - Advanced Type Systems, Generics & Design Patterns

Harvard ECON1011 - Intermediate Microeconomics: Game Theory & Market Structures