3 ways to speed up CI [GitHub Actions] that you can do immediately!

For those who are frustrated by slow CI execution.

Here are three ways to speed up CI execution with GitHub Actions.

Three ways to speed up CI [GitHub Actions].

The following three methods are introduced in this article.

• Split the Job
• Adding package cache processing
• Split tests and run them in parallel

Split a Job

Jobs can be split so that each job runs in parallel.

For example, the execution of a unit test and the execution of a Linter can often run independently.

It would be more efficient to describe them in separate Jobs, rather than in series in a single Job.

jobs:.
  test:.
    runs-on: ubuntu-22.04
    steps:.
    ...

  lint: ...
    runs-on: ubuntu-22.04
    steps: ...
    ...

Add package caching process.

Packages are recommended to be cached to skip the time-consuming package installation process.

Use the official actions/cache to implement the cache process.

In the following cases, npm ci will only be executed if there is a change in the OS, Node version or the file that manages package information (package-lock.json), otherwise the cache will be used.

- name: cache and restore packages
  id: cache-npm
  uses: actions/cache@v4.0.2
  with: node_modules
    path: node_modules
    key: ${{ runner.os }}-${{ steps.tool_versions.outputs.nodejs }}-${{ hashFiles(‘**/package-lock.json’) }}

- name: install npm packages
  if: steps.cache-npm.outputs.cache-hit ! = ‘true’
  run: npm ci
  shell: bash

Split and run tests in parallel

If your tests take a long time to run, you can speed up the process by dividing the tests and running each one in parallel.

For example, in the case of Jest, you can use the matrix strategy and the command option --shard. The matrix strategy is a simple and easy way to split up tests and run them in parallel.

The matrix strategy is a method to run a Job for each value defined in a variable within a single Job, and --shard is an option to split tests.

Using these, you can define a workflow like the following.

jobs:
  test:
    runs-on: ubuntu-22.04
    strategy:
      matrix:
        shard: [1/4, 2/4, 3/4, 4/4]
    steps:
      - name: checkout
        uses: actions/checkout@v3

      - name: setup environment
        uses: ./.github/actions/setup

      - name: run test
        run: npx jest --ci --shard=${{ matrix.shard }}

This will run 4 Jobs in parallel, each running a quarter of the tests.

I don't know if there are other options like --shard besides Jest, but the idea itself can be applied to any language.

There are other ways.

The following three methods were introduced as easy ways to improve the speed of CI.

• Split the Job
• Add package cache processing
• Split tests and run them in parallel

However, in addition to these, you can also use larger runner and running tests only in areas where changes have been made, there are many other ways to improve speed.

It is recommended to improve the speed little by little to the extent possible, recognising the time and financial resources available.