Multi-container Pods concept in Kubernetes - Step-by-Step Execution

Process Flow - Multi-container Pods concept

Pod Created

↓

Multiple Containers Defined

↓

Containers Share Pod Resources

↓

Containers Communicate via localhost

↓

Containers Start Together

↓

Pod Runs as Single Unit

This flow shows how a Pod is created with multiple containers that share resources and communicate locally, running together as one unit.

Execution Sample

Kubernetes

apiVersion: v1
kind: Pod
metadata:
  name: multi-container-pod
spec:
  containers:
  - name: app
    image: nginx
  - name: sidecar
    image: busybox
    command: ['sh', '-c', 'echo Hello from sidecar && sleep 3600']

This YAML defines a Pod with two containers: an nginx app and a sidecar container that prints a message and sleeps.

Process Table

Step	Action	Pod State	Container States	Notes
1	Pod manifest applied	Pod created	Containers: Pending	Kubernetes accepts Pod definition
2	Scheduler assigns Pod to node	Pod scheduled	Containers: Pending	Pod assigned to a worker node
3	Kubelet starts containers	Pod running	app: Running, sidecar: Running	Both containers start simultaneously
4	Containers share localhost network	Pod running	app: Running, sidecar: Running	Containers can communicate via localhost
5	Sidecar executes command	Pod running	app: Running, sidecar: Running	Sidecar prints message and sleeps
6	Pod continues running	Pod running	app: Running, sidecar: Running	Pod runs as a single unit with both containers

💡 Pod runs continuously until deleted or stopped; containers run together sharing resources.

Status Tracker

Variable	Start	After Step 3	After Step 5	Final
Pod State	Not created	Running	Running	Running
app Container	Not started	Running	Running	Running
sidecar Container	Not started	Running	Sleeping after echo	Sleeping

Key Moments - 3 Insights

Why do both containers start at the same time inside the Pod?

Because the Pod is the smallest deployable unit in Kubernetes, all containers defined in it start together as shown in execution_table step 3.

How do containers inside the Pod communicate with each other?

They share the same localhost network namespace, so they can communicate via localhost as shown in execution_table step 4.

What happens if one container in the Pod stops?

The Pod is considered unhealthy or failed; Kubernetes may restart the Pod depending on its restart policy, since containers run as a single unit.

Visual Quiz - 3 Questions

Look at the execution table, at which step do both containers start running?

A Step 2

B Step 5

C Step 3

D Step 1

💡 Hint

Check the 'Container States' column in execution_table row for Step 3.

According to variable_tracker, what is the state of the sidecar container after Step 5?

A Not started

B Sleeping

C Running

D Terminated

💡 Hint

Look at the 'sidecar Container' row under 'After Step 5' in variable_tracker.

If the Pod had only one container, how would the execution table change?

A Only one container state would be shown as running

B There would be no container states listed

C Containers would start at different steps

D Pod would not be scheduled

💡 Hint

Refer to the 'Container States' column in execution_table and consider how many containers are defined.

Concept Snapshot

Multi-container Pods run multiple containers together in one Pod.
Containers share network and storage resources.
They start and stop as a single unit.
Containers communicate via localhost inside the Pod.
Useful for sidecar patterns and helper containers.

Full Transcript

A Kubernetes Pod can have multiple containers running together. When you create a Pod with multiple containers, Kubernetes schedules the Pod as one unit. Both containers start at the same time and share the same network and storage resources. They can talk to each other using localhost because they share the same network namespace. For example, a Pod might have an nginx container and a sidecar container that logs or modifies data. The Pod runs continuously until it is deleted or stopped. If one container stops, the Pod is affected as a whole. This concept helps run related containers together efficiently.