Kubernetes - Container Orchestration & Microservices Flashcards

Question 1

What is Kubernetes?

Accepted Answer

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, ensuring high availability and efficient resource utilization.

Question 2

What is a Kubernetes Pod?

Accepted Answer

The smallest deployable unit in Kubernetes, representing 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.
```yaml
apiVersion: v1
kind: Pod
metadata:
  name: my-nginx-pod
spec:
  containers:
  - name: nginx
    image: nginx:latest
    ports:
    - containerPort: 80
```

Question 3

What is a Kubernetes ReplicaSet?

Accepted Answer

A controller that ensures a specified number of Pod replicas are running at any given time. It maintains the desired state of Pods by creating or deleting them as needed. ReplicaSets are typically managed by Deployments, which provide higher-level declarative updates.
```yaml
apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: my-app-replicaset
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-container
        image: my-image:latest
```

Question 4

What is a Kubernetes Deployment?

Accepted Answer

A higher-level abstraction that manages ReplicaSets and provides declarative updates to Pods and ReplicaSets. Deployments enable rolling updates, rollbacks, and scaling of applications. It's the recommended way to manage stateless applications.
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-container
        image: my-image:v1.0
        ports:
        - containerPort: 80
```

Question 5

What is a Kubernetes Service and why is it needed?

Accepted Answer

An abstract way to expose an application running on a set of Pods as a network service. Services provide a stable IP address and DNS name for Pods, which are ephemeral and can be created/destroyed dynamically. This allows other applications to reliably communicate with your Pods, abstracting away their changing IPs.

Question 6

Explain the Kubernetes `ClusterIP` Service type.

Accepted Answer

Exposes the Service on an internal IP address within the cluster. This type makes the Service only reachable from within the cluster. It's the default Service type and is ideal for internal communication between microservices.
```yaml
apiVersion: v1
kind: Service
metadata:
  name: my-internal-service
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: ClusterIP
```

Question 7

Explain the Kubernetes `NodePort` Service type.

Accepted Answer

Exposes the Service on each Node's IP at a static port (the `NodePort`). A `ClusterIP` Service is automatically created, and the `NodePort` routes to it. This makes the Service accessible from outside the cluster using `:`. Useful for development or when an external load balancer isn't available. ```yaml apiVersion: v1 kind: Service metadata: name: my-nodeport-service spec: selector: app: my-app ports: - protocol: TCP port: 80 targetPort: 8080 nodePort: 30000 # Optional, Kubernetes assigns if omitted type: NodePort ```

Question 8

Explain the Kubernetes `LoadBalancer` Service type.

Accepted Answer

Exposes the Service externally using a cloud provider's load balancer. This type automatically provisions an external load balancer (e.g., AWS ELB, GCP Load Balancer) that routes traffic to your Nodes and Pods. It's suitable for exposing public-facing applications and requires a cloud provider integration.
```yaml
apiVersion: v1
kind: Service
metadata:
  name: my-public-service
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer
```

Question 9

What is a Kubernetes Namespace?

Accepted Answer

A way to divide cluster resources among multiple users or teams. Namespaces provide a scope for names (e.g., Pods, Services) and are used for resource isolation, access control, and organizing resources within a single cluster.
*   `kubectl create namespace dev`
*   `kubectl get pods -n dev`
*   `kubectl config set-context --current --namespace=dev`

Question 10

What is a Kubernetes ConfigMap?

Accepted Answer

An API object used to store non-confidential data in key-value pairs. ConfigMaps allow you to decouple configuration artifacts from image content, making applications more portable. They can be consumed by Pods as environment variables, command-line arguments, or files in a volume.
```yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  database_url: "jdbc:mysql://db-service:3306/mydb"
  log_level: "INFO"
```
To use in a Pod:
```yaml
# ...
spec:
  containers:
  - name: my-container
    image: my-image
    envFrom:
    - configMapRef:
        name: app-config
```

Question 11

What is a Kubernetes Secret?

Accepted Answer

An API object used to store sensitive information, such as passwords, OAuth tokens, and SSH keys. Secrets are similar to ConfigMaps but are designed for confidential data. They are base64 encoded by default (not encrypted at rest without additional configuration) and can be consumed by Pods as environment variables or mounted as files.
```yaml
apiVersion: v1
kind: Secret
metadata:
  name: my-db-secret
type: Opaque
data:
  username: YWRtaW4= # base64 encoded "admin"
  password: c2VjcmV0cGFzc3dvcmQ= # base64 encoded "secretpassword"
```
To use in a Pod:
```yaml
# ...
spec:
  containers:
  - name: my-container
    image: my-image
    env:
    - name: DB_USERNAME
      valueFrom:
        secretKeyRef:
          name: my-db-secret
          key: username
```

Question 12

What is a Kubernetes Volume?

Accepted Answer

A directory, accessible to the containers in a Pod, that persists data beyond the lifecycle of a single container. Volumes are specified in the Pod's `.spec.volumes` field and mounted into containers at specific paths. They solve the problem of data loss when containers restart or crash.
*   **`emptyDir`**: Ephemeral, for temporary data, lasts as long as the Pod.
*   **`hostPath`**: Mounts a file or directory from the host node's filesystem (use with caution).
*   **`persistentVolumeClaim`**: For durable storage, abstracts underlying storage details.

Question 13

Explain Kubernetes PersistentVolumes (PVs) and PersistentVolumeClaims (PVCs).

Accepted Answer

*   **PersistentVolume (PV)**: A piece of storage in the cluster that has been provisioned by an administrator or dynamically provisioned. It's a resource in the cluster, independent of any single Pod, representing actual storage capacity.
*   **PersistentVolumeClaim (PVC)**: A request for storage by a user. It's a claim for a PV resource, specifying desired size and access modes. Pods consume PVCs, and PVCs consume PVs, decoupling storage provisioning from storage consumption.
```yaml
# PVC Example
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
```

Question 14

What is Kubernetes Ingress?

Accepted Answer

An API object that manages external access to services in a cluster, typically HTTP and HTTPS. Ingress provides HTTP and HTTPS routing to Services based on hostnames or URL paths, acting as an entry point for external traffic. It requires an Ingress Controller (e.g., NGINX, Traefik) to be running in the cluster to fulfill the Ingress rules.
```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
spec:
  rules:
  - host: myapp.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: my-app-service
            port:
              number: 80
```

Question 15

What is a Kubernetes StatefulSet?

Accepted Answer

A workload API object used to manage stateful applications. It provides guarantees about the ordering and uniqueness of Pods, stable network identities, and stable, persistent storage. StatefulSets are ideal for databases, message queues, and other applications that require stable identifiers and persistent storage across Pod restarts.
```yaml
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: web
spec:
  serviceName: "nginx"
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: k8s.gcr.io/nginx-slim:0.8
        ports:
        - containerPort: 80
          name: web
        volumeMounts:
        - name: www
          mountPath: /usr/share/nginx/html
  volumeClaimTemplates:
  - metadata:
      name: www
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi
```

Question 16

List common `kubectl` commands for basic operations.

Accepted Answer

* `kubectl apply -f `: Creates or updates resources defined in a YAML file. * `kubectl get `: Lists resources (e.g., `kubectl get pods`, `kubectl get deployments`). * `kubectl describe `: Shows detailed information about a specific resource. * `kubectl delete `: Deletes a resource. * `kubectl delete -f `: Deletes resources defined in a YAML file.

Question 17

How do you view logs and execute commands in a Pod using `kubectl`?

Accepted Answer

* **View logs**: `kubectl logs [-c ]` * Example: `kubectl logs my-app-pod-abcde` * Example for specific container: `kubectl logs my-app-pod-abcde -c my-sidecar-container` * **Execute commands**: `kubectl exec -it [-c ] -- ` * Example to open a shell: `kubectl exec -it my-app-pod-abcde -- bash` * Example to run a single command: `kubectl exec my-app-pod-abcde -- ls /app`

Question 18

How do you scale a Deployment using `kubectl`?

Accepted Answer

Use the `kubectl scale` command to adjust the number of replicas for a Deployment. * `kubectl scale deployment --replicas=` * Example: `kubectl scale deployment my-app-deployment --replicas=5`

Question 19

How does Kubernetes support microservices architectures?

Accepted Answer

Kubernetes provides key features essential for microservices:
*   **Containerization**: Encapsulates services into isolated units.
*   **Service Discovery**: Services provide stable endpoints for ephemeral Pods.
*   **Load Balancing**: Distributes traffic across multiple service instances.
*   **Scaling**: Automatically scales services based on demand.
*   **Resilience**: Restarts failed containers/Pods, ensures desired state.
*   **Configuration Management**: ConfigMaps and Secrets for externalized configuration.

Question 20

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

Accepted Answer

The front-end for the Kubernetes control plane. It exposes the Kubernetes API, which is used by all other control plane components and external users (via `kubectl`). It processes REST requests, validates them, and updates the state of API objects in `etcd`, serving as the central management point.

Question 21

What is the role of the `kube-scheduler` in Kubernetes?

Accepted Answer

Watches for newly created Pods with no assigned Node and selects a Node for them to run on. The scheduler considers various factors like resource requirements, hardware/software/policy constraints, affinity/anti-affinity specifications, and data locality to make optimal placement decisions.

Question 22

What is the role of the `kube-controller-manager` in Kubernetes?

Accepted Answer

Runs controller processes that regulate the state of the cluster. Each controller (e.g., Node Controller, Replication Controller, Endpoints Controller, Service Account Controller) tries to move the current state closer to the desired state specified in the API objects.

Question 23

What is the role of the `cloud-controller-manager` in Kubernetes?

Accepted Answer

Embeds cloud-specific control logic. It allows you to link your cluster into your cloud provider's API, separating cloud-specific components from those that interact only with the cluster. For example, it handles creating load balancers, persistent volumes, and node lifecycle management in a cloud environment.

Question 24

What is the role of the `kubelet` in Kubernetes?

Accepted Answer

An agent that runs on each Node in the cluster. It ensures that containers are running in a Pod. The `kubelet` takes a set of PodSpecs (provided via the API server or other mechanisms) and ensures that the described containers are running and healthy on its Node.

Question 25

What is the role of the `kube-proxy` in Kubernetes?

Accepted Answer

A network proxy that runs on each Node in the cluster. It maintains network rules on Nodes, allowing 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, implementing various proxy modes (e.g., iptables, IPVS).

Kubernetes - Container Orchestration & Microservices

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