Kaushik's Notes

dockerPublish

6 min read

Docker - Publish

Publish Docker Image to Docker Hub

  • Docker Hub is the official cloud service for storing and sharing Docker images. We call these kinds of services “registries”. Other popular image registries include:
    • AWS Elastic Container Registry (ECR)
    • Google Container Registry (GCR)
    • Azure Container Registry (ACR)
    • GitHub Container Registry (GHCR)
    • Harbor

Steps to Publish a Docker Image to Docker Hub

  1. Rebuild the Go Web Server:

    • Ensure your Go server is compiled for the correct OS and architecture using the following command:
    GOOS=linux GOARCH=amd64 go build

  2. Rebuild the Docker Image:

    • Use the following command to build the Docker image, replacing USERNAME with your Docker Hub username:
    docker build . -t USERNAME/goserver
    • This command builds the image and tags it with the name USERNAME/goserver to match your Docker Hub repository namespace.

  3. Test the Docker Image:

    • Before pushing to Docker Hub, test the image locally:
    docker run -p 8080:8080 USERNAME/goserver
    • Make sure it runs correctly by accessing it at http://localhost:8080.

  4. Login to Docker Hub:

    • If you are not logged in yet, authenticate yourself with Docker Hub:
    docker login

  5. Push the Docker Image to Docker Hub:

    • Push the image to your Docker Hub repository:
    docker push USERNAME/goserver

  6. Verify the Image:

    • Go to your Docker Hub account and check the “Repositories” section to verify that your new image goserver has been successfully uploaded.

Key Points

  • Namespace: The image must be tagged with your Docker Hub username to push it to your account.
  • Testing: Always test your image locally before pushing it to Docker Hub.
  • Image Accessibility: Once pushed, anyone with Docker can pull and run your image using docker pull USERNAME/goserver.

Deleting and Pulling a Docker Image

  1. Remove Local Docker Image:

    • Use the following command to delete your local copy of the Docker image:
    docker image rm USERNAME/goserver
    • This will remove the image USERNAME/goserver from your local machine.

  2. Pull the Image from Docker Hub:

    • To pull the image back from Docker Hub, use the command:
    docker pull USERNAME/goserver
    • This fetches the image goserver from your Docker Hub repository.

  3. Run the Image:

    • After pulling it, run the image again to make sure it works correctly:
    docker run -p 8080:8080 USERNAME/goserver

  4. Run Tests:

    • Make sure to run any tests you have against the image to confirm it hasn’t been modified. Ensure that the content being served (e.g., HTML body) is the same as before.

Key Points

  • Safety in the Cloud: Docker Hub allows you to store your images remotely, making it easy to retrieve them from any machine or after accidental deletions.
  • Consistency: The image pulled from Docker Hub should match the original, ensuring the application behaves identically during testing.

Tag and Push a Specific Version

  • To tag a specific version of your image, use the following command:

    docker tag USERNAME/goserver USERNAME/goserver:v1.0
    docker build . -t USERNAME/goserver:v1.0
    • This tags the image USERNAME/goserver with version v1.0.

  • To push the tagged version to Docker Hub, use the command:

    docker push USERNAME/goserver:v1.0

Tagging Docker Images with “Latest”

  1. Understanding the “Latest” Tag:

    • The latest tag in Docker is simply the default tag used when no other tag is specified. It doesn’t necessarily mean the “most recent” version of the image, which can sometimes lead to confusion.
    • You can explicitly tag images with version numbers to avoid ambiguity and maintain proper version control.

  2. Semantic Versioning:

    • A common practice is to use semantic versioning (e.g., 1.0.0, 2.1.0) to tag Docker images. This allows you to track different versions over time.
    • Despite using semantic versions, it’s common to also push an image to the latest tag so that it always points to the most up-to-date version.

  3. Building and Tagging for Multiple Versions:

    • You can tag an image with both a specific version and the latest tag simultaneously during the build process:

      docker build -t username/imagename:0.0.0 -t username/imagename:latest .

    • This ensures that version 0.0.0 and latest both refer to the same image, allowing flexibility for users who either want a specific version or the most current image.

  4. Pushing Multiple Tags to Docker Hub:

    • After building, you can push all the tags of the image at once using the --all-tags option:

      docker push username/imagename --all-tags

  5. Conclusion:

    • It’s best practice to tag all your images with version numbers and to reserve the latest tag for the most recent stable release.
    • This makes it easier to manage and pull specific versions while also ensuring users can always access the most recent version via the latest tag.

The Bigger Picture: Docker in the Software Development Lifecycle

  1. Overview of the Deployment Process:

    • Code Development: Developers write and test new code.
    • Version Control: Code is committed to a version control system like Git.
    • Branching: Developers create a new branch on platforms like GitHub for their changes.
    • Pull Requests: After writing the code, developers open a pull request (PR) for review.
    • Peer Review: Teammates review the PR, provide feedback, and approve it if everything looks good.
    • Merging: The approved PR is merged into the main branch, integrating the new code.
    • Automated Build Process: Upon merging, an automated script (e.g., GitHub Actions) is triggered to handle the next steps:
      • Code Compilation: If the code is in a compiled language, the script compiles it.
      • Docker Image Creation: A new Docker image is built using the latest code.
      • Image Pushing: The new image is pushed to a container registry (e.g., Docker Hub).
    • Deployment to Production:
      • Update Notification: The server running containers (e.g., a Kubernetes cluster) is notified of the new version.
      • Image Pulling: The Kubernetes cluster pulls the latest Docker image.
      • Container Management: The cluster manages the deployment by shutting down old containers and spinning up new ones with the latest image.

  2. Variability in Processes:

    • While the outlined process is common in modern, cloud-native companies, variations exist across different organizations.
    • Some organizations might use:
      • Different Version Control Systems: Such as GitLab instead of GitHub.
      • Alternative Container Registries: Like Amazon Elastic Container Registry (ECR) instead of Docker Hub.
      • Different Container Orchestration Tools: Such as Docker Swarm or other managed services instead of Kubernetes.

  3. Importance of Docker in the Process:

    • Consistency: Docker provides a consistent environment across development, testing, and production, reducing “it works on my machine” issues.
    • Scalability: Containers can be easily scaled up or down based on demand, which is essential in cloud environments.
    • Isolation: Each application runs in its container, isolating it from others, which enhances security and stability.

  4. Conclusion:

    • Understanding how Docker fits into the software development lifecycle is crucial for modern developers, particularly in DevOps environments.
    • Being adaptable to various tools and processes is key, as each organization may have its unique workflows while leveraging the power of containers.

Graph View

Backlinks