Image tags and versioning in Docker - Step-by-Step Execution

Process Flow - Image tags and versioning

Start with base image

↓

Build image locally

↓

Tag image with version or tag

↓

Push image to registry

↓

Pull image using tag

↓

Run container from tagged image

↓

Update image -> new tag

↓

Repeat push and pull with new tag

This flow shows how Docker images are built, tagged with versions, pushed to a registry, and pulled for use. Tagging helps track different versions.

Execution Sample

Docker

docker build -t myapp:1.0 .
docker push myapp:1.0
docker pull myapp:1.0
docker run myapp:1.0

Builds an image tagged '1.0', pushes it, pulls it, and runs a container from it.

Process Table

Step	Command	Action	Image Tag	Result
1	docker build -t myapp:1.0 .	Build image locally	myapp:1.0	Image created with tag 1.0
2	docker push myapp:1.0	Push image to registry	myapp:1.0	Image myapp:1.0 uploaded
3	docker pull myapp:1.0	Pull image from registry	myapp:1.0	Image myapp:1.0 downloaded
4	docker run myapp:1.0	Run container from image	myapp:1.0	Container started from myapp:1.0
5	docker build -t myapp:2.0 .	Build updated image	myapp:2.0	Image created with tag 2.0
6	docker push myapp:2.0	Push updated image	myapp:2.0	Image myapp:2.0 uploaded
7	docker pull myapp:2.0	Pull updated image	myapp:2.0	Image myapp:2.0 downloaded
8	docker run myapp:2.0	Run container from updated image	myapp:2.0	Container started from myapp:2.0
9				Execution stops after running updated image

💡 No more commands; images built, tagged, pushed, pulled, and run with versions 1.0 and 2.0

Status Tracker

Variable	Start	After Step 1	After Step 5	Final
Image Tags	none	myapp:1.0	myapp:1.0, myapp:2.0	myapp:1.0, myapp:2.0
Registry State	empty	myapp:1.0 uploaded	myapp:1.0, myapp:2.0 uploaded	myapp:1.0, myapp:2.0 uploaded
Local Images	empty	myapp:1.0 present	myapp:1.0, myapp:2.0 present	myapp:1.0, myapp:2.0 present
Running Containers	none	running from myapp:1.0	running from myapp:1.0 and myapp:2.0	running from myapp:1.0 and myapp:2.0

Key Moments - 3 Insights

Why do we need to tag images with versions like '1.0' or '2.0'?

Tagging images lets us keep track of different versions. Without tags, Docker uses 'latest' by default, which can cause confusion about which version is running. See execution_table steps 1 and 5 where different tags are created.

What happens if we push an image without a tag?

Docker assigns the 'latest' tag automatically. This can overwrite previous 'latest' images and cause unexpected updates. In our example, explicit tags avoid this problem (execution_table steps 2 and 6).

Can we run a container from an image tag that does not exist locally?

Yes, Docker will try to pull the image from the registry first. In step 3 and 7, pulling happens before running to ensure the image is available.

Visual Quiz - 3 Questions

Look at the execution table at step 4. What image tag is used to run the container?

A myapp:1.0

B myapp:2.0

C latest

D myapp:latest

💡 Hint

Check the 'Image Tag' column at step 4 in the execution_table.

At which step is the updated image with tag '2.0' first created?

A Step 2

B Step 6

C Step 5

D Step 8

💡 Hint

Look for 'Build updated image' action in the execution_table.

If we skip tagging the image during build, what tag will Docker assign by default?

A none

B latest

C 1.0

D default

💡 Hint

Refer to key_moments about default tags when no tag is specified.

Concept Snapshot

Docker images are tagged to identify versions.
Use 'docker build -t name:tag .' to create tagged images.
Push images with 'docker push name:tag' to share.
Pull images with 'docker pull name:tag' before running.
Tags prevent confusion and allow version control.
'latest' is default tag if none specified.

Full Transcript

This lesson shows how Docker images are built, tagged with versions like '1.0' or '2.0', pushed to a registry, pulled back, and run as containers. Tagging images helps track different versions and avoid confusion. The execution table traces commands step-by-step: building images with tags, pushing them to a registry, pulling them, and running containers from those tags. Variables track image tags, registry state, local images, and running containers. Key moments clarify why tagging is important, what happens if no tag is given, and how Docker pulls images if not found locally. The quiz tests understanding of tags used at each step and default behaviors. The snapshot summarizes the key commands and concepts for quick reference.