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.

In this guide, I’ll walk you through the process of setting up Hugo with a Docker Drone.io container and GitHub, allowing you to streamline your website deployment workflow.

Prerequisites

Before getting started, make sure you have the following prerequisites in place:

• Docker installed:
  • Ensure you have Docker installed on your local machine.
• Basic knowledge of Docker:
  • Familiarity with Docker and Docker Compose will be helpful.
• A working Hugo website:
  • Set up a Hugo website locally.
• A GitHub repository:
  • Host your Hugo website’s code in a GitHub repository.

Step 1: Set Up a Docker Drone.io Container

1. Create a new directory on your machine for the Docker Drone.io container configuration.
2. Create a docker-compose.yml file within that directory and add the following content:

version: '3'
services:
  drone-server:
    image: drone/drone:latest
    ports:
      - "8080:80"
    volumes:
      - ./drone-data:/data
    restart: always
    environment:
      - DRONE_GITHUB_CLIENT_ID=your-github-client-id
      - DRONE_GITHUB_CLIENT_SECRET=your-github-client-secret

  drone-runner:
    image: drone/drone-runner-docker:latest
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    restart: always

3. Save the file and navigate to the Docker Drone.io container configuration directory in your terminal.

4. Replace your-github-client-id and your-github-client-secret with the appropriate values. These can be obtained by registering a new OAuth application within GitHub’s settings.

5. Run the command docker-compose up -d to start the Docker Drone.io container.

Drone.io should now be accessible at http://localhost:8080.

Step 2: Connect Drone.io to GitHub

1. Open Drone.io in your web browser at http://localhost:8080.
2. Sign in with your GitHub credentials.
3. Authorise Drone.io to access your GitHub repositories.

Step 3: Configure the Drone.io Pipeline

1. Within your Hugo website’s GitHub repository, create a .drone.yml file in the root directory.
2. Add the following code to the .drone.yml file:

kind: pipeline
name: your-pipeline-name

steps:
  - name: Clone Git Submodules
    image: alpine/git
    commands:
      - git submodule init
      - git submodule update --recursive --remote
      
  - name: Build with Hugo
    image: binaryronin/drone-hugo:latest
    pull: always
    commands:
      - echo "Checking Hugo version."
      - hugo version
      - cd /drone/src/hugo/
      - hugo --verbose 
      - ls -al /drone/src/hugo/public 

  - name: Deploy
    image: appleboy/drone-scp
    settings:
      host: your-remote-host
      username: your-remote-username
      password:
        from_secret: your-remote-password-secret
      source: 
        - /hugo/public/
      target: /path/to/your/remote/directory

Replace your-pipeline-name with a suitable name for your pipeline.

3. Adjust the host, username, password, and target fields to match your remote server details and deployment directory.

4. Add a secret for your remote server’s password by going to your Drone.io repository settings and adding a secret with the key your-remote-password-secret and the corresponding value.

Step 4: Trigger the Pipeline

1. Push your updated .drone.yml file to your GitHub repository.
2. This will trigger the Drone.io pipeline to run.
3. Monitor the build process in the Drone.io interface to ensure everything is working correctly.
4. Once the pipeline completes successfully, your Hugo website will be deployed to the specified remote server.

You have successfully set up Hugo with a Docker Drone.io container and GitHub. Now, whenever you push changes to your GitHub repository, Drone.io will automatically build your Hugo website and deploy it to your remote server.

I’ll continue documenting my journey with Gitea, Drone and Hugo and share the interesting things I find along the way.

If you want to look further in to any of the above tools, do take a look at my previous posts and read the official documentation from the following sites:

Gitea Drone Hugo