In a github actions workflow, is there a way to have multiple jobs reuse the same setup?

Question

I recently hooked up my project with github actions for continuous integration. I created two separate jobs: the first one checks if the code in the pull request is accepted by our linter, and the second one checks if the code passes the test suite. I like that having two jobs like this shows up as two separate checkmarks in the Github webpage for the pull request:

The problem I'm having now is that there is some duplicated code in workflow YAML file: the first 3 steps, which install Lua and Luarocks. Not only is it annoying to maintain, but it also wastes CI minutes by running the same actions twice. Is there a way to avoid this? So that the setup code is only written in one place, and only runs once when the workflow executes?

But I am confused what would be the proper way to proceed:

1. Should I create my own Github Action with the shared setup code?
2. Should I create a Docker image that already has Lua and Luarocks pre-installed?
3. Should I use a single job? Can I still have independent checkmarks for the linter and the test suite if they are steps of the same job?
4. Something else?

Here is the current YAML file for my workflow:

name: Github Actions CI

on: [ pull_request ]

jobs:
    lint:
        name: Lint
        runs-on: ubuntu-latest
        steps:
            - uses: actions/checkout@v2
            - uses: leafo/gh-actions-lua@v8.0.0
            - uses: leafo/gh-actions-luarocks@v4.0.0

            - run: luarocks install luacheck
            - run: ./run-linter.sh

    test:
        name: Test
        runs-on: ubuntu-latest
        steps:
            - uses: actions/checkout@v2
            - uses: leafo/gh-actions-lua@v8.0.0
            - uses: leafo/gh-actions-luarocks@v4.0.0

            - run: luarocks install busted
            - run: ./build-project.sh
            - run: ./run-test-suite.sh

I tried searching for similar questions but couldn't find anything that exactly answered my question:

1. Caching APT packages in GitHub Actions workflow: I can't use this solution because I don't have a way to precisely specify all the versions of all the dependencies that I am using, so that they may be cached. I also don't mind if separate runs of the workflow are not cached. I'm more worried about the code duplication.
2. Github actions share workspace/artifacts between jobs? I don't want to have to manage uploading uploading artifacts to a separate service and then deleting them afterwards.
3. Reuse portion of github action across jobs: In that question the only difference between the jobs is a single variable, so accepted answer is to use a build matrix. But I don't think a build matrix would work as well in my case, where only the setup code is the same?

Answer 1

As of today (August 2021) composite action is no longer limited to run. GitHub Actions: Reduce duplication with action composition

name: "Publish to Docker"
description: "Pushes built artifacts to Docker"

inputs:
  registry_username:
    description: “Username for image registry”
    required: true
  registry_password:
    description: “Password for image registry”
    required: true

runs:
  using: "composite"
  steps:
      - uses: docker/setup-buildx-action@v1

      - uses: docker/login-action@v1
        with:
          username: ${{inputs.registry_username}}
          password: ${{inputs.registry_password}}

      - uses: docker/build-push-action@v2
        with:
          context: .
          push: true
          tags: user/app:latest

Old Answer

What you are looking for is composite action which help you reuse once defined set of steps.

jobs:
    lint:
        name: Lint
        runs-on: ubuntu-latest
        steps:
            - uses: octocat/say-hello@v1

            - run: luarocks install luacheck
            - run: ./run-linter.sh

    test:
        name: Test
        runs-on: ubuntu-latest
        steps:
            - uses: octocat/say-hello@v1

            - run: luarocks install busted
            - run: ./build-project.sh
            - run: ./run-test-suite.sh

octocat/say-hello/action.yml:

runs:
  using: "composite"
  steps: 
    - run: echo "Nice to meet you!"
      shell: pwsh

For more details you can also check's ADR here.

And why you can't simply run it once for all jobs, because each job may run on a different machine.

A job is a set of steps that execute on the same runner. By default, a workflow with multiple jobs will run those jobs in parallel. You can also configure a workflow to run jobs sequentially. For example, a workflow can have two sequential jobs that build and test code, where the test job is dependent on the status of the build job. If the build job fails, the test job will not run.

Answer 2

There are 3 main approaches for code reusing in GitHub Actions:

• Reusable Workflows
• Dispatched workflows
• Composite Actions

There is an article describing their pros and cons.

In your case if the duplicated steps are in the single workflow you also can:

1. extract them to the "preparation" job
2. upload build artifacts
3. add "preparation" job to "needs" key of both jobs
4. download build artifact in both jobs

Answer 3

The below code snippet should do the work for you. Instead of creating two jobs, one for lint and another for test, you can use one job and create multiple tasks

name: Github Actions CI

on: [ pull_request ]

jobs:
    lint:
        name: Lint and Test
        runs-on: ubuntu-latest
        steps:
            - uses: actions/checkout@v2
            - uses: leafo/gh-actions-lua@v8.0.0
            - uses: leafo/gh-actions-luarocks@v4.0.0

            - name: Install Luacheck
              run: luarocks install luacheck

            - name: Run Lint Check
            - run: ./run-linter.sh

            - name: Install Busted
              run: luarocks install busted

            - name: Build Project
              run: ./build-project.sh

            - name: Run Test Suite
            - run: ./run-test-suite.sh