In this tutorial, I will walk you through the process of publishing a Docker image to GitHub’s Container Registry using GitHub Actions. By using GitHub Actions, you can automate the build and publish process, making it easier to distribute your Docker images.

Prerequisites

Before getting started, make sure you have the following:

1. A GitHub account.
2. A Dockerfile that describes your application’s dependencies and build instructions.
3. A GitHub repository where you want to publish your Docker image.

Step 1: Set up GitHub Actions workflow

GitHub Actions allow you to automate tasks by creating workflows.

To publish a Docker image, we’ll create a workflow file named publish.yml.

Create a new directory called .github/workflows in the root of your repository, if it doesn’t already exist.

Inside this directory, create a new file named publish.yml and add the following content:

name: Publish Docker Image

on:
  push:
    branches:
      - main

jobs:
  build-and-publish:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Login to GitHub Container Registry
        uses: docker/login-action@v1
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Build and push Docker image
        uses: docker/build-push-action@v2
        with:
          context: .
          push: true
          tags: ghcr.io/${{ github.repository_owner }}/${{ github.repository }}:${{ github.sha }}

This workflow will trigger whenever you push changes to the main branch. It checks out the code, logs in to GitHub’s Container Registry using your GitHub credentials, and builds and pushes the Docker image to the registry.

Step 2: Configure the Dockerfile

In your repository, create a file named Dockerfile and add the necessary instructions to build your Docker image. Here’s an example Dockerfile for a Node.js application:

FROM node:14

WORKDIR /app

COPY package.json package-lock.json ./

RUN npm ci --only=production

COPY app.js .

CMD ["node", "app.js"]

Make sure to modify the Dockerfile to suit your application’s requirements.

Step 3: Push changes to your repository

Commit and push the Dockerfile, publish.yml, and any other files you may have modified to your repository.

Step 4: Monitor the workflow execution

After pushing the changes, navigate to the “Actions” tab in your GitHub repository. You should see the workflow you created (“Publish Docker Image”) listed there. Click on it to monitor the execution.

Step 5: Verify the Docker image in GitHub Container Registry

Once the workflow execution is complete, go to the “Packages” tab in your GitHub repository. You should see your Docker image listed there. Click on it to view the details.

Summary

You have successfully published a Docker image to GitHub’s Container Registry using GitHub Actions. By automating this process, you can easily distribute your Docker images and ensure consistent deployment across different environments. GitHub Actions provides a powerful platform for automating various tasks in your development workflow, saving you time and effort.

Docker has become an essential tool in modern software development, enabling easy and efficient containerisation of applications. GitHub’s Container Registry provides a convenient way to store and manage Docker images within the GitHub ecosystem.

In this tutorial, we will walk through the process of creating, editing, and publishing a Docker image to GitHub’s Container Registry.

Prerequisites

Before we begin, ensure that you have the following:

1. A GitHub account
2. Docker installed on your local machine
3. Basic familiarity with Docker commands

Step 1: Create a Dockerfile

The first step is to create a Dockerfile, which defines the instructions to build your Docker image. Open a text editor and create a new file called Dockerfile. Here’s a basic example:

# Use a base image
FROM ubuntu:latest

# Set the working directory
WORKDIR /app

# Copy files to the container
COPY . /app

# Install dependencies
RUN apt-get update && apt-get install -y <your-package-name>

# Specify the command to run when the container starts
CMD ["<your-command>"]

Customise the FROM line with the base image you want to use and replace <your-package-name> with the required packages for your application. Also, update <your-command> with the command to start your application.

Step 2: Build the Docker Image

Once you have the Dockerfile ready, you can build the Docker image.

Open a terminal or command prompt and navigate to the directory containing the Dockerfile.

Run the following command:

docker build -t <image-name> .

Replace <image-name> with the desired name for your Docker image.

The . at the end specifies the build context, which includes the files needed for building the image.

Wait for the build process to complete.

Docker will execute the instructions in the Dockerfile and generate the image.

Step 3: Tag the Docker Image

To publish the Docker image to GitHub’s Container Registry, you need to tag it accordingly.

Run the following command:

docker tag <image-name> ghcr.io/<username>/<repository>:<tag>

Replace <username> with your GitHub username, <repository> with the name of the repository you want to push the image to, and <tag> with the desired tag (e.g., version number or latest).

Step 4: Log in to GitHub Container Registry

Before you can publish the image, you need to authenticate with GitHub’s Container Registry.

Run the following command:

docker login ghcr.io -u <username>

Replace <username> with your GitHub username. You will be prompted to enter your GitHub password or a personal access token.

Step 5: Publish the Docker Image

Now that you’re logged in, you can publish the Docker image to GitHub’s Container Registry.

Run the following command:

docker push ghcr.io/<username>/<repository>:<tag>

Replace <username>, <repository>, and <tag> with the values you used in Step 3.

Wait for the push process to complete. Once finished, your Docker image will be available in GitHub’s Container Registry, associated with your specified repository.

Step 6: Update and Re-Publish

If you make changes to your Docker image or need to update it with a new version, follow the steps again from Step 2 onwards.

Remember to tag the image with a new version number or an appropriate tag, and push it to GitHub’s Container Registry.