alpine-php

The image is tagged respectively for the following architectures,

• aarch64

• armhf

• armv7l

• x86_64

latest tag is annotated as multiarch so pulling without any tags should fetch the correct image for your architecture. Same goes for any of the version tags.

non-x86_64 builds have embedded binfmt_misc support and contain the qemu-user-static binary that allows for running it also inside an x86_64 environment that has support for it.

If you want to run images for other architectures on a x86_64 machine, you will need to have binfmt support configured for your machine before running the image. multiarch, has made it easy for us containing that into a docker container, just run

docker run --rm --privileged multiarch/qemu-user-static --reset -p yes

Now images built for other architectures will also be executable. This is optional though, without the above, you can still run the image that is made for your architecture.

You can check your own UID/GID by running the command id in a terminal.

Did you know, we could check what any make target is going to execute before we actually run them, with

make -n <targetname> <optional args>

All images have a few common build parameters that can be customized at build time, like

• ARCH

The target architecture to build for. Defaults to host architecture, auto-detected at build-time if not specified. Also determines if binfmt support is required before build or run and runs the regbinfmt target automatically. Possible values are aarch64, armhf, armv7l, and x86_64.

• BUILDDATE

The date of the build. Can be used to create separate tags for images. (format: yyyymmdd)

• DOCKERFILE

The dockerfile to use for build. Defaults to the file Dockerfile, but if per-arch dockerfiles exist, (e.g. for x86_64 the filename would be Dockerfile_x86_64) that is used instead.

• TESTCMD

The command to run for testing the image after build. Runs in a bash shell.

• VERSION

The version of the app/tool, may need to be preset before starting the build (e.g. for binaries from github releases), or extracted from the image after build (e.g. for APK or pip packages).

• REGISTRY

The registry to push to, defaults to the Docker Hub Registry (docker.io) or any custom registry that is set via docker configurations. Does not need to be changed for local or test builds, but to override, either pass it by setting an environment variable, or with every make command.

• ORGNAME

The organization (or user) name under which the image repositories exist, defaults to woahbase. Does not need to be changed for local or test builds, but to override, either pass it by setting an environment variable, or with every make command.

The image may also require custom parameters (like binary architecture). Before you build, check the makefile for a complete list of parameters to see what may (or may not) need to be set.

If you're using a private registry (a-la docker distribution server) with self-signed certificates, that fail to validate when pulling/pushing images. You will need to configure buildx to allow insecure access to the registry. This is configured via the config.toml file. A sample is provided in the repository, make sure to replace YOUR.PRIVATE.REGISTRY with your own (include port if needed).

By default, if make is run without any arguments, it calls the target all. In our case this is usually mapped to the target run (which in turn may be mapped to shell).

With a single make push, we are actually pushing 3 tags of the same image, e.g. for x86_64 architecture, they're namely

• alpine-php:x86_64

The actual image that is built.

• alpine-php:x86_64_(version)

It is expected that the application is versioned when built or packaged, it can be specified in the tag, this makes pulling an image by tag possible. Usually this is obtained from the parameter VERSION, which by default, is set by calling a function to extract the version string from the package installed in the container, or from github releases. Can be skipped with the parameter SKIP_VERSIONTAG to a non-empty string value like 1.

• alpine-php:x86_64_(version)_(builddate)

When building multiple versions of the same image (e.g. for providing fixes or revisions), this ensures that a more recent push does not fully replace a previously pushed image. This way, although the architecture and version tags are replaced, it is possible to roll back to the previously built image by build date (format yyyymmdd). This value is obtained from the BUILDDATE parameter, and if not essential, can be skipped by setting the parameter SKIP_BUILDDATETAG to a non-empty string value like 1.

If you want to push the image to a custom registry that is not pre-configured on your system, you can set the REGISTRY variable either on the build environment, or as a makefile parameter, and that will be used instead of the default Docker Hub repository. Make sure to have push access set up before you actually push, and include port if needed. E.g.

export REGISTRY=your.private.registry:5000
make build test push

or

make build test push REGISTRY=your.private.registry:5000

We can inspect the manifest of any image by running

docker manifest inspect <imagename>:<optional tag, default is latest>

First we create or amend the manifest with the tag latest

docker manifest create \
woahbase/alpine-php:latest \
woahbase/alpine-php:aarch64 \
woahbase/alpine-php:armhf \
woahbase/alpine-php:armv7l \
woahbase/alpine-php:x86_64 \
;

docker manifest create --amend \
woahbase/alpine-php:latest \
woahbase/alpine-php:aarch64 \
woahbase/alpine-php:armhf \
woahbase/alpine-php:armv7l \
woahbase/alpine-php:x86_64 \
;

Then annotate the image for each architecture in the manifest with

docker manifest annotate --os linux --arch arm64 \
    woahbase/alpine-php:latest \
    woahbase/alpine-php:aarch64;

docker manifest annotate --os linux --arch arm --variant v6 \
    woahbase/alpine-php:latest \
    woahbase/alpine-php:armhf;

docker manifest annotate --os linux --arch arm --variant v7 \
    woahbase/alpine-php:latest \
    woahbase/alpine-php:armv7l;

docker manifest annotate --os linux --arch amd64 \
    woahbase/alpine-php:latest \
    woahbase/alpine-php:x86_64;

And finally, push it to the repository using

docker manifest push -p woahbase/alpine-php:latest

First we create or amend the manifest with the tag (version)

docker manifest create \
woahbase/alpine-php:(version) \
woahbase/alpine-php:aarch64_(version) \
woahbase/alpine-php:armhf_(version) \
woahbase/alpine-php:armv7l_(version) \
woahbase/alpine-php:x86_64_(version) \
;

docker manifest create --amend \
woahbase/alpine-php:(version) \
woahbase/alpine-php:aarch64_(version) \
woahbase/alpine-php:armhf_(version) \
woahbase/alpine-php:armv7l_(version) \
woahbase/alpine-php:x86_64_(version) \
;

Then annotate the image for each architecture in the manifest with

docker manifest annotate --os linux --arch arm64 \
    woahbase/alpine-php:(version) \
    woahbase/alpine-php:aarch64_(version);

docker manifest annotate --os linux --arch arm --variant v6 \
    woahbase/alpine-php:(version) \
    woahbase/alpine-php:armhf_(version);

docker manifest annotate --os linux --arch arm --variant v7 \
    woahbase/alpine-php:(version) \
    woahbase/alpine-php:armv7l_(version);

docker manifest annotate --os linux --arch amd64 \
    woahbase/alpine-php:(version) \
    woahbase/alpine-php:x86_64_(version);

And finally, push it to the repository using

docker manifest push -p woahbase/alpine-php:(version)

First we create or amend the manifest with the tag (version)_(builddate)

docker manifest create \
woahbase/alpine-php:(version)_(builddate) \
woahbase/alpine-php:aarch64_(version)_(builddate) \
woahbase/alpine-php:armhf_(version)_(builddate) \
woahbase/alpine-php:armv7l_(version)_(builddate) \
woahbase/alpine-php:x86_64_(version)_(builddate) \
;

docker manifest create --amend \
woahbase/alpine-php:(version)_(builddate) \
woahbase/alpine-php:aarch64_(version)_(builddate) \
woahbase/alpine-php:armhf_(version)_(builddate) \
woahbase/alpine-php:armv7l_(version)_(builddate) \
woahbase/alpine-php:x86_64_(version)_(builddate) \
;

Then annotate the image for each architecture in the manifest with

docker manifest annotate --os linux --arch arm64 \
    woahbase/alpine-php:(version)_(builddate) \
    woahbase/alpine-php:aarch64_(version)_(builddate);

docker manifest annotate --os linux --arch arm --variant v6 \
    woahbase/alpine-php:(version)_(builddate) \
    woahbase/alpine-php:armhf_(version)_(builddate);

docker manifest annotate --os linux --arch arm --variant v7 \
    woahbase/alpine-php:(version)_(builddate) \
    woahbase/alpine-php:armv7l_(version)_(builddate);

docker manifest annotate --os linux --arch amd64 \
    woahbase/alpine-php:(version)_(builddate) \
    woahbase/alpine-php:x86_64_(version)_(builddate);

And finally, push it to the repository using

docker manifest push -p woahbase/alpine-php:(version)_(builddate)