Container Management

🏠 Container Lifecycle: Managing Your Little Houses

Imagine Kubernetes containers are like little houses in a neighborhood. Each house has rules about what happens when things go wrong, how to say goodbye properly, and how to welcome guests!

🔁 Container Restart Policies

The “What If My House Falls Down?” Rule

Think of restart policies like instructions for a magical builder. If your toy house falls over, what should happen?

Three Types of Rules:

apiVersion: v1
kind: Pod
metadata:
  name: my-app
spec:
  restartPolicy: Always
  containers:
  - name: web
    image: nginx

🎯 Simple Analogy:

• Always = Your mom always picks up your toys after you
• OnFailure = Mom only helps if you dropped something by accident
• Never = You clean up your own mess!

🪝 Container Lifecycle Hooks

Special Moments: “Hello!” and “Goodbye!”

Lifecycle hooks are like special moments when you can do something important:

Two Magic Moments:

graph TD
    A["Container Starting"] -->|postStart| B["Say Hello!"]
    B --> C["Container Running"]
    C -->|preStop| D["Say Goodbye!"]
    D --> E["Container Stops"]

1️⃣ PostStart Hook - “Welcome to the Party!”

Runs right after your container starts. Like ringing a doorbell to say “I’m here!”

lifecycle:
  postStart:
    exec:
      command:
      - /bin/sh
      - -c
      - echo "Hello, I'm ready!"

2️⃣ PreStop Hook - “Let Me Clean Up First!”

Runs before your container stops. Like saying goodbye and putting away your toys.

lifecycle:
  preStop:
    exec:
      command:
      - /bin/sh
      - -c
      - nginx -s quit

🎯 Real Life Example:

• PostStart: A restaurant server clocks in and sets up their station
• PreStop: The server finishes serving current customers before leaving

🤝 Graceful Shutdown

“Please Wait, I’m Not Done Yet!”

Imagine you’re playing with friends and mom says “Time to go home!” A graceful shutdown means:

1. 📢 Warning: “We’re leaving in 5 minutes!”
2. ⏳ Wait: Finish your current game
3. 👋 Leave: Say goodbye properly

graph TD
    A["SIGTERM Signal"] -->|Grace Period| B["Finish Current Work"]
    B --> C["Save Everything"]
    C --> D["Clean Shutdown"]
    D --> E["Container Stops"]
    A -->|Timeout!| F["SIGKILL - Forced Stop"]

How Kubernetes Does It:

spec:
  terminationGracePeriodSeconds: 30
  containers:
  - name: my-app
    image: myapp:v1

What happens:

1. Kubernetes sends a polite message (SIGTERM)
2. Your app has 30 seconds to finish
3. If still running → forced stop (SIGKILL)

🎯 Why It Matters: Without graceful shutdown, it’s like unplugging a video game without saving. You lose everything!

⛔ Container Termination

“Game Over - What Happens Next?”

When a container stops, Kubernetes keeps a record. Like a report card!

graph TD
    A["Container Ends"] --> B{Exit Code?}
    B -->|0| C["✅ Success!"]
    B -->|Non-zero| D["❌ Something Failed"]
    D --> E["Check terminationMessagePath"]
    C --> E
    E --> F["Save Final Message"]

Exit Codes - The Score Card:

Termination Message:

spec:
  containers:
  - name: my-app
    terminationMessagePath: /dev/termination-log
    terminationMessagePolicy: File

🎯 Simple Explanation: Your container writes a goodbye note explaining why it stopped. Kubernetes reads this note and tells you!

🚪 Container Ports Config

“Which Door Should Visitors Use?”

Ports are like doors to your house. Each door has a number so visitors know where to go!

graph TD
    A["Outside World"] -->|Port 80| B["Container Door"]
    B --> C["Your App Inside"]
    C -->|Talks on| D["containerPort: 8080"]

Port Configuration:

containers:
- name: web-server
  image: nginx
  ports:
  - name: http
    containerPort: 8080
    protocol: TCP
  - name: https
    containerPort: 443
    protocol: TCP

Port Properties:

🎯 Fun Analogy:

• Port 80 = Front door (HTTP)
• Port 443 = Secure door with a lock (HTTPS)
• Port 22 = Secret back door (SSH)

⚠️ Important Rule: Two apps can’t use the same door at the same time! Just like two people can’t stand in the same doorway.

📦 Image Management

“Choosing the Right Toy Box”

Container images are like instruction books + toy boxes. They have everything needed to build your app!

graph TD
    A["Image Registry"] -->|Pull| B["Download Image"]
    B --> C["Create Container"]
    C --> D["Run Your App!"]

Image Pull Policies:

containers:
- name: my-app
  image: myapp:v2.1.0
  imagePullPolicy: IfNotPresent

Image Names Explained:

registry.io/team/app:v1.0.0
    │        │    │    │
    │        │    │    └─ Tag (version)
    │        │    └────── Image name
    │        └─────────── Namespace/user
    └──────────────────── Registry location

Private Images (Secret Toys):

spec:
  imagePullSecrets:
  - name: my-registry-secret
  containers:
  - name: private-app
    image: private.io/myapp:v1

🎯 Best Practices:

1. Use specific tags: myapp:v1.2.3 not myapp:latest
2. Like: Use “Chapter 5” not “the latest chapter” - you know exactly what you’re getting!

🎓 Quick Summary

graph TD
    A["Container Lifecycle"] --> B["Restart Policies"]
    A --> C["Lifecycle Hooks"]
    A --> D["Graceful Shutdown"]
    A --> E["Termination"]
    A --> F["Ports Config"]
    A --> G["Image Management"]

    B --> B1["Always/OnFailure/Never"]
    C --> C1["postStart/preStop"]
    D --> D1["SIGTERM → Wait → SIGKILL"]
    E --> E1["Exit Codes & Messages"]
    F --> F1["containerPort/protocol"]
    G --> G1["Pull Policies & Tags"]

🌟 You Did It!

Now you understand how Kubernetes takes care of containers like a good neighborhood manager:

• ✅ Restart Policies = Rules for rebuilding houses
• ✅ Lifecycle Hooks = Hello and goodbye ceremonies
• ✅ Graceful Shutdown = Polite way to close up shop
• ✅ Termination = Report cards when containers stop
• ✅ Ports = Doors for visitors
• ✅ Images = Instruction books and toy boxes

You’re now a Container Lifecycle Master! 🎉