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

Most projects that we may package as `APKBUILD` have some build system, like a `Makefile`, `CMake`, or `meson`. By default, these systems don’t necessarily install to the correct locations that are defined by the Alpine FHS. That means that we have to explicitly specify what location they should be installed to.

# Common problems

By default, most build systems assume that user installs are done, not system installs. This means that the build system will try to install content to `/usr/local`. While this may be correct for installing packages without the package manager, it’s the wrong location when installing it with our package manager (`apk`). To fix this, we usually have to specify a different prefix. The prefix specifies a common directory that all files of a package are installed to, like  `/usr`. How we specify this prefix differs depending on the build system, as we'll see later in this lesson. (Note that sometimes packages also install files to the wrong directory. One example of this is installing binary files to `/usr/share`. This isn't correct since `/usr/share` should only contain architecture-independent files according to the Alpine FHS.)

# `Makefiles`

`Makefiles` are a simple format for specifying how a package will be built. The problem with `Makefiles` is that they aren’t well standardized across packages. As such, there are subtle differences in each `Makefile` build system for each different package. However, it’s common for `Makefiles` to have some configuration options that are at the top of the file, like so:

Understand the details of installing packages into the right directories.

Introduction

Using abuild

Alpine's FHS

Creating Your First APKBUILD

Creating More Complex APKBUILDs

Hosting Our Own APK Repository

Additional APKBUILD Examples

Conclusion

Ensure Build Systems Install to the Right Location

Preface

Common problems