Container State Persistence

📦 Container State Persistence: Saving Your Work Forever

The Story: Your Magic Sandbox

Imagine you’re playing in a magic sandbox. You build an amazing sandcastle with towers, moats, and flags. But oh no! When you leave the playground, all your work disappears!

What if you could:

1. Take a photo of your sandcastle (so you can rebuild it exactly the same way)
2. Pack it in a box and take it home
3. Unpack it at your friend’s playground

That’s exactly what Container State Persistence does in Docker! Let’s learn the three magic spells to save your container work forever.

🎯 The Three Magic Spells

1. 📸 Committing Container Changes

What Is It?

Committing is like taking a photograph of your sandcastle. It captures everything exactly as it is right now and saves it as a new image.

Why Do We Need It?

When you work inside a container:

• You install new software
• You create files
• You change settings

But containers are temporary! When they stop, changes might disappear. Commit saves those changes forever.

The Magic Words

docker commit my-container my-new-image

graph TD
    A["🏃 Running Container"] --> B["📸 docker commit"]
    B --> C["💾 New Image Created"]
    C --> D["🚀 Can create new containers"]

Real Example: Installing a Game

Let’s say you have a container and you install a game inside it:

# Start a container
docker run -it --name sandbox ubuntu

# Inside container: install cowsay
apt update
apt install cowsay -y

# Exit container
exit

Now save your work:

docker commit sandbox sandbox-with-cowsay

Result: You now have a new image called sandbox-with-cowsay that includes the game!

🧪 Quick Check

Before commit:

docker images
# Shows: ubuntu

After commit:

docker images
# Shows: ubuntu, sandbox-with-cowsay

2. 📦 Exporting Containers

What Is It?

Exporting is like putting your entire sandcastle into a cardboard box. You can carry this box anywhere!

The box is called a tar file (like a zip file).

Why Do We Need It?

Sometimes you want to:

• Share your container with a friend
• Move it to another computer
• Back it up for safety

The Magic Words

docker export my-container > mybox.tar

Or the fancy way:

docker export -o mybox.tar my-container

graph TD
    A["🏃 Container"] --> B["📦 docker export"]
    B --> C["📁 mybox.tar file"]
    C --> D["💾 Save anywhere!"]
    C --> E["📧 Send to friends!"]
    C --> F["☁️ Upload to cloud!"]

Real Example: Boxing Your Work

# Create and customize a container
docker run -it --name mywork ubuntu
# ... do some work inside ...
exit

# Export to a tar file
docker export mywork > mywork-backup.tar

# Check the file
ls -lh mywork-backup.tar
# Shows: mywork-backup.tar (about 70MB)

📸 vs 📦: Commit vs Export

3. 📥 Importing Containers

What Is It?

Importing is like opening the cardboard box and rebuilding your sandcastle at a new playground!

You take a tar file and turn it back into a Docker image.

Why Do We Need It?

When someone sends you an exported container, you need to import it before you can use it.

The Magic Words

docker import mybox.tar mynew-image

Or from a URL:

docker import http://example.com/box.tar remote-image

graph TD
    A["📁 mybox.tar"] --> B["📥 docker import"]
    B --> C["💾 New Image"]
    C --> D["🚀 docker run mynew-image"]
    D --> E["🏃 Container Running!"]

Real Example: Unpacking Your Friend’s Work

Your friend sends you awesome-app.tar. Here’s how to use it:

# Import the tar file as an image
docker import awesome-app.tar friends-app

# Check it worked
docker images
# Shows: friends-app

# Run a container from it
docker run -it friends-app /bin/bash

Adding Extra Info While Importing

You can add helpful notes:

docker import \
  -c 'CMD ["/bin/bash"]' \
  -m "Imported from friend" \
  awesome-app.tar \
  friends-app:v1

This sets:

• -c: Default command to run
• -m: A message describing what this is

🎮 The Complete Journey

Let’s see all three spells working together:

graph TD
    A["🆕 Start Fresh Container"] --> B["🛠️ Make Changes Inside"]
    B --> C{What do you want?}
    C -->|Keep as Image| D["📸 docker commit"]
    C -->|Share as File| E["📦 docker export"]
    D --> F["💾 New Docker Image"]
    E --> G["📁 .tar File"]
    G --> H["📧 Send to Friend"]
    H --> I["📥 docker import"]
    I --> J[💾 Friend's New Image]
    J --> K["🚀 Friend Runs Container"]

🎯 Quick Command Summary

💡 Pro Tips

1. Name Your Images Well

# Good names
docker commit mycontainer webapp:v2
docker import backup.tar project:latest

# Not so good
docker commit mycontainer abc123

2. Check Before You Commit

# See what changed in your container
docker diff mycontainer

This shows:

• A = Added files
• C = Changed files
• D = Deleted files

3. Compress Your Exports

# Export and compress at once
docker export mycontainer | gzip > backup.tar.gz

# Import compressed file
gunzip -c backup.tar.gz | docker import - myimage

🚨 Common Mistakes to Avoid

Mistake 1: Forgetting the Container Name

# ❌ Wrong - no container name
docker commit

# ✅ Right - include container name
docker commit mycontainer myimage

Mistake 2: Export vs Save Confusion

# docker export = for containers (no history)
docker export container > file.tar

# docker save = for images (keeps history)
docker save image > file.tar

Mistake 3: Forgetting to Run After Import

# Import creates an IMAGE, not a running container
docker import file.tar myimage

# You still need to RUN it
docker run -it myimage /bin/bash

🎉 You Did It!

Now you know the three magic spells:

1. 📸 Commit - Take a snapshot, make a new image
2. 📦 Export - Pack it up, take it anywhere
3. 📥 Import - Unpack and use it

Your container work will never disappear again! Just like saving your video game progress, you can now save, share, and restore your Docker containers whenever you want.

Remember: Containers are like sandcastles that wash away. But with these spells, you can save them forever! 🏰✨