GitHub Actions with Docker - Commands & Configuration

Introduction

Building and testing Docker containers automatically can be slow and error-prone if done manually. GitHub Actions lets you automate these steps so your Docker images are built and tested every time you update your code.

When you want to build a Docker image automatically after pushing code to GitHub.

When you want to run tests inside a Docker container on every code change.

When you want to push your Docker image to a registry like Docker Hub after a successful build.

When you want to ensure your Docker container works before deploying it.

When you want to save time by automating repetitive Docker build and test steps.

Config File - docker-image.yml

docker-image.yml

name: Build and Push Docker Image

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout repository
        uses: actions/checkout@v3

      - name: Log in to Docker Hub
        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Build Docker image
        run: docker build -t dockerhub-user/my-app:latest .

      - name: Push Docker image
        run: docker push dockerhub-user/my-app:latest

      - name: Run container to test
        run: |
          docker run --rm dockerhub-user/my-app:latest echo "Container runs successfully"

This GitHub Actions workflow file automates building and pushing a Docker image.

• on.push.branches: Runs the workflow when code is pushed to the main branch.
• jobs.build.runs-on: Uses an Ubuntu machine to run the steps.
• actions/checkout@v3: Gets your code from GitHub.
• docker/login-action@v2: Logs into Docker Hub using stored secrets.
• docker build: Builds the Docker image with a tag.
• docker push: Uploads the image to Docker Hub.
• docker run: Runs the image to check it works.

Commands

Builds a Docker image from the current folder and tags it as dockerhub-user/my-app:latest.

Terminal

docker build -t dockerhub-user/my-app:latest .

Expected Output

Sending build context to Docker daemon  8.192kB

Step 1/5 : FROM alpine:3.18

 ---> a24bb4013296

Step 2/5 : COPY . /app

 ---> Using cache

 ---> 3c1a2f4b5d6e

Step 3/5 : WORKDIR /app

 ---> Using cache

 ---> 7b9e8f1a2c3d

Step 4/5 : RUN echo "Hello from Docker"

 ---> Running in 1a2b3c4d5e6f

Hello from Docker

Removing intermediate container 1a2b3c4d5e6f

 ---> 9f8e7d6c5b4a

Step 5/5 : CMD ["echo", "Container runs successfully"]

 ---> Running in 7f6e5d4c3b2a

Removing intermediate container 7f6e5d4c3b2a

 ---> 2a3b4c5d6e7f

Successfully built 2a3b4c5d6e7f

Successfully tagged dockerhub-user/my-app:latest

→

-t - Tags the image with a name and version

Uploads the built Docker image to Docker Hub so others can download it.

Terminal

docker push dockerhub-user/my-app:latest

Expected Output

The push refers to repository [docker.io/dockerhub-user/my-app]

123456789abc: Pushed

latest: digest: sha256:abcdef1234567890 size: 1234

Runs the Docker image to check it works and prints a success message, then removes the container.

Terminal

docker run --rm dockerhub-user/my-app:latest echo "Container runs successfully"

Expected Output

Container runs successfully

→

--rm - Removes the container after it finishes running

Key Concept

If you remember nothing else from this pattern, remember: GitHub Actions can automatically build, test, and push your Docker images every time you update your code.

Common Mistakes

Not setting Docker Hub credentials in GitHub secrets and trying to push the image.

Without credentials, Docker cannot log in and push the image, causing the workflow to fail.

Store your Docker Hub username and access token in GitHub secrets and reference them in the workflow.

Forgetting to tag the Docker image before pushing.

Docker push requires a tagged image; without a tag, it won't know what to upload.

Use the -t flag with docker build to tag the image properly.

Running docker run without --rm flag during tests.

Containers remain after running, cluttering the system with stopped containers.

Add --rm to remove the container automatically after the test run.

Summary

Create a GitHub Actions workflow file to automate Docker image build and push.

Use docker build with a tag to create the image from your code.

Push the tagged image to Docker Hub using docker push.

Run the image with docker run to verify it works before deployment.

Practice

1. What is the main purpose of using GitHub Actions with Docker in a project?

easy

A. To automate building and testing Docker images on code changes

B. To manually run Docker commands on your local machine

C. To replace Docker with a different container tool

D. To write Dockerfiles without using any commands

Solution

1. Step 1: Understand GitHub Actions role

   GitHub Actions automates tasks like building and testing when code changes happen.

2. Step 2: Connect automation with Docker

   Using GitHub Actions with Docker means automating Docker image builds and tests on events like pushes.

3. Final Answer:

   To automate building and testing Docker images on code changes -> Option A

4. Quick Check:

   Automation with Docker = D [OK]

Hint: GitHub Actions automate tasks triggered by code events [OK]

Common Mistakes:

• Thinking GitHub Actions replace Docker itself
• Confusing manual commands with automation
• Assuming Dockerfiles are written by GitHub Actions

2. Which of the following is the correct syntax to build a Docker image inside a GitHub Actions workflow step?

easy

A. run: docker start -t myimage .

B. run: docker create myimage .

C. run: docker push -t myimage .

D. run: docker build -t myimage .

Solution

1. Step 1: Recall Docker build command

   The command to build an image is 'docker build' with '-t' to tag the image.

2. Step 2: Match with GitHub Actions step syntax

   In GitHub Actions, 'run:' is used to run shell commands, so 'run: docker build -t myimage .' is correct.

3. Final Answer:

   run: docker build -t myimage . -> Option D

4. Quick Check:

   Build image command = C [OK]

Hint: Use 'docker build -t name .' to build images [OK]

Common Mistakes:

• Using 'docker create' instead of 'docker build'
• Confusing 'docker start' with building images
• Using 'docker push' to build images

3. Given this GitHub Actions workflow step:

run: |
  docker build -t test-image .
  docker run --rm test-image echo Hello

What will be the output when this step runs successfully?

medium

A. test-image

B. Hello

C. docker build completed

D. Error: image not found

Solution

1. Step 1: Understand the commands run

   The first command builds an image tagged 'test-image'. The second runs a container from it that prints 'Hello'.

2. Step 2: Identify the output of the run command

   The 'docker run' command runs 'echo Hello' inside the container, so the output is 'Hello'.

3. Final Answer:

   Hello -> Option B

4. Quick Check:

   docker run echo output = Hello [OK]

Hint: Run command output is what container prints [OK]

Common Mistakes:

• Thinking build command outputs 'test-image'
• Expecting build success message as output
• Assuming image not found error without build

4. You have this GitHub Actions step:

run: docker build -t myapp .
run: docker run myapp

The workflow fails with 'Error: Dockerfile not found'. What is the likely cause?

medium

A. The Dockerfile is missing in the repository

B. The two 'run' commands are separate steps and do not share state

C. The image name 'myapp' is invalid

D. The 'docker run' command syntax is incorrect

Solution

1. Step 1: Understand docker build requirement

   The 'docker build .' command requires a Dockerfile in the current directory (repo root after checkout).

2. Step 2: Identify the error cause

   If the Dockerfile is missing from the repository, the build step fails with 'Dockerfile not found' error.

3. Final Answer:

   The Dockerfile is missing in the repository -> Option A

4. Quick Check:

   docker build fails = no Dockerfile [OK]

Hint: Ensure Dockerfile exists in repository root [OK]

Common Mistakes:

• Thinking separate steps prevent image sharing
• Assuming image name 'myapp' is invalid
• Believing 'docker run' syntax causes the error

5. You want to create a GitHub Actions workflow that builds a Docker image only when a push happens to the 'main' branch and then pushes the image to Docker Hub. Which of these YAML snippets correctly sets the trigger and steps?

hard

A. on:
push:
tags:
- main
jobs:
build:
runs-on: ubuntu-latest
steps:
- run: docker build -t myuser/myapp .
- run: docker push myuser/myapp

B. on:
pull_request:
branches:
- main
jobs:
build:
runs-on: ubuntu-latest
steps:
- run: docker build -t myapp .
- run: docker push myapp

C. on:
push:
branches:
- main
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- run: docker build -t myuser/myapp:latest .
- run: echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
- run: docker push myuser/myapp:latest

D. on:
push:
branches:
- develop
jobs:
build:
runs-on: ubuntu-latest
steps:
- run: docker build -t myuser/myapp .
- run: docker push myuser/myapp

Solution

1. Step 1: Check trigger event and branch

   on: push: branches: - main jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - run: docker build -t myuser/myapp:latest . - run: echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin - run: docker push myuser/myapp:latest triggers on push to 'main' branch, which matches the requirement.

2. Step 2: Verify build and push steps

   on: push: branches: - main jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - run: docker build -t myuser/myapp:latest . - run: echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin - run: docker push myuser/myapp:latest includes checkout, build with proper tagging, login using secrets, and push commands correctly.

3. Final Answer:

   The snippet that triggers on push to main, checks out code, logs in with secrets, builds tagged image, and pushes -> Option C

4. Quick Check:

   Push on main + login + build + push = A [OK]

Hint: Use 'on: push: branches: - main' and login before push [OK]

Common Mistakes:

• Using pull_request instead of push event
• Triggering on tags instead of branches
• Pushing without Docker login step