These days, optimising workflows and automating processes is key to efficient software development and infrastructure management.

In my previous posts I covered how to configure Drone to build Hugo and deploy to various destinations, such as an FTP / Web server or Cloudflare Pages.

As I’ve been using and learning more about Hugo, I noticed that the Docker Image I was using to build my Hugo files in Drone was quite out of date and wouldn’t let me use some of the latest features available. After a brief search on the web, I couldn’t find a more recent version.

So, with a couple of spare hours on a Saturday morning, I did some research and looked in to building my own Docker Image and have it published to GitHub’s Container Registry.

And we now have the andrewbeaton/hugo-drone Docker image.

What is it?

andrewbeaton/hugo-drone is a Docker image specifically designed to facilitate Hugo site builds and deployments.

Built upon the popular Drone CI/CD platform, this image contains a preconfigured environment with Hugo and other necessary dependencies, aiming to streamline the setup process and ensuring consistency across different development environments.

The image is based on RockyLinux and installs the current version of Hugo, which is currently v0.113.0.

My aim is to build and release a new versioned image, for each major release that comes along.

Step 1: Installing Docker

Before we can use andrewbeaton/hugo-drone, we need to have Docker installed on our system. Docker allows us to run containers, which are lightweight, isolated environments that encapsulate our applications and their dependencies. Follow these instructions to install Docker on your operating system.

Step 2: Pulling the Image

Once Docker is installed, we can pull the andrewbeaton/hugo-drone image from the GitHub Images Repository.

Open your terminal or command prompt and enter the following command:

docker pull ghcr.io/andrewbeaton/hugo-drone:latest

This command will fetch the latest version of the image and make it available on your system for usage.

Step 3: Creating a Hugo Project

To work with andrewbeaton/hugo-drone, you need to have an existing Hugo project or create a new one.

If you haven’t set up a Hugo project yet, follow these steps:

1. Install Hugo:
   Visit the official Hugo website and download the appropriate binary for your operating system. Follow the installation instructions provided.

2. Create a New Hugo Site:
   In your terminal or command prompt, navigate to your desired project directory and run the following command:

   hugo new site my-hugo-site
   

   This command will create a new Hugo site with the name “my-hugo-site” in the current directory.

3. Add a Theme:
   Navigate to your Hugo site’s directory and add a theme of your choice. You can explore various themes on the Hugo Themes website or use a specific theme by following its documentation.

Step 4: Setting Up a Drone Configuration File

Drone relies on a configuration file named .drone.yml to define the build pipeline.

Create a new file named .drone.yml in the root of your Hugo project and add the following content as a starting point:

kind: pipeline
type: docker
name: default

steps:
  - name: Build with Hugo
    image: ghcr.io/andrewbeaton/hugo-drone:latest
    pull: always
    commands:
      - echo "Checking Hugo version."
      - hugo version
      - cd /drone/src/hugo/
      - hugo --environment production --verbose --debug 
      - ls -al /drone/src/hugo/public

This configuration instructs Drone to use the andrewbeaton/hugo-drone image and execute the hugo command for production to build your Hugo site. I like to enable verbose and debug output to help with problem-solving, and I also output the current version of Hugo with each build.

Step 5: Building and Deploying with Drone

Now that everything is set up, you can build and deploy your Hugo site with Drone.

Commit and push the changes you made to your .drone.yml file. The Drone pipeline will automatically trigger, building your Hugo site.

Take a look at some of my other posts for examples on how to deploy to a web server or Cloudflare Pages.

Summary

The andrewbeaton/hugo-drone Docker image simplifies the process of building Hugo sites by providing a preconfigured environment. By following the steps outlined in this blog post, you can use this image to automate your Hugo builds, saving time and effort in the development and deployment process.

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.

Ackee is a self-hosted, open-source, privacy focused, analytics platform that provides useful insights into your website’s traffic.

By running Ackee in a Docker container, you can easily deploy and manage it on your own server.

In this guide, I’ll talk you through the process of creating an Ackee Docker container and setting it up using Docker Compose.

Prerequisites

Before you start, ensure you have the following:

• Docker installed on your server.

• Docker Compose installed on your server.

• Basic knowledge of working with Docker and Docker Compose.

Create a Docker Compose File

Open your text editor and create a new file named docker-compose.yml.

In this file, we define the configuration for the Ackee Docker container.

Define the Docker Compose Configuration

Copy and paste the following configuration into your docker-compose.yml file:

version: '3'
services:
  ackee:
    image: electerious/ackee
    container_name: ackee
    restart: always
    ports:
      - "3000:3000"
    environment:
      - WAIT_HOSTS=mongodb:27017
      - DATABASE_URI=mongodb://mongo:27017/ackee
    depends_on:
      - mongo
  mongo:
    image: mongo
    container_name: mongo
    restart: always
    ports:
      - '27017:27017'
    volumes:
      - ackee-mongo:/data/db
volumes:
  ackee-mongo:

This configuration defines two services: ackee and mongo.

The ackee service uses the electerious/ackee Docker image, exposes port 3000, sets the DATABASE_URI environment variable to connect to the MongoDB instance, and depends on the mongo service.

The mongo service uses the mongo Docker image and mounts a volume to persist MongoDB data.

Save the Docker Compose File

Save the docker-compose.yml file in your desired directory on your server. Make sure you remember the location as we’ll use it in the next step.

Start the Ackee Docker Container

Open a terminal or command prompt and navigate to the directory where you saved the docker-compose.yml file.

Run the following command to start the Ackee Docker container:

docker-compose up -d

Docker Compose will download the necessary Docker images and start the Ackee and MongoDB containers in detached mode.

Access Ackee in your Web Browser

Open your web browser and enter the following URL:

http://localhost:3000

You should now see the Ackee login page.

Create a new user account and log in to the Ackee dashboard.

You have now successfully created an Ackee Docker container and set it up using Docker Compose. You can now start analyzing your website’s traffic using Ackee’s powerful analytics features.

Additional Configuration Options

If you want to use a different port for Ackee, you can modify the ports section in the docker-compose.yml file:

ports:
    - "3000:3000"

To allow your domains to connect to Ackee, you can set the ACKEE_ALLOW_ORIGIN environment variable and list your domains:

ACKEE_ALLOW_ORIGIN=https://domain1.com,https://domain2.com

You can specify your username and password in the docker-compose.yml file with the environment variables:

- ACKEE_USERNAME=username
- ACKEE_PASSWORD=password 

Remember to regularly update the docker-compose.yml file to use the latest version of Ackee and MongoDB images to benefit from the latest features and security patches.

Summary

With Docker Compose, managing your Ackee deployment becomes seamless, allowing you to focus on gaining valuable insights from your website’s analytics data.

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:

Ackee
Docker Docker Compose

In this guide, I’ll walk you through the process of setting up Hugo with a local Drone.io instance and a local Gitea server, allowing you to automate your website deployment workflow in a self-hosted environment.

I used this setup initially, before changing the Drone deployment to upload through FTP to my local staging web server. If you’re interested in this setup, you can find the details in the guide Deploy to an FTP server with Drone.

Note

The instructions below cover the setup and running of the Docker instances locally. If you are setting this up in your home lab, then just change the references from local to the details of your servers.

Prerequisites

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

• Docker installed:
  • Make sure you have Docker installed on your local machine or remote server.
• Basic knowledge of Docker:
  • Familiarity with Docker and Docker Compose will be helpful.
• A working Hugo website:
  • Set up a Hugo website locally.

Step 1: Set up Gitea

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

version: '3'
services:
  gitea:
    image: gitea/gitea:latest
    ports:
      - "3000:3000"
      - "2222:22"
    volumes:
      - ./gitea-data:/data
    restart: always

3. Save the file and navigate to the Gitea Docker configuration directory in your terminal.
4. Run the command docker-compose up -d to start the Gitea container.

Gitea should now be accessible at http://localhost:3000. Follow the on-screen instructions to set up an admin account and create a new repository for your Hugo website.

Step 2: Set up Drone.io

1. Create a new directory on your machine for the Drone.io Docker 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_GITEA_SERVER=http://gitea:3000
      - DRONE_GITEA_CLIENT_ID=your-gitea-client-id
      - DRONE_GITEA_CLIENT_SECRET=your-gitea-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 Drone.io Docker configuration directory in your terminal.

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

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

Drone.io should now be accessible at http://localhost:8080. Sign in with your Gitea credentials and authorise Drone.io to access your Gitea repositories.

Step 3: Configure the Drone.io Pipeline

1. Within your Hugo website’s 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

  - name: deploy
    image: appleboy/drone-scp
    settings:
      host: your-remote-host
      username: your-remote-username
      password: your-remote-password
      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.

Step 4: Trigger the Pipeline

1. Push your updated .drone.yml file to your Gitea 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 local Drone.io instance and a local Gitea server. Now, whenever you push changes to your Gitea 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

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