In the fast-paced world of containerization, effectively managing Docker images is crucial for maintaining robust and traceable deployment pipelines. A key aspect of this management is image tagging, which allows for precise identification and version control. This article explores a streamlined approach to automate Docker image tagging using two powerful versioning strategies: Semantic Versioning and Timestamp-based Versioning.

The Significance of Docker Image Tagging

Docker image tags serve as labels that denote specific versions of an image, offering several benefits:

• Traceability: Easily identify which version of an application or service is deployed.
• Immutability: Once an image is tagged, its content typically remains consistent, ensuring reproducible builds.
• Deployment Control: Facilitate rollbacks to previous stable versions and controlled rollouts of new features.

Automating this process removes manual errors and integrates seamlessly into Continuous Integration/Continuous Deployment (CI/CD) workflows.

Semantic Versioning for Docker Images

Semantic Versioning (SemVer) is a widely adopted system that encodes version information using a three-part number: MAJOR.MINOR.PATCH. This scheme provides clear meaning to version changes:

• MAJOR: Incremented for incompatible API changes.
• MINOR: Incremented for adding functionality in a backward-compatible manner.
• PATCH: Incremented for backward-compatible bug fixes.

This method is ideal for applications where version compatibility is critical.

Implementing Semantic Versioning with pyv.py

A simple Python script, pyv.py, can manage your semantic versions, storing the current state in a docker_version.json file.

The core logic handles:

• Initialization: If docker_version.json doesn’t exist, it defaults to 1.0.0.
• Retrieval: Reads the current version.
• Incrementing: Functions to increment major, minor, or patch versions, resetting lower-level versions accordingly.
• Formatting: Presents the version in a concise MAJOR.MINOR.PATCH format, omitting .0 for minor and patch if they are zero (e.g., 1, 1.2).

Here\’s the pyv.py script:

import json
import sys
import os

default_version={"major":1,"minor":0,"patch":0}

VERSION_FILE="docker_version.json"

def get_version():
    if not os.path.exists(VERSION_FILE):
        return default_version
    with open(VERSION_FILE,"r") as f:
        return json.load(f)
def save_version(version):
    with open(VERSION_FILE,"w") as f:
        json.dump(version,f,indent=2)

def format_version(version):
    major=version["major"]
    minor=version["minor"]
    patch=version["patch"]
    if patch==0:
        if minor==0:
            return f"{major}"
        else:
            return f"{major}.{minor}"
    else:
        return f"{major}.{minor}.{patch}"

def show_version():
    v=get_version()
    return format_version(v)

def update_version(version):
    save_version(version)
    return format_version(version)

def increment_major():
    v=get_version()
    v["major"]+=1
    v["minor"]=0
    v["patch"]=0
    return update_version(v)

def increment_minor():
    v=get_version()
    v["minor"]+=1
    v["patch"]=0
    return update_version(v)

def increment_patch():
    v=get_version()
    v["patch"]+=1
    return update_version(v)

if __name__ == '__main__':

    if len(sys.argv)==1:
        print(show_version())
        sys.exit(0)
    if len(sys.argv)>2:
        print("Usage: pyv <major|minor|patch|show>")
        sys.exit(1)

    command=sys.argv[1]

    if command=="major":
        print(increment_major())
    elif command=="minor":
        print(increment_minor())
    elif command=="patch":
        print(increment_patch())
    elif command=="show":
        print(show_version())
    else:
        print("Invalid command. Use major|minor|patch|show as argument.")
        sys.exit(1)

Usage Examples:

To use this script, you can run it with commands like:

python pyv.py show
python pyv.py major
python pyv.py minor
python pyv.py patch

Global Command Setup (Making pyv accessible)

• Linux:
  1. Create an executable script pyv (without .py extension) containing the Python code.
  2. Make it executable: chmod +x pyv
  3. Copy it to a directory in your PATH, e.g., /usr/local/bin/: sudo cp pyv /usr/local/bin/
• Windows (PowerShell):
  1. Create a batch file pyv.bat in the same directory as pyv.py:

     @echo off
     python "%~dp0pyv.py" %*

  2. Add an alias to your PowerShell profile (usually $PROFILE). Open it with notepad $PROFILE and add:
     Set-Alias pyv "C:\path\to\pyv.bat" (Replace with your actual path).
  3. You might need to adjust your execution policy: Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Timestamp-Based Versioning for Docker Images

Timestamp-based versioning provides a unique and chronologically ordered tag for each build. This is particularly useful for continuous deployments where every build needs a distinct, ordered identifier. The format typically includes Year_Month_Day__Hour_Minute_Second (e.g., 2025_10_14__12_00_00).

Implementing Timestamp-Based Tagging

This method typically involves setting up a simple shell alias or function.

• Linux (Bash/Zsh):
  Add the following alias to your shell configuration file (e.g., ~/.bashrc or ~/.zshrc):

  alias dtsv="date +\'%Y_%m_%d__%H_%M_%S\'"

  After editing, source the profile: source ~/.bashrc (or source ~/.zshrc).

• Windows (PowerShell):
  Add this function to your PowerShell profile (notepad $PROFILE):

  function dtsv { Get-Date -Format "yyyy_MM_dd__HH_mm_ss" }

Using Versioning in Docker Commands

Once your versioning scripts/aliases are set up, integrating them into your Docker build and push commands is straightforward:

• Building with Semantic Versioning:

  docker build -t "imagename:$(pyv)" .

• Pushing with Semantic Versioning:

  docker push "username/imagename:$(pyv)"

• Building with Timestamp-Based Versioning:

  docker build -t "imagename:$(dtsv)" .

These commands dynamically fetch the current version from your chosen strategy and apply it as the image tag.

Conclusion

Automating Docker image tagging with either Semantic or Timestamp-based Versioning significantly enhances the reliability and manageability of your containerized applications. Whether you need strict version compatibility or unique, chronological identifiers, these strategies provide the tools to maintain a clean, traceable, and efficient Docker image repository. Incorporate these methods into your development workflow to optimize your CI/CD pipelines and streamline your deployment process.