Gain insights into creating Alpine Linux packages. Delve into APKBUILDs, packaging basics, and repository management. Discover quality assurance and enhance your Alpine Linux and DevOps skills.

Doxx.tar.gz

In this course, you will learn how packaging software works in Alpine Linux, the most popular Docker Linux distribution.

You’ll first learn the basics: what is Alpine Linux and what are its advantages over other distributions, especially in a Docker environment? Next, you’ll cover the basics of packaging software: what are apk and APKBUILD, where should files be installed, and how can we create basic APKBUILDs and submit them for inclusion in Alpine Linux official repositories? You’ll also learn what makes an Alpine Linux package low or high quality. Finally, you’ll explore APKBUILDs for different programming languages and finish by creating your own private Alpine Linux repository with complex subpackages. 

By the end of the course, you will be able to create APKBUILDs which easily pass Alpine’s quality assurance. Overall, this course will increase your understanding of Alpine Linux and Linux in general and help you improve your DevOps skills.

Creating Alpine Linux Packages

# Preface

The `abuild` package also installs an additional tool for us: `newapkbuild`. This command can be used for creating a template to base our first package on.


# Run `newapkbuild`

First, let's see how to run `newapkbuild`. Its help page lists all available commands:



$ newapkbuild -h
newapkbuild 3.9.0-r0 - generate a new APKBUILD
Usage: newapkbuild [-n PKGNAME] [-d PKGDESC] [-l LICENSE] [-u URL]
       [-a | -C | -m | -p | -y | -r] [-s] [-c] [-f] [-h]
       PKGNAME[-PKGVER] | SRCURL
Options:
  -n  Set package name to PKGNAME (only use with SRCURL)
  -d  Set package description to PKGDESC
  -l  Set package license to LICENSE, use identifiers from:
      <https://spdx.org/licenses/>
  -u  Set package URL
  -a  Create autotools package (use ./configure ...)
  -C  Create CMake package (Assume cmake/ is there)
  -m  Create meson package (Assume meson.build is there)
  -p  Create perl package (Assume Makefile.PL is there)
  -y  Create python package (Assume setup.py is there)
  -r  Create rust package (Assume Cargo.toml is there)
  -s  Use sourceforge source URL
  -c  Copy a sample init.d, conf.d, and install script
  -f  Force even if directory already exists
  -h  Show this help



We'll go through these options at a later stage, so don't worry if these aren't immediately clear. Since we only want to create a simple dummy package, only a handful of options are relevant for us. The following command will do to create our first package:



newapkbuild -d "This is our first package" "our-first-package-0.0.1"


Afterward, we can inspect the output `newapkbuild` generated:


# Contributor:
# Maintainer:
pkgname=our-first-package
pkgver=0.0.1
pkgrel=0
pkgdesc="This is our first package"
url=""
arch="all"
license=""
depends=""
makedepends=""
checkdepends=""
install=""
subpackages="$pkgname-dev $pkgname-doc"
source=""
builddir="$srcdir/"

build() {
	# Replace with proper build command(s)
	:
}

check() {
	# Replace with proper check command(s)
	:
}

package() {
	# Replace with proper package command(s)
	:
}

As we can see, `newapkbuild` has set `pkgdesc` to the description we passed to it via `-d` and set `pkgname` to the last positional argument we passed to it. Let's go over the function of the individual keys, line by line.

* `Contributor` is an optional comment that is used in `aports`, Alpine's package tree. Everyone that has contributed to this particular `APKBUILD` is listed here in the format `Name <email@example.org>`. There may be multiple contributors to one `APKBUILD`, in which case there are multiple `Contributor` lines with one name and email each.
* `Maintainer` is another optional field that denotes the maintainer of this package in the same format as the `Contributor` field. The person noted in this field is responsible for keeping this package updated and for backporting security patches to stable releases.
* `pkgname` sets the name of that specific package. We can `add` the package with this name later on.
* `pkgver` is the version of this package (e.g., `0.0.1`).
* `pkgrel` is the release version of this package. This is used when the version of the Alpine Linux package is increased without the upstream package version (`pkgver`) getting increased. This may be the case when additional patches are added to a package. The `pkgrel` has to be increased in this case so `apk` can install the newer patched version.
* `pkgdesc` is the description of this package.
* `license` is the license of the package's source in the SPDX format (e.g., `GPL-3.0-or-later`).
* `depends` is a list of runtime dependencies.
* `makedepends` is a list of build-only dependencies. For example, when a package uses `CMake` for building, we add it to `makedepends` since it's only required for building the package and not for running it.
* `checkdepends` is a list of packages that are required for running tests.
* `install` denotes `triggers` that should be run during installation/removal of the package.
* `subpackages` is a list of subpackages that this main package is divided into.
* `source` is a list of online resources that are required for building this package.
* `builddir`, the last key in the template, is used for setting the default directory that `abuild` will change into, in each of the build functions.

## The `build()` functions

The `build()` functions in the `APKBUILD` define how the package should be built. By default, `newapkbuild` has added the following functions:

Discover what you can do with APKBUILDs, and try building your first package using abuild.

Introduction

Using abuild

Alpine's FHS

Creating Your First APKBUILD

Creating More Complex APKBUILDs

Hosting Our Own APK Repository

Additional APKBUILD Examples

Conclusion

Build APKBUILDs with abuild

Preface

Run `newapkbuild`

Build APKBUILDs with abuild

Preface

Run newapkbuild

Run `newapkbuild`