Buildah Build is a GitHub Action for building Docker and Kubernetes-compatible images quickly and easily.

Buildah only works on Linux. GitHub's Ubuntu Environments (ubuntu-18.04 and newer) come with buildah installed. If you are not using these environments, or if you want to use a different version, you must first install buildah.

After building your image, use push-to-registry to push the image and make it pullable.

image: The name of the built image.
For example, spring-image.

tags: A list of the tags that were created, separated by spaces.
For example, latest ${{ github.sha }}.

You can configure the buildah action to build your image using one or more Dockerfiles, or none at all.

If you have been building your images with an existing Dockerfile, buildah can reuse your Dockerfile.

In this case the inputs needed are image and dockerfiles. tag is also recommended. If your Dockerfile requires ARGs, these can be passed using build-arg.

name: Build Image using Dockerfile
on: [push]

jobs:
  build:
    name: Build image
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2

    - name: Buildah Action
      uses: redhat-actions/buildah-build@v2
      with:
        image: my-new-image
        tags: v1 ${{ github.sha }}
        dockerfiles: |
          ./Dockerfile
        build-args: |
          some_arg=some_value

Building without a Dockerfile requires additional inputs, that would normally be specified in the Dockerfile.

Do not set dockerfiles if you are doing a build from scratch. Otherwise those Dockerfiles will be used, and the inputs below will be ignored.

• An output image name and usually a tag.
• base-image
  • In a Dockerfile, this would be the FROM directive.
• content to copy into the new image
  • In a Dockerfile, this would be COPY directives.
• entrypoint so the container knows what command to run.
  • In a Dockerfile, this would be the ENTRYPOINT.
• All other optional configuration inputs, such as port, envs, and workdir.

Example of building a Spring Boot Java app image:

name: Build Image
on: [push]

jobs:
  build-image:
    name: Build image without Dockerfile
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2

    - run: mvn package

    - name: Build Image
      uses: redhat-actions/buildah-build@v2
      with:
        base-image: docker.io/fabric8/java-alpine-openjdk11-jre
        image: my-new-image
        tags: v1
        content: |
          target/spring-petclinic-2.3.0.BUILD-SNAPSHOT.jar
        entrypoint: java -jar spring-petclinic-2.3.0.BUILD-SNAPSHOT.jar
        port: 8080

Refer to the multi-arch example.

Cross-architecture builds from dockerfiles containing RUN instructions require qemu-user-static emulation registered in the Linux kernel.

For example, run sudo apt install qemu-user-static on Debian hosts, or sudo dnf install qemu-user-static on Fedora.

You can run a containerized version of the registration if the package does not exist for your distribution:

sudo podman run --rm --privileged docker.io/tonistiigi/binfmt --install all

This registration remains active until the host reboots.

The arch argument overrides the Architecture label in the output image. It does not actually affect the architectures the output image will run on. The image must still be built for the required architecture.

There is a simple example in this issue.

Use the buildah manifest command to bundle images into an image list, so multiple image can be referenced by the same repository tag.

There are examples and explanations of the manifest command in this issue.

This action does not support the manifest command at this time, but there is an issue open.

If your build references a private image, run podman-login in a step before this action so you can pull the image. For example:

- name: Log in to Red Hat Registry
  uses: redhat-actions/podman-login@v1
  with:
    registry: registry.redhat.io
    username: ${{ secrets.REGISTRY_REDHAT_IO_USER }}
    password: ${{ secrets.REGISTRY_REDHAT_IO_PASSWORD }}