GitHub Actions with Docker - Step-by-Step Execution

Process Flow - GitHub Actions with Docker

Push code to GitHub

↓

GitHub Actions triggered

↓

Run workflow steps

↓

Build Docker image

↓

Run tests inside Docker container

↓

Push Docker image to registry (optional)

↓

Complete workflow

This flow shows how pushing code triggers GitHub Actions to build and test a Docker image, then optionally push it to a registry.

Execution Sample

Docker

name: Docker CI
on: [push]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Build Docker image
        run: docker build -t myapp:latest .
      - name: Run tests
        run: docker run myapp:latest pytest

This GitHub Actions workflow builds a Docker image and runs tests inside the container on every push.

Process Table

Step	Action	Command Run	Result	Next Step
1	Trigger workflow	Push code to GitHub	Workflow starts	Checkout code
2	Checkout code	actions/checkout@v3	Code available on runner	Build Docker image
3	Build Docker image	docker build -t myapp:latest .	Docker image 'myapp:latest' created	Run tests in container
4	Run tests	docker run myapp:latest pytest	Tests executed, results shown	Workflow complete
5	Complete workflow	N/A	Workflow ends successfully	End

💡 Workflow ends after tests run successfully or fails if any step errors

Status Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
Code	Not checked out	Checked out on runner	Checked out on runner	Checked out on runner	Checked out on runner
Docker Image	Not built	Not built	Built as 'myapp:latest'	Built as 'myapp:latest'	Built as 'myapp:latest'
Test Status	Not run	Not run	Not run	Tests passed or failed	Tests passed or failed

Key Moments - 3 Insights

Why do we need to checkout the code before building the Docker image?

The checkout step downloads the code to the runner so the docker build command can access the Dockerfile and source files. Without it, the build would fail (see execution_table step 2).

What happens if the tests inside the Docker container fail?

If tests fail during the 'docker run' step (step 4), the workflow stops and marks the run as failed. This prevents pushing broken code.

Can the Docker image be pushed to a registry in this workflow?

Yes, but this example does not include that step. You can add a step after tests to push the image if tests pass.

Visual Quiz - 3 Questions

Look at the execution table, what is the result after step 3?

A Code is checked out on the runner

B Docker image 'myapp:latest' is created

C Tests have been executed

D Workflow ends successfully

💡 Hint

Check the 'Result' column for step 3 in the execution_table

At which step does the workflow run tests inside the Docker container?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look for the 'Run tests' action in the execution_table

If the checkout step is removed, what will happen during the Docker build?

A Docker build fails due to missing files

B Docker image builds successfully

C Tests run without errors

D Workflow completes without building

💡 Hint

Refer to key_moments about why checkout is needed before build

Concept Snapshot

GitHub Actions with Docker:
- Trigger on push event
- Checkout code to runner
- Build Docker image with 'docker build'
- Run tests inside container with 'docker run'
- Optionally push image to registry
- Workflow stops if any step fails

Full Transcript

This visual execution shows how GitHub Actions automates Docker workflows. When code is pushed, the workflow starts by checking out the code to the runner. Then it builds a Docker image using the Dockerfile in the repo. After building, it runs tests inside a container created from that image. If tests pass, the workflow completes successfully. If any step fails, the workflow stops and reports failure. This process helps automate testing and deployment using Docker containers in GitHub Actions.

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