Lesson 5: Working with Pods

In this lesson, we will explore how to create, manage, and scale pods within a Kubernetes cluster. Pods are the smallest deployable units in Kubernetes and can hold one or more containers.

What is a Pod?

A Pod is a logical host for one or more containers, which share the same network namespace, IP address, and storage. Pods are designed to run a single instance of a given application.

Key Features of Pods:

• Shared Networking: All containers in a Pod share the same IP address and port space.
• Shared Storage: Containers can share storage volumes, allowing data persistence and sharing.
• Lifecycle Management: Kubernetes manages the lifecycle of Pods, including deployment and scaling.

Creating a Pod

You can create a Pod using a YAML configuration file or directly via kubectl commands.

Example: Creating a Pod using YAML

Create a file named my-pod.yaml with the following content:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: nginx
    ports:
    - containerPort: 80

To create the Pod, run the following command:

kubectl apply -f my-pod.yaml

Verify the Pod Creation

To check if the Pod is running, use:

kubectl get pods

Managing Pods

Managing Pods involves operations like viewing logs, deleting, and updating Pods.

Viewing Logs

You can view the logs of a specific container in a Pod:

kubectl logs my-pod -c my-container

Deleting a Pod

To delete a Pod, use:

kubectl delete pod my-pod

Scaling Pods

Kubernetes allows you to scale Pods easily using Deployments.

Example: Scaling with Deployments

Create a file named my-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-container
        image: nginx
        ports:
        - containerPort: 80

To create the Deployment, run:

kubectl apply -f my-deployment.yaml

Scaling the Deployment

To scale the number of replicas:

kubectl scale deployment my-deployment --replicas=5

Best Practices

Note: Always use Deployments for managing Pods instead of creating Pods directly. This allows for easier scaling and updates.

Common Mistake: Not specifying resource limits for containers can lead to resource exhaustion on nodes.

Summary

• Pods are the smallest deployable units in Kubernetes.
• You can create Pods using YAML files or kubectl commands.
• Managing Pods includes viewing logs and deleting them.
• Scaling Pods is best done using Deployments.
• Follow best practices for resource management and organization.

Exercise 1: Create a Pod

1. Create a YAML file named test-pod.yaml that defines a Pod running an httpd container.
2. Apply the configuration using kubectl apply -f test-pod.yaml.

Exercise 2: View and Delete a Pod

1. Use kubectl get pods to list all Pods.
2. Use kubectl logs <pod-name> to view the logs of your created Pod.
3. Delete the Pod using kubectl delete pod <pod-name>.

Exercise 3: Scale a Deployment

1. Create a Deployment YAML file named test-deployment.yaml with 2 replicas of an nginx container.
2. Apply the configuration and then scale it to 4 replicas using kubectl scale deployment <deployment-name> --replicas=4.

• Pods are the basic units of deployment in Kubernetes.
• Pods can be created and managed using YAML files and kubectl commands.
• Scaling is best handled through Deployments.
• Always follow best practices to ensure efficient resource management.