Speed Up Your Build with caching in Github Action.
Table of contents
Save between 10% and 90% of your build time!
As a DevOps professional, automation is a daily essential—but optimizing our workflow time is always challenging. Reducing the duration of testing, building, and deployment processes can be a nightmare. In this article, we'll show you how caching in GitHub Actions can transform your pipelines and dramatically speed up your builds.
Why Use Caching?
Caching prevents repetitive work by reusing previously built layers or dependencies. This means:
Faster Builds: Significant time savings.
Lower Resource Usage: Less CPU and bandwidth consumption.
Enhanced Productivity: Quicker development and deployment cycles.
To illustrate the impact of caching, we use a Django application. To highlight the time gap, we add the heavy library scikit-learn to our requirements.txt:
asgiref
Django
sqlparse
scikit-learn # Heavy library to observe the time difference
Workflow with Cache
```yaml name: Install dependencies witht cache run-name: Install dependencies with cache
on: [push, pull_request]
jobs: build: runs-on: ubuntu-latest steps:
name: Checkout uses: actions/checkout@v4
name: Setup Buildx uses: docker/setup-buildx-action@v2 with: driver: docker-container
name: Restore Cache uses: actions/cache@v3 id: docker-cache with: path: .cache/docker key: docker-cache-${{ github.sha }} restore-keys: | docker-cache-
name: Build Image uses: docker/build-push-action@v4 with: context: tp_cache file: tp_cache/Dockerfile target: with_cache tags: image-with-cache cache-from: type=local,src=.cache/docker cache-to: type=local,mode=max,dest=.cache/docker ```
Workflow Without Cache
```yaml name: Install dependencies without pip cache run-name: Install dependencies without pip cache
on: [push, pull_request]
jobs: install-dependencies: runs-on: ubuntu-latest steps:
- name: Checkout repository uses: actions/checkout@v4
- name: Build Image uses: docker/build-push-action@v4 with: context: tp_cache file: tp_cache/Dockerfile target: without_cache tags: image-without-cache ```
Case 1: Django Application – Installing Dependencies via a Virtual Environment
The Dockerfile
We use the python:3.12-slim image (Debian-based) to create the virtual environment, install pip libraries, and run the server:
FROM python:3.12-slim AS compile-image
RUN apt-get update
RUN apt-get install -y --no-install-recommends build-essential gcc
RUN python -m venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"
COPY requirements.txt .
RUN pip install -r requirements.txt
FROM python:3.12-slim AS with_cache
COPY --from=compile-image /opt/venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"
EXPOSE 8000
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]
FROM python:3.12-slim AS without_cache
COPY --from=compile-image /opt/venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"
EXPOSE 8000
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]
Result:
Using cache saves about 10% of the build time.
Case 2: Building a Pip Library from Source on Alpine
In this scenario, we test building a pip library from source (tar.gz) using Alpine as the build environment. By default, Alpine compiles Python packages from source, which is usually slower.
The requirements.txt, workflows remains the same:
The Dockerfile
We use the python:3.12-alpine image (Alpine-based) to create the virtual environment, install pip libraries:
FROM python:3.13.2-alpine3.21 AS compile-image
RUN apk update && apk add --no-cache \
build-base \
gcc \
g++ \
python3-dev \
py3-pip
WORKDIR /app
RUN python -m venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"
COPY requirements.txt .
RUN pip install -r requirements.txt
FROM python:3.12-slim AS with_cache
COPY --from=compile-image /opt/venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"
EXPOSE 8000
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]
FROM python:3.12-slim AS without_cache
COPY --from=compile-image /opt/venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"
EXPOSE 8000
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]
Result:
In this case, caching can save up to 80% of the build time, as reusing precompiled layers eliminates the heavy source compilation on Alpine.
Conclusion
Using caching in GitHub Actions offers significant benefits:
Time Savings: Reduce build times by 10% to 90% depending on the scenario.
Resource Optimization: Lower CPU and bandwidth usage by avoiding repetitive compilations or installations.
Enhanced Productivity: Faster workflows mean quicker development and deployment cycles.
By smartly integrating caching into your pipelines, you not only accelerate your builds but also streamline your entire CI/CD process. Are you ready to supercharge your GitHub Actions builds?
Feel free to share your feedback and any tips you have on optimizing workflows further!👍