Alpine Linux - User contributions [en]

Creating an Alpine package

2025-08-25T21:15:20Z

Sliwkr: Link to aports/CODESTYLE.md when mentioning APKBUILD references

{{TOC right}}
This page documents the procedure to create and submit new package in Alpine Linux.

== Overview ==

This is a brief list of the steps to create and submit new package in Alpine Linux. Please see the rest of this wiki for details on the steps.

# Create an account on https://gitlab.alpinelinux.org
# [[Setting up the build environment|Setup the build environment]].
# Fork the [https://gitlab.alpinelinux.org/alpine/aports aports repository] and [[Git#Cloning_your_forked_repository|clone your fork]] .
# Create and switch to a new branch (don't use master).
# Add a new directory under testing that is your new package name.
# Add your APKBUILD file.
# Run abuild checksum
# Make sure you run the apkbuild-lint and aport -r and there are no warnings.
# Commit your APKBUILD with the commit message: 'testing/packagename: new aport'
# Push your changes to your fork on https://gitlab.alpinelinux.org/alpine.
# Create a merge request.

== Getting help ==
{{Seealso|Abuild and Helpers}}

The {{pkg|abuild}} package provides scripts necessary for creating packages for Alpine Linux. It implements functionality for building packages as well as additional commands and options for package maintenance. It might be wise to start by checking what the [[Abuild and Helpers|abuild]] program can/cannot do.{{Cmd|abuild -h}}

For realtime help, you can also go on #alpine-devel on [[IRC]].

A reference for APKBUILD files is available as [[APKBUILD Reference]] wiki page, [https://gitlab.alpinelinux.org/alpine/aports/-/blob/master/CODINGSTYLE.md?ref_type=heads aports/CODINGSTYLE.md] or a man page in the {{pkg|abuild-doc}} package:{{Cmd|man APKBUILD}}

== Creating an APKBUILD file ==
{{Seealso|APKBUILD examples}}
The [[APKBUILD examples]] page lists a number of APKBUILD examples ranging from [[APKBUILD_examples#Simple_APKBUILD|Simple APKBUILD]] to [[APKBUILD_examples#Subpackages|subpackages]] and various [[APKBUILD_examples#Application_specific_examples|Application specific examples]]. These examples will assist you in understanding how to create an APKBUILD and provide snippets to use in your own APKBUILD files.

=== Use a template APKBUILD ===

Alpine Linux has the following tools to create a template APKBUILD file.

==== newapkbuild ====
{{:Include:Newapkbuild}}

==== apkbuild-cpan ====
{{:Include:apkbuild-cpan}}

==== apkbuild-pypi ====
{{:Include:apkbuild-pypi}}

=== Modify your APKBUILD ===

Edit APKBUILD and fill in the needed info (especially pkgname, pkgver, pkgdesc, url, license, depends and source).

If you are going to use any of the variables for directories like $pkgdir, always make sure they are double quoted like:

"$pkgdir"/somedir

This will prevent issues with spaces/special characters in the future.

{{Note|If you like syntax highlighting we suggest you to install vim. We have setup vim to recognize the APKBUILD file as a bash scripts so its easier to read them.}}

=== APKBUILD variables/functions ===

==== source ====

The source variable is not only used to list the remote source files to fetch, it is also used to list the local files that abuild will need in order to build the apk. Examples of such local files include: init.d files, conf.d files, install files (see [[Creating an Alpine package#install|install variable]]), patches, and all other necessary files.

Here are few things to note:
* When you are finished adding local and/or remote files to ''source'', you can execute the following command to add their checksums to the APKBUILD file:
: {{cmd|abuild checksum}}
: {{Note|When later updating the content of ''source'', or updating a file that is listed in ''source'', you must also update their checksums again with the same command.}}

* When the remote file is hosted at SourceForge, it's best to specify the special mirrors link used by SourceForge:
: <pre>http://downloads.sourceforge.net/$pkgname/$pkgname-$pkgver.tar.gz</pre>
: (or similar depending on the package).

* When the remote filename is not specified in the URI (ie, does not end in '/software-1.0.tar.gz'), such as:
: <pre>http://oss.example.org/?get=software&ver=1.0</pre>
: You must prepend '${pkgname}-${pkgver}.tar.gz::' to the protocol, like so:
: <pre>source="${pkgname}-${pkgver}.tar.gz::http://oss.example.org/?get=software&ver=1.0"</pre>
: This causes the file to be saved as ''software-1.0.tar.gz'' where abuild can use it, instead of ''?get=software&ver=1.0'', where abuild cannot use it.

* Some projects didn't provide a release tarball. Beware that some git services (gitweg, cgit, …?) doesn’t provide ''stable'' tarballs, so when you point source to an tarball like <tt>https://repo.or.cz/w/gitstats.git/snapshot/ad7efbb9399e60cee6cb217c6b47e604174a8093.tar.gz</tt>, then you will run into issues because the checksum changes when downloading on the build system. This is not a problem on GitHub, GitLab and other decent services provides, they provide ''stable'' tarballs.

* abuild currently supports the following protocols for remote file retrieval:
** http
** https
** ftp


* abuild currently supports the following archive types/archive file extensions:
** .tar
** .tar.gz / .tgz
** .tar.bz2
** .tar.lz (only in Alpine >=3.7)
** .tar.lzma
** .tar.xz
** .zip

==== depends & makedepends ====

Depends are the actual running dependencies that a package would need when it is running. Makedepends are only needed when you are building a package. If you set a package in depends, you do not need to add it to makedepends as well. The best way to find out what the depends and makedepends of a package are is to [https://en.wikipedia.org/wiki/Rtfm RTFM].

No kidding, lots of important information can be found in the package INSTALL and README files (or the likes). Another good way is the run <code>./configure --help</code> from the source directory to see which options are needed for configure to finish without errors. If you do not yet have a source directory you can create one with the command: {{Cmd|abuild unpack}}

Running <code>configure</code> will also show you how you can disable a specific option for this package. For instance, a good example is "--disable-nls" which will disable native language support and thus does not depend on gettext (libiconv, glib, ...).

Alpine likes to keep things small, so we try to disable as much as possible without losing too many features. The exact disable/enable options are decided by the package builder but please try to follow Alpine's design concept as much as possible.

An easy way of quickly finding out the build info for a package is to check Arch Linux (Alpine package management and build scripts are similar) or Gentoo Linux ebuilds (previous versions of Alpine were based on Gentoo).

* [https://gitweb.gentoo.org/repo/gentoo.git/tree/ Gentoo Ebuilds]
* [https://archlinux.org/packages/?q=search Arch Linux packages] [https://aur.archlinux.org/ Arch Linux User Repository]

==== license ====

The '''license''' tag must reflect the license of the source code. Please check the source tarball for COPYING, LICENSE, or other files with names that indicates that it contains licensing information. Beside the license file most developer include headers in the source code files with licensing details.

If the license is on the [https://spdx.org/licenses/ SPDX License List] or [https://spdx.org/licenses/exceptions-index.html SPDX License Exceptions], use the identifier specified by SPDX.

Note that some licenses have additional requirements that should be adhered to. The <code>MIT</code> license for example has the requirement:

<blockquote>
The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
</blockquote>

This means that we need to include the license as shipped with the project.

Known licenses that require this:

* <code>MIT</code>
* <code>ISC</code>

If a package has a special/custom license or is not listed as [https://opensource.org/licenses/alphabetical OSI approved], use the identifier "custom". In that case we need to provide the license file with the package as well.

Because we want to save space and don't like to have licenses all over our system we have decided to include the license in the doc subpackage. Please follow the following guidelines to add a proper license. Locate the license file inside the source package. Add the doc subpackage to the $subpackages variable as follows:

subpackages="$pkgname-doc"

Add a similar line to the following to your package() function, depending on the license description file: {{Cmd|install -Dm644 COPYING "$pkgdir"/usr/share/licenses/$pkgname/COPYING}}

If you follow these steps then abuild will automatically add the license to the package-doc apk for you.

{{Warning|It is not acceptable to package software with "unknown" license! If you can't find the license of the source code, please contact the author and ask them to specify the license. }}

==== arch ====

The package architecture(s) to build for. This can be one of: ''x86, x86_64, all,'' or ''noarch'', where ''all'' means all architectures, and ''noarch'' means it's architecture-independent (e.g., a pure-python package).
{{Tip|To determine if your APKBUILD can use ''noarch'', build the package for your architecture and then run "scanelf -R pkg" from the directory that the APKBUILD resides in, in order to scan for ELF files in the ''./pkg'' directory. If you do NOT get output from this, then ''noarch'' can be used.}}

==== url ====

Website address for the program. This is useful later on when either finding documentation or other information about the package.

==== pkgdesc ====

A brief, one line, description of what the package does. Useful for the package management system. It should start with a capital letter and does '''not''' end with a period.

Here is an example from apk_info for the OpenSSH client package:

pkgdesc="Port of OpenBSD's free SSH release - client"

==== pkgver ====

Provide the release number of the package you are building.

==== pkgrel ====

The $pkgrel versioning is made so that if you change something in your APKBUILD file without changing the actual $pkgver, you can increment pkgrel so apk tools will detect it as an update. For instance, if you forget to add a dependency, you can add it afterward and you can +1 pkgrel so apk finds this update and adds the missing dependency. When there's an upstream version change, we reset the pkgrel to 0.

==== pkgname ====

The base name of the package you are creating. For Freeswitch 1.0.6, you would use "freeswitch"

==== install ====

There are 6 different kinds of install scripts. Each script is called with the $pkgname.''<action>'' where ''<action>'' is one of the following:

<dl>
<dt>$pkgname.pre-install
<dd>This script is executed before package is installed. Typical use is when package needs a group and a user to be created. For example:
<pre>
#!/bin/sh

addgroup -S clamav 2>/dev/null
adduser -S -D -H -s /bin/false -G clamav -g clamav clamav 2>/dev/null

exit 0
</pre>
Note the ''exit 0'' at the end. If the script exits with failure (if the user already exist), the package will not be installed and <code>apk add</code> will exit with failure.

<dt>$pkgname.post-install
<dd>This script is executed after the package is installed.

<dt>$pkgname.pre-upgrade
<dd>Same as pre-install but is executed before upgrading/downgrading/reinstalling an already installed package. Note that exiting with failure will not cause apk to exit with failure, but will mark the package as broken.

<dt>$pkgname.post-upgrade
<dd>Same as post-install but is executed after upgrading/downgrading/reinstalling an already installed package.

<dt>$pkgname.pre-deinstall
<dd>This script is executed before uninstalling a package. If script exits with failure apk will not uninstall the package.

<dt>$pkgname.post-deinstall
<dd>This script is executed after a package have been uninstalled. For example, can be used to restore busybox links:
<pre>
#!/bin/sh
busybox --install -s
</pre>

</dl>

If the package has a pre-install and post-install script the APKBUILD should have the ''install'' variable defined:
<pre>
...
install="$pkgname.pre-install $pkgname.post-install"

...
</pre>

==== subpackages ====

{{Tip| Refer to the example [[APKBUILD_examples#Subpackages|subpackages]] to assist you in understanding how to create them.}}

$subpackages are made to split up the normal "make install" into separate packages. The most common subpackages we use are doc and dev. Because we like to keep our target system small we move documentation and development files (only needed when building packages) into separate packages. To use the specific program a user only need to install the base apk without package-doc or package-dev, but if he wants to read the manual he will need to install package-doc.

The easiest way to find out if you need to use -dev and -doc is to first build the package without these options set and wait until the build finishes. When its finished you should have a pkg directory which is the fake root directory. Inside this directory you will see the structure as how it would be installed in / on the target system.

To see if you need the -dev package you can run the following cmd:

{{Cmd|find pkg/usr/ -name '*.[acho]' -o -name '*.la'}}

If this returns any files you need to include the -dev package.

 To see if you need the -doc package you can run the following cmd:

{{Cmd|find pkg/usr/share -name doc -o -name man -o -name info -o -name html -o -name sgml -o -name licenses}}

If this returns any directories you need to include the -doc package.

===== Custom subpackages =====

Some software additionally has non-essential files that do not qualify as either documentation or development content. These files should be placed in their own, specialized subpackage(s). Some packages include large test suites which are only needed in specific circumstances or binaries which have depends which we prefer not to install. To handle those we create our own package/function. In the APKBUILD below the build() function we create another function:

test() {
mkdir -p "$subpkgdir"/usr
mv "$pkgdir"/usr/package-test "$subpkgdir"/usr/
# or amove usr/package-test
}

We also need to add the package info to $subpackages variable:

subpackages="$pkgname-doc $pkgname-dev $pkgname-test"

After we finish building the package you should see another apk called packagename-test.apk which includes the files which we moved to the $subpkgdir dir.

The above mentioned variables can also be used in our custom function. If we want for instance to build the test() function with perl support we would add:

depends="perl"
makedepends="perl-dev"

If we would install the base package it would not install perl, but if we install the package-test package it would.

==== Patches ====
{{Note|Follow the [[Package policies|coding style]] while creating patches.}}
Please make sure you always submit human readable patches. Ways to create them are:

To do a directory compare: {{Cmd|diff -Nurp original_directory new_directory > filename.patch}}

To do a file compare: {{Cmd|diff -up original.file new.file > filename.patch}}

If a patch contains a completely new file but not *.rej or *.orig file, you need to add -N option to diff, but you may need to add exclusions with <code>--exclude PATTERN</code> so that you do not inadvertently add files. You may need to manually delete unwanted files inside the patch file.

Because multiple patches can patch the same file, they can change the offsets required by subsequent patches. To make sure we always patch in a specific way, we should number the patches as follows:

10-patch1.patch 20-patch2.patch 30-patch3.patch

This way we are always sure that patch 1 is applied first, and if we want to add additional patches between them we can use appropriate indexes (e.g. 11, 12, 21, 22).

Add the names of the patch files to the ''source'' variable. If you haven't declared a custom ''prepare'' function, no further action is necessary. Otherwise, be sure to call ''default_prepare'' in your ''prepare'' function. For example:

prepare() {
default_prepare

# do your stuff
}

Note: Some older packages contain a ''for'' loop in the ''prepare'' function to apply patches. This is not needed anymore, as patches are handled by ''default_prepare''.

In Alpine >=3.4 you can define patch_args to supply the patch level. This only works if all the patches have the same patch level. If there are a lot of patches from different sources, there is a good chance that you may need to edit them, as discussed below.

To automatically patch the package (available only in Alpine >=3.4) if it uses a patch level (-pX) other than the default (-p1), you need to carefully modify the patch. First, you'll need a text editor that does not automatically convert between Windows and Unix new lines (or, disable this feature) so that it preserves the old code. The next thing you'll need to do is modify the paths on "+++" and "---" lines in the .patch file. You can begin the path with a/ and b/ like shown below. Next, you need to adjust the paths so that the relative base path is from inside $builddir. Anything to the left of $builddir, including $builddir itself, needs to be removed from the path. So, if $builddir is /home/USER/aports/community/chromium/src/chromium-65, you need to erase it on the "+++" and "---" lines. Inside the chromium-65 folder you can see a src folder that has 3rdparty as a descendant. If a patch originally has a deeper patch level, you may need to fill in the missing portion of the path. For example, use the <code>find . -name "Assertions.cpp"</code> command to find the full path to the file relative to the base.

{{Cat|example.patch|<nowiki>
Author: John Doe <johndoe@mail.com>
URL: http://.....
Summary: Fixes musl compatibility
----
--- a/src/3rdparty/chromium/third_party/WebKit/Source/wtf/Assertions.cpp.orig
+++ b/src/3rdparty/chromium/third_party/WebKit/Source/wtf/Assertions.cpp
@@ -142,7 +142,7 @@
};

FrameToNameScope::FrameToNameScope(void* addr) : m_name(0), m_cxaDemangled(0) {
-#if OS(MACOSX) || (OS(LINUX) && !defined(__UCLIBC__))
+#if OS(MACOSX) || (OS(LINUX) && defined(__GLIBC__))
Dl_info info;
if (!dladdr(addr, &info) || !info.dli_sname)
return;
</nowiki>}}

Portions of the patch may be outdated, removed completely as in the source code file completely removed, or moved or renamed files. You need to delete that section of the patch or find where that section of code changed and re-diff it.

It is good etiquette to give credit at the top and the location of where you originally found them with notes.

Excluding patches with global variable resembling patch_opts is not available on Alpine. To exclude patches you need to create your own custom prepare().

If you have a monolithic patch where there are a bunch of patches in one big patch, you could use filterdiff which is available in the patchutils package.

Just do something like:

<pre>
makedepends="patchutils"

prepare() {
...
cd "$builddir"
filterdiff -x '*drivers/video/logo*' "$srcdir"/original.patch > "$builddir"/modified.patch
patch -p1 -i "$builddir"/modified.patch
}
</pre>

You need to put the wildcard pattern in single quotes for it to work.

==== Configure options ====

Alpine has some default configure options we set by default. We use /usr for prefix to make sure everything is installed with /usr in front of it. If you notice that anything is installed in the wrong directory please run {{Cmd|./configure --help}} and see if you can set the correct location.

We are not covering the depend switches here we have discussed this already in the depend section.

==== Make options ====

If you notice weird problems when compiling or installing the package with make/make install you could try to disable [https://www.gnu.org/software/make/manual/make.html#Parallel parallel] building/installing. A normal make line would be:{{Cmd|make}}

To disable parallel we use: {{Cmd|make -j1}}

We can use the same for make install.

Because we do not want to install the package in our build environment but we want to install it in a fake root directory we need to tell 'make install' to use another destination directory instead of '/'. We do this by setting a variable when we execute make install as followed: {{Cmd|make DESTDIR{{=}}"$pkgdir" install}}

Please note that some Makefiles do not support this variable and will always install software in '/'. To make sure you do not mess up your build system NEVER run your build system as root but always use a custom user and doas when needed. If by accident the Makefile does not support DESTDIR variable it will fail to install in our build system system directories.

==== builddir ====

If you used <tt>newapkbuild</tt> to create your APKBUILD file, you must specify the path to your unpacked sources. Inside the sections during the prepare/build/install process ''builddir'' is used. Most of the time a combination of ''$srcdir'' and ''$pkgname-$pkgver'' will work. When not, check the /src directory or the source tarball for the right string. Especially when you are working with automatically generated tarballs (like from github and gitorious), this needs to be adjusted.

<pre>
builddir="$srcdir"/$pkgname-$pkgver
</pre>

==== Additional files ====

If you want/need to install additional files not mentioned above you can use the following cmd (this is an example of a conf file): {{Cmd|install -Dm644 doc/$pkgname.conf "$pkgdir"/etc/$pkgname.conf}}

== Build the package ==
{{Seealso|Building packages}}
If you did not already create the checksums as mentioned above you can do so now: {{Cmd|cd $pkgname
abuild checksum}}

It's about time we build our package. Because a build system should never have all the package installed to prevent linking to packages we don't want it to link we use a abuild recursively with the '''-r''' switch. It will install all dependencies from your repository and builds it, afterwards it will uninstall all those depending packages again.{{Cmd|abuild -r}}

== Testing the package locally ==
{{Seealso|Development using git:Quality assurance}}
When it completes, your package will be found in a subfolder of <code>~/packages</code>. You may want to test it on your machine but only if the package is not a critical system package like musl or apk-tools package. To avoid borking your system (as in making it impossible to use <code>apk add</code> or to restore back the system and the compiler toolchain) for a critical system package, you should test on a chroot first before using it live.

The best way to test a package locally is to modify your <code>/etc/apk/repositories</code> so that it includes the indexes to your locally built packages - the directories that contain <code>ARCH/APKINDEX.tar.gz</code>. For example the <code>/etc/apk/repositories</code> below includes locally built packages in testing, community and main. To use this example change <code>USER</code> to your login name.

{{Cat|/etc/apk/repositories|/home/USER/packages/testing/
/home/USER/packages/main/
/home/USER/packages/community/
https://dl-cdn.alpinelinux.org/alpine/edge/main
https://dl-cdn.alpinelinux.org/alpine/edge/community
https://dl-cdn.alpinelinux.org/alpine/edge/testing
}}

If you prefer to test a package without changing any other configuration you can use the <code>-X, --repository</code> option to <code>apk</code>: {{Cmd|doas apk add --repository /home/USER/packages/testing $pkgname}}

== Code review ==
{{Seealso|Package_policies}}
To successfully have your package pass through code reviewers (as of Feb 18, 2018 are nmeum and jirutka on GitHub) and possible increased acceptance, the following conventions as laid in the below references need to be followed:
* [https://gitlab.alpinelinux.org/alpine/aports/-/blob/master/CODINGSTYLE.md?ref_type=heads aports/CODINGSTYLE.md]
* [https://gitlab.alpinelinux.org/alpine/aports/-/blob/master/COMMITSTYLE.md?ref_type=heads aports/COMMITSTYLE.md]
{{Note| Run the linter tool <code>apkbuild-lint</code> from {{pkg|atools}} package: {{Codeline|$ apkbuild-lint APKBUILD}}}}
# Custom global variables should be prefixed with underscore (_).
# Compact code as in merged commands, removed unused variables, removal of functions that do the same thing that are automatically handled by abuild.
# Versioning is done properly. For details see [[APKBUILD_Reference#pkgver]].
# Licensing is done properly. Remove unnecessary copying of licensing that is already OSI approved.
# Naming conventions rules for unofficial variables as in _gitrev is preferred over commit.
# Indent with tabs not spaces.
# Removal of explicit return 1. (They are still found the old APKBUILD files if you are learning but are now strongly discouraged.)
# Disabling check() requires either (1) a comment (#) stating next to options="!check" that there is no test suite/unit tests or (2) functioning working check() function.
# Explicit call to subpackages="$pkgname-doc" must be used instead of explicit gzip man page compression.
# Ideally, lines should be no more than 80 columns wide

== Commit your work ==

After you successfully build your package and properly followed the conventions and requirements in the code review section, you can submit your APKBUILD to Alpine's git repository.

Update your git repo, before adding new files:

{{Cmd|cd $aportsdir
git pull}}

This should pull all the changes made by others into your local git repo.

When you think you are ready you can add your files to git:

NOTE: when using our Gitlab instance, you can create MR's for each package. Please squash all commits related to the same package into a single one per MR.

{{Cmd|cd $aportsdir
git add testing/$pkgdir (include any other files needed for the build; $pkgname.install...)
git commit}}

Use the following commit message template for new aports (without the comments):

{{Cat|template|testing/$pkgname: new aport # this will be the subject line
# a blank line
$url # project homepage
$pkgdesc # one line description}}

Or you could add the following and <code>chmod +x ports/.git/hooks/prepare-commit-msg</code> to automatically generate commit message which the default aports/.githooks/ does not:

{{Cat|aports/.git/hooks/prepare-commit-msg|<nowiki>#!/bin/sh
case "$2,$3" in
,|template,)
if git diff-index --diff-filter=A --name-only --cached HEAD \
| grep -q '/APKBUILD$'; then
meta() { git diff --staged | grep "^+$1" | sed 's/.*="\?//;s/"$//';}
printf 'testing/%s: new aport\n\n%s\n%s\n' "$(meta pkgname)" \
"$(meta url)" "$(meta pkgdesc)" "$(cat $1)" > "$1"
else
printf '%s\n\n%s' `git diff-index --name-only --cached HEAD \
| sed -n 's/\/APKBUILD$//p;q'` "$(cat $1)" > "$1"
fi;;
esac</nowiki>}}

Now your changes are only available locally in your repository.

Because you do not have push rights to the Alpine aports repository you need to create a merge request to [https://gitlab.alpinelinux.org/alpine/aports Alpine's GitLab instance].

Alternatively you can also create a diff (patch) of the changes you made and send this patch to the
[https://lists.alpinelinux.org/~alpine/aports alpine-aports mailinglist].

To create a diff patch: {{Cmd|git format-patch HEAD^}}

or if you have sprunge, you can create a link to your patch for convenience: {{Cmd|git format-patch HEAD^ --stdout <nowiki>|</nowiki> sprunge}}

== Automated flagging of outdated ports ==

Consider adding your port to [https://release-monitoring.org/ Anitya], so it will be flagged as outdated
as soon as a new stable version is released by upstream.

== See also ==

* [[APKBUILD Reference]]
* [[APKBUILD examples]]
* [[Development using git:Quality assurance]]
* [[Package policies]]
* [https://gitlab.alpinelinux.org/alpine/aports/-/blob/master/COMMITSTYLE.md?ref_type=heads aports/COMMITSTYLE.md]
* [https://gitlab.alpinelinux.org/alpine/aports/-/blob/master/CODINGSTYLE.md?ref_type=heads aports/CODINGSTYLE.md]

[[category: Development ]] [[category: Package Manager]]

Installation

2022-09-25T10:04:38Z

Sliwkr: /* Post-Installation */ update broken link to desktop environments section

[[Image:hdd_mount.png|left|link=]]
 

This page explains the basics to get started. But before actually installing, it can also help to skim through the [[Alpine_Linux:FAQ| Frequenty Asked Questions (FAQ)]].

{{Tip|This is a wiki!
If something isn't correct (anymore), or still incomplete, you will have to try figuring it out, or ask for the correct solution in the [https://alpinelinux.org/community/ community].

And then carefully edit the wiki page.

Just as those before you did it for you.
}}

== Minimal Hardware Requirements ==

* At least 100 MB of RAM. [A graphical desktop system may require up to 1 GB minimum.]
* At least 0-700 MB space on a writable storage device. [Only required in "sys" or "data" mode installations (explained below). It is optional in "diskless" mode, where it may be used to save newer data and configurations states of a running system.]

For more information please check [[Requirements]]

== Installation Overview ==

=== The general course of action ===
{{Note|For single-board-computer (SBC) architectures which can not boot .iso images, see [[Alpine_on_ARM|Alpine on ARM]] for peculiarities.}}

As usual, the regular installation procedure starts with three basic steps (additional details for all the steps follow [[Installation#additional details|below]]): 

# Downloading and verifying the proper [http://alpinelinux.org/downloads stable-release ISO installation image-file] for the computer's architecture, and the corresponding <code>sha256</code> (checksum) and <code>GPG</code> (signature) files.
# Either burning the ISO image-file onto a blank CD/DVD/Blu-ray disk with disk burning software, or flashing the installation image onto a bootable storage device (USB-device, CF-/MMC-/SD-card, floppy, ...). Optionally to setup a headless system, a bootstrapping configuration overlay file [https://github.com/macmpi/alpine-linux-headless-bootstrap headless.apkovl.tar.gz] may be added to enable basic networking, so that following configuration steps can be performed under <code>ssh</code>.
# Booting the computer from the prepared disk or storage device.

The boot process of the installation image first copies the entire operating system into the RAM memory, and then already starts a complete Alpine Linux system from there. It will initially only provide a basic command line environment that does not depend on reading from any (possibly slow) initial boot media, anymore.

Log-in is possible as the user <code>root</code>. Initially, the root user has no password.

At the command prompt, an interactive script named <code>[[Alpine_setup_scripts#setup-alpine|setup-alpine]]</code> is available to configure and install the initial Alpine Linux system.

The question-and-answer dialog of <code>[[Alpine_setup_scripts#setup-alpine|setup-alpine]]</code> takes care of the base configuration and allows to configure the system to
boot into one of three different '''Alpine Linux disk modes''': '''"diskless"''', '''"data"''', or '''"sys"'''.

These modes are explained in more detail in the following subsections.

{{Note|It can be helpful to know that it is possible to first only complete a base configuration of the initial "diskless" installation system in order to to prepare the system. For example, to download and install some specific driver or software tool. And then use more specific [[Alpine_setup_scripts|setup-scripts]] afterwards, to proceed with the final installation. The base configuration of the "diskless" system may be completed by running <code>[[Alpine_setup_scripts#setup-alpine|setup-alpine]]</code> and answering "none" when asked for the disk to use, and where to store configs, as well as for the location for the package cache.

Examples of preparation options:

* Preparing a custom partitioning or filesystem scheme that avoids to use and/or overwrite an entire disk ([[Installation#Custom_partitioning_of_the_harddisk|details below]]).
* Installing something that may be missing in the live system to configure the hardware, e.g. by using the alpine package manager <code>[[Alpine_Linux_package_management|apk]]</code>.

Examples of proceeding options:

* <code>[[Alpine_setup_scripts#setup-lbu|setup-lbu]]</code> to configure a "local backup" location for the diskless system, and <code>[[Alpine_local_backup|lbu commit]]</code> to then save the local configuration state.
* <code>[[Alpine_setup_scripts#setup-apkcache|setup-apkcache]]</code> to configure a local package cache storage location.
* <code>[[Alpine_setup_scripts#setup-disk|setup-disk]]</code> to add a "data" mode partition, or do a classic full install of the "diskless" system onto a "sys" disk or partition.

There are many more [[Alpine_setup_scripts|setup-scripts]] available. All these tools may also be run later to adjust specific configurations. For example, to set up a graphical environment as covered under [[Installation#Post-Install|Post-Install]] below.
}}

==='''Diskless Mode'''===
This means the entire operating system with all applications are first loaded into RAM and then only run from there. This is the method used to boot for the .iso installation images. It's is extremely fast and can save on unnecessary disk spin-ups, power, and wear. It is similar to what other linux distributions may call a "frugal" install and boot into with a "toram" option. However, <code>[[Alpine_setup_scripts#setup-alpine|setup-alpine]]</code> can also configure the installed system to boot like this if "disk=none" is specified.

Custom configurations and package selections may optionally still be preserved or "persist" across reboots by using the Alpine local backup tool <code>[[Alpine_local_backup|lbu]]</code>. It enables committing and reverting system states by using .apkovl files that are saved to writable storage and loaded when booting. If additional or updated packages have been added to the system, these may also be made available for automatic (re)installation during the boot phase without any (re)downloading, by enabling a [[Alpine_Linux_package_management#Local_Cache|local package cache]] on the writable storage.

[[https://gitlab.alpinelinux.org/alpine/alpine-conf/-/issues/10473 FIXME-1]: Storing local configs and the package cache on an ''internal'' disk still requires [[Alpine_local_backup#Saving_and_loading_ISO_image_customizations|some manual steps]] to have the partition listed, i.e. making a /etc/fstab entry, mountpoint, and mount, *before* running setup-alpine. The linked workaround also still requires to commit these configurations to disk manually before rebooting.]

If a writable partition is available, <code>setup-alpine</code> can be told to store the configs and the package cache on that writable partition. (Later, another directory on that same partition or another available partition may also be mounted as /home, or for example, for selected important applications to keep their run-time and user data on it.)

The boot device of the newly configured local "diskless" system may remain the initial (and possibly read-only) installation media. But it is also possible to copy the boot system to a partition (e.g. /dev/sdXY) with <code>[[Alpine_setup_scripts#setup-bootable|setup-bootable]]</code>.

==='''Data Disk Mode'''===
This mode also runs from system RAM, thus it enjoys the same accelerated operation speed as "diskless" mode. However, swap storage and the entire {{Path|/var}} directory tree get mounted from a persistent storage device (two newly created partitions). The directory {{Path|/var}} holds e.g. all log files, mailspools, databases, etc., as well as <code>[[Alpine_local_backup|lbu]]</code> backup commits and the package cache. This mode is useful for having RAM accelerated servers with variable amounts of user-data that exceed the available RAM size. It enables the entire current system state (not just the boot state) to survive a system crash in accordance with the particular filesystem guarantees.

[[https://gitlab.alpinelinux.org/alpine/alpine-conf/-/issues/10474 FIXME-2]]: Setup-alpine will create the data partition and mount it as /var, but can not yet configure lbu storage settings automatically. It is currently necessary to select "none" at the 'where to store configs' prompt (the new data partition is not listed) and configure lbu manually. For example, after running <code>setup-alpine</code> and before rebooting:

# Set LBU_MEDIA=sdXY in /etc/lbu/lbu.conf
# Execute a corresponding <code>echo "/dev/sdXY /media/sdXY <fstype> rw 0 0" >> /etc/fstab</code>
# Save the configuration for the next boot with <code>lbu commit</code>.

In data disk mode, the boot device may also remain the initial (and possibly read-only) installation media, or be copied to a partition (e.g. /dev/sdXY) with <code>[[Alpine_setup_scripts#setup-bootable|setup-bootable]]</code>.

==='''System Disk Mode'''===
This is a traditional hard-disk install.

If this mode is selected, the <code>[[setup-alpine]]</code> script creates three partitions on the selected storage device, {{Path|/boot}}, {{Path|swap}} and {{Path|/}} (the filesystem root). This mode may, for example, be used for generic [[Desktops|desktop]] and development machines.

For custom partitioning, see [[Setting_up_disks_manually]].

To install along side another operating systems, see [[Installing_Alpine_on_HDD_dualbooting]].

== Basic Installation Step Details ==

{{Expand| }}

This "Additional Details" section needs to be consolidated with the work at '''[https://docs.alpinelinux.org https://docs.alpinelinux.org] (not finished)'''
(Restructuring things there, moving and linking from here or there?).

=== Verifying the downloaded image-file ===

{| class="wikitable" style="width:95%; align=center"
|+ Commands to verify the checksum and GPG signature of a downloaded image-file on different systems.
|-
! width=100px | OS type
! <code>SHA256</code> check !! <code>SHA256</code> calculation (to be compared manually) !! <code>GPG</code> signature verification
|-
! Linux
| <code>sha256sum -c alpine-*.iso.sha256</code> || || <code>curl https://alpinelinux.org/keys/ncopa.asc | gpg --import ;</code>
<code> gpg --verify alpine-<version>.iso.asc alpine-<version>.iso</code>
|-
! MACOS
| - ? - || <code>shasum -a 256 alpine-*.iso</code> || - ? -
|-
! OpenBSD
| <code>sha256 -C alpine-*.sha256 alpine-*.iso</code> || || <code>doas pkg_add gnupg;
ftp -o - https://alpinelinux.org/keys/ncopa.asc | gpg --import ;
gpg --verify alpine-<version>.iso.asc alpine-<version>.iso</code>
|-
! FreeBSD
| - ? - || <code>/usr/local/bin/shasum -a 256 alpine-*.iso</code> || - ? -
|-
! NetBSD
| - ? - || <code>/usr/local/bin/shasum -a 256 alpine-*.iso</code> || - ? -
|-
! Windows (PowerShell installed)
| - ? - || <code>Get-FileHash .\alpine-<image-version>.iso -Algorithm SHA256</code> || - ? -
|}

=== Flashing (direct data writing) the installation image-file onto a device or media ===

==== Unix/Linux ====

Under Unix (and thus Linux), "everything is a file" and the data in the image-file can be written to a device or media with the <code>dd</code> command. Afterward, executing the <code>eject</code> command removes the target device from the system and ensures the write cache is completely flushed.

dd if=<iso-file-to-read-in> of=<target-device-node-to-write-out-to> bs=4M oflag=sync status=progress; eject <target-device-node-to-write-to>

Be careful to correctly identify the target device as any data on it '''will''' be lost! All connected "bulk storage devices" can be listed with <code><nowiki>lsblk</nowiki></code> and <code><nowiki>blkid</nowiki></code>.

# lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sdX 0:0 0 64,0G 0 disk
├─sdX1 0:1 0 2G 0 part
└─sdX2 0:2 0 30G 0 part /mnt/sdX2

# blkid
/dev/sdX1: LABEL="some" UUID="..." TYPE="vfat"
/dev/sdX2: LABEL="other" UUID="..." TYPE="ext4"

For example, if /dev/sdX is the desired target device, first make sure you un-mount all mounted partitions of the target device. For example sdX1 and sdX2:

umount /dev/sdX1 /dev/sdX2

For <code>dd</code>'s output-file (<code>of=</code>), however, do '''not''' specify a partition number. For example, write to sdX, '''not''' sdX1:

Warning: '''This will overwrite the target device /dev/sdX''', so before executing, make sure you have a backup of the data if you can't afford to lose it.

dd if=~/Downloads/alpine-standard-3.00.0-x86_64.iso of=/dev/sdX bs=4M oflag=sync status=progress; eject /dev/sdX

==== Windows ====

For example, there is the [https://rufus.ie/ Rufus] program. Rufus will enable you to create bootable USB flash drives under Windows.

Rufus has been tested and works for Alpine Linux 3.12.x with the following settings:
* '''Partition scheme''': <code>MBR</code>
* '''Target system''': <code>BIOS or UEFI</code>
* '''File system''': <code>FAT32</code>
* '''Cluster size''': <code>4096 bytes (default)</code>

=== Verifying the written installation media ===

After detaching and re-attaching the device, a bit-wise comparison can verify the data written to the device (instead of just data buffered in RAM). If the comparison terminates with an end-of-file error on the .iso file side, all the contents from the image have been written (and re-read) successfully:

# cmp ~/Downloads/alpine-standard-3.00.0-x86_64.iso /dev/sdX
cmp: EOF on alpine-standard-3.00.0-x86_64.iso

=== Booting from external devices ===

Insert the boot media to a proper drive or port of the computer and turn the machine on, or restart it, if already running.

If the computer does not automatically boot from the desired device, one needs to bring up the boot menu and choose the media to boot from. Depending on the computer, the menu may be accessed by repeatedly pressing a key quickly when booting starts. Some computers require that you press the button ''before'' starting the computer and hold it down while the computer boots. Typical keys are: `F9`-`F12`, sometimes `F7` or `F8`. If these don't bring up the boot menu, it may be necessary to enter the BIOS configuration and adjust the boot settings, for which typical keys are: `Del.` `F1` `F2` `F6` or `Esc.`

=== Custom partitioning of the harddisk ===

It is possible to specify configurations for RAID, encryption, LVM, etc. as well as manual partitioning.

For "diskless" or "data disk" mode installs, manual partitioning may be needed to prepare the harddisk for committing local backups of the system state with <code>[[Alpine_local_backup|lbu commit]]</code>, to have a place for a package cache, or to use it for a /var mount.

For a "sys" install, custom partitioning is needed only if the desired scheme differs from overwriting an entire disk, or using the default set of a /boot, swap and root partition on the disk.

See [[Setting_up_disks_manually]] for the alpine options for RAID, encryption, LVM, etc. and manual partitioning.

=== Questions asked by <code>setup-alpine</code> ===
[[File:Installation-alpine-alpine-setup-3-setup-scripts.png|350px|thumb|right|Example <code>setup-alpine</code> session]]

The <code>[[setup-alpine]]</code> script offers the following configuration options:

* '''Keyboard Layout''' (Local keyboard language and usage mode, e.g. ''us'' and variant of ''us-nodeadkeys''.)
* '''Hostname''' (The name for the computer.)
* '''Network''' (For example, automatic IP address discovery with the "DHCP" protocol.)
* '''DNS Servers''' (Domain Name Servers to query. For privacy reasons it is NOT recommended to route every local request to servers like google's <s>8.8.8.8</s> .)
* '''Timezone'''
* '''Proxy''' (Proxy server to use for accessing the web. Use "none" for direct connections to the internet.)
* '''Mirror''' (From where to download packages. Choose the organization you trust giving your usage patterns to.)
* '''SSH''' (Secure SHell remote access server. "Openssh" is part of the default install image. Use "none" to disable remote login, e.g. on laptops.)
* '''NTP''' (Network Time Protocol client used for keeping the system clock in sync with a time server. Package "chrony" is part of the default install image.)
* '''Disk Mode''' (Select between diskless (disk="none"), "data" or "sys", as described above.)
{{Warning|The data on a chosen device will be overwritten!}}

=== Preparing for the first boot ===

If <code>setup-alpine</code> has finished configuring the "sys" disk mode, the system should be ready to reboot right away (see next subsection).

If the new local system was configured to run in "diskless" or "data" mode, and you do not want keep booting from the initial (and possibly read-only) installation media, the boot system needs to be copied to another device or partition.

The target partition may be identified using <code><nowiki>lsblk</nowiki></code> (after installing it with <code>apk add lsblk</code>) and/or <code>blkid</code>, similar to previously identifying the initial installation media device.

The procedure to copy the boot system is explained at <code>[[Alpine_setup_scripts#setup-bootable|setup-bootable]]</code>

Once everything is in place, save your customized configuration with <code>lbu commit</code> before rebooting.

=== Rebooting and testing the new system ===

First, remove the initial installation media from the boot drive, or detach it fron the port it's connected to.

The system may now be power-cycled or rebooted to confirm everything is working correctly.

The relevant commands for this are <code>poweroff</code> or <code>reboot</code>.

=== Completing the installation ===

The installation script installs only the base operating system. '''No''' applications e.g. web server, mail server, desktop environment, or web browser are installed, and <code>root</code> is the only user.

Please look under "Post-Install" below, for some common things to do after installation.

= Further Installation Instructions =

=== Installation ===

* [[Kernels]] ''(kernel selection, e.g. for VMs or RPi)''
* [[How to make a custom ISO image with mkimage]] ''(installation media with its own configuration)''
* [[Directly booting an ISO file]] ''(without flashing it to a disk or device)''
* [[Dualbooting|Dual/multi-boot install to HDD partition]]
* [[Netboot Alpine Linux using iPXE]]
Also see other [[:Category:Installation|Installation Category]] pages.

=== Post-Installation ===



{{Note|A [[Post installation|Post Installation]] wiki page is available, however, post-installation information should be kept at their individually manageable topic pages and only directly referenced (linked).}}

* [[Setting up a new user]] ''(to allow remote, console, or graphical logins)''
* [[Tutorials_and_Howtos#Networking|Setting up Networking]] ''(including non-standard configurations)''
* [[Package_management|Package Management (apk)]] ''(how to search/add/del packages etc.)''
** [[Package_management#Upgrade_a_Running_System|Upgrading Alpine]] ''(checking for and installing updates)''
** [[Repositories#Enabling_the_community_repository|Enabling the community repository]] ''(access to additional packages)''
* [[FAQ#Why_don.27t_I_have_man_pages_or_where_is_the_.27man.27_command.3F|man command/man pages]]
* [[Change default shell]]
* [[Running glibc programs]] ''(installation and development)''
 

* [[Alpine_local_backup|Local backup utility <code>lbu</code>]] ''(persisting RAM system configurations)''
** [[Back Up a Flash Memory Installation]] ''("diskless mode" systems)''
** [[Manually_editing_a_existing_apkovl]] ''(the stored custom configs)''
 

* [[OpenRC|Init System (OpenRC)]] ''(configure a service to automatically boot at next reboot)''
** [[Writing Init Scripts]]
** [[Multiple Instances of Services]]
 

* [[Alpine setup scripts#setup-xorg-base|<code>setup-xorg-base</code>]] ''(setup graphical base environment)''
** [[Tutorials_and_Howtos#Desktop|Desktop Environments]]
 

* [[Hosting services on Alpine]] ''(links to several mail/web/ssh server setup pages)''
 

* [[How to get regular stuff working]] ''(things one may miss in a too lightweight installation )''
* Running applications and services in their own [[Firejail Security Sandbox]]

=== Broader Usage Guides ===

* See: [[Tutorials and Howtos]]

= General Documentation =

{{Tip| Alpine Linux packages stay close to the upstream design. Therefore, all upstream documentation about configuring a software package, as well as good configuration guides from other distributions that stay close to upstream, e.g. those in the [https://wiki.archlinux.org/ Arch Wiki], are to a large degree, also applicable to configuring the software on Alpine Linux, thus can be very useful.}}

* [[FAQ|FAQs]]

* [[Contribute|How to Contribute]]
* [[Developer Documentation]]
* [[Alpine_Linux:Wiki_etiquette|Wiki etiquette]] ''(to collaborate on this documentation)''
* [[Comparison with other distros]] ''(how common things are done on Alpine)''

----
[[Category:Installation]]

Tutorials and Howtos

2022-09-18T11:23:01Z

Sliwkr: desktop - remove section that expanded on available window managers - this duplicated the content of Desktop environments and Window managers

{{Todo|This material has been re-organized..., but grouping should be checked: '''Howtos are smaller articles''' and '''tutorials are more detailed document'''}}

[[Image:package_edutainment.svg|right|link=]]
{{TOC left}}
'''Welcome to Tutorials and Howtos, a place of basic and advanced configuration tasks for your Alpine Linux.'''

'''The tutorials are hands-on''' and the reader is expected to try and achieve the goals described in each step, possibly with the help of a good example. The output in one step is the starting point for the following step.

'''Howtos are smaller articles''' explaining how to perform a particular task with Alpine Linux, that expects a minimal knowledge from reader to perform actions.

'''IMPORTANT:''' contributions on those pages must be complete articles as well as requesting topics to be covered, don't override already made contributions. If you want to request a topic, please add your request in this page's [[Talk:Tutorials_and_Howtos|Discussion]].

{{Clear}}

= Howtos =

== Applications ==

=== Miscellaneous ===

* [[Ansible]] ''(Configuration management)''

=== Monitoring ===

* [[Awstats]] ''(Free log file analyzer)''
* [[Cacti: traffic analysis and monitoring network]] ''(Front-end for rrdtool networking monitor)''
* [[Cvechecker]] ''(Compare installed packages for Common Vulnerabilities Exposure)'' 
* [[Dglog]] ''(Log analyzer for the web content filter DansGuardian)''
* [[Linfo]]
* [[Obtaining user information via SNMP]] ''(Using squark-auth-snmp as a Squid authentication helper)'' 
* [[PhpSysInfo]] ''(A simple application that displays information about the host it's running on)''
* [[Piwik]] ''(A real time web analytics software program)''
* [[Setting up A Network Monitoring and Inventory System]] ''(Nagios + OpenAudit and related components)'' 
** [[Setting up NRPE daemon]] ''(Performs remote Nagios checks)'' 
* [[Setting Up Fprobe And Ntop|Ntop]] ''(NetFlow collection and analysis using a remote fprobe instance)'' 
* [[Setting up lm_sensors]]
* [[SqStat]] ''(Script to look at active squid users connections)''
* [[Traffic monitoring]] 
** [[Setting up monitoring using rrdtool (and rrdcollect)]]
** [[Setting up traffic monitoring using rrdtool (and snmp)]] 
* [[Zabbix|Zabbix - the professional complete manager]] ''(Monitor and track the status of network services and hardware)''
* [[ZoneMinder video camera security and surveillance]]

=== Networking ===

* Alpine Wall ''(a new firewall management framework)''
** [[Alpine Wall]]
** [[Alpine Wall User's Guide]]
** [[How-To Alpine Wall]]
* [[Freeradius Active Directory Integration]]
* [[GNUnet]]
* [[Setting up a OpenVPN server|OpenVPN server]] ''(Allowing single users or devices to remotely connect to your network)''
* [[OpenVSwitch]]
* [[Using Alpine on Windows domain with IPSEC isolation]]
* [[Configure a Wireguard interface (wg)|Wireguard]]

=== Telephony ===

* [[Freepbx on Alpine Linux]]
* [[FreePBX V3]] ''(FreeSWITCH, Asterisk GUI web acces tool)''
* [[Sending SMS using gnokii]]
* [[Setting up Zaptel/Asterisk on Alpine]]
* [[Kamailio]] ''(SIP Server, formerly OpenSER)''

== Backup and data migration ==

* [[Alpine local backup|Alpine local backup (lbu)]] ''(Permanently store your modifications in case your box needs reboot)''
** [[Back Up a Flash Memory Installation]]
** [[Manually editing a existing apkovl]]
* [[Migrating data]]
* [[Rsnapshot]] - setting up periodic backups

== Desktop ==

* [[Alpine and UEFI]]
* [[Default applications]]
* Desktop cloud
** [[EyeOS]] ''(Cloud Computing Desktop)''
** [[Nextcloud]] ''(Self hostable cloud suite - Dropbox Alternative)''
** [[Oneye]] ''(Cloud Computing Desktop - Dropbox Alternative)''
** [[OwnCloud]] ''(Installing OwnCloud)''
** [[Seafile: setting up your own private cloud]]
* [[Desktop environments and Window managers]] (overall information only)
* [[Printer Setup]]
* [[Remote Desktop Server]]
* [[Sound Setup]]
** [[PipeWire]]
* [[Suspend on LID close]]
* [[Alpine setup scripts#setup-xorg-base|Xorg Setup]]

== Networking ==

* [[Bonding]] - Bond (or aggregate) multiple ethernet interfaces
* [[Bridge]] - Configuring a network bridge
** [[Bridge wlan0 to eth0]]
* [[Configure Networking]]
* [[How to configure static routes]]
* Modem
** [[Using HSDPA modem]]
** [[Using serial modem]]
* [[Multi ISP]] ''(Dual-ISP setup with load-balancing and automatic failover)''
* [[PXE boot]]
* [[Setting up Satellite Internet Connection|Satellite Internet Connection setup]]
* Wi-Fi
** [[Wi-Fi|Connecting to a wireless access point]]
** [[How to setup a wireless access point]] ''(Setting up Secure Wireless AP w/ WPA encryption with bridge to wired network)''
* [[Vlan]]

== Other Architectures ==

=== ARM ===

* [[Alpine on ARM]]

==== Raspberry Pi ====

* [[Raspberry Pi Bluetooth Speaker|Raspberry Pi - Bluetooth Speaker]]
* [[Raspberry Pi|Raspberry Pi - Installation]]
* [[Linux Router with VPN on a Raspberry Pi|Raspberry Pi - Router with VPN]]
* [[Linux Router with VPN on a Raspberry Pi (IPv6)|Raspberry Pi - Router with VPN (IPv6)]]
* [[Classic install or sys mode on Raspberry Pi|Raspberry Pi - Sys mode install]]
* [[RPI Video Receiver|Raspberry Pi - Video Receiver]] ''(network video decoder using Rasperry Pi and omxplayer)''
* [[Raspberry Pi 3 - Browser Client]] - kiosk or digital sign
* [[Raspberry Pi 3 - Configuring it as wireless access point -AP Mode]]
* [[Raspberry Pi 3 - Setting Up Bluetooth]]
* [[Raspberry Pi 4 - Persistent system acting as a NAS and Time Machine]]
* [[How to set up Alpine as a wireless router|Raspberry Pi Zero W - Wireless router]] ''(Setting up a firewalled, Wireless AP with wired network on a Pi Zero W)''

=== IBM Z (IBM z Systems) ===

* [[s390x|s390x - Installation]]

=== PowerPC ===

* [[Ppc64le|Powerpc64le - Installation]]

== Post-Install ==

* [[CPU frequency scaling]]
* [[Repositories#Enabling_the_community_repository|Enable Community repository]] ''(Providing additional packages)''
* [[Enable Serial Console on Boot]]
* [[Alpine Linux Init System|Init System (OpenRC)]] ''(Configure a service to automatically boot at next reboot)''
** [[Multiple Instances of Services|Init System - Multiple Instances of Services]]
** [[Writing Init Scripts|Init System - Writing Init Scripts]]
* [[Installing Oracle Java|Oracle Java (installation)]]
* [[IPTV How To|Internet Protocol television (IPTV)]]
* [[Alpine Linux package management|Package Management (apk)]] ''(How to add/remove packages on your Alpine)''
** [[Comparison with other distros|Package Management - Comparison with other distros]]
* [[Running glibc programs]]
* [[Setting up a new user]]
* [[Upgrading Alpine]]

== Remote Administration ==

* ACF
** [[Changing passwords for ACF|ACF - changing passwords]]
** [[Generating SSL certs with ACF]] 
** [[setup-acf| ACF - setup]] ''(Configures ACF (webconfiguration/webmin) so you can manage your box through https)''
* [[Setting up a ssh-server|ssh-server setup]] ''(Using ssh is a good way to administer your box remotely)''
** [[HOWTO OpenSSH 2FA with password and Google Authenticator |OpenSSH 2FA]] ''(A simple two factor setup for OpenSSH)''
* [[OpenVCP]] ''(VServer Control Panel)''
* [[PhpMyAdmin]] ''(Web-based administration tool for MYSQL)''
* [[PhpPgAdmin]] ''(Web-based administration tool for PostgreSQL)''
* [[Webmin]] ''(A web-based interface for Linux system)''

== Server ==

* [[Hosting services on Alpine]] ''(Hosting mail, webservices and other services)''
* [[Hosting Web/Email services on Alpine]]

=== DNS ===

* [[DNSCrypt-Proxy]] ''Encrypt and authenticate DNS calls from your system''
* [[Setting up nsd DNS server]]
* [[Setting up unbound DNS server]]
* [[TinyDNS Format]]

=== HTTP ===

* [[Apache]]
** [[Apache with php-fpm]]
** [[Setting Up Apache with PHP]]
** [[Apache authentication: NTLM Single Signon]]
* [[Cherokee]]
* [[Darkhttpd]]
* [[Lighttpd]]
** [[Lighttpd Advanced security]]
** [[Setting Up Lighttpd With FastCGI]]
* [[Nginx]]
** [[Nginx as reverse proxy with acme (letsencrypt)]]
** [[Nginx with PHP]]
* Squid Proxy
** [[Obtaining user information via SNMP]] ''(Using squark-auth-snmp as a Squid authentication helper)'' 
** [[Setting up Explicit Squid Proxy]]
** [[Setting up Transparent Squid Proxy]] ''(Covers Squid proxy and URL Filtering system)''
** [[SqStat]] ''(Script to look at active squid users connections)''
* [[Tomcat]]

==== Hostable Content ====

* [[DokuWiki]]
* [[Drupal]] ''(Content Management System (CMS) written in PHP)''
* [[Kopano]] ''(Microsoft Outlook compatible Groupware)''
* [[Mahara]] ''(E-portfolio and social networking system)''
* [[MediaWiki]] ''(Free web-based wiki software application)''
* [[Pastebin]] ''(Pastebin software application)''
* [[Phpizabi]] ''(Social Networking Platform)''
* [[Statusnet]] ''(Microblogging Platform)''
* [[WordPress]] ''(Web software to create website or blog)''

=== IRC ===

* [[How To Setup Your Own IRC Network]] ''(Using {{Pkg|charybdis}} and {{Pkg|atheme-iris}})''
* [[NgIRCd]] ''(Server for Internet Relay Chat/IRC)''

=== Mail ===

* Exim/Dovecot
** [[Small-Time Email with Exim and Dovecot]] ''(A simple configuration for your home network.)
** [[Setting up dovecot with imap and ssl]]
* [[relay email to gmail (msmtp, mailx, sendmail]]
* [[Roundcube]] ''(Webmail system)''
* [[Setting up postfix with virtual domains]]
* Server protection
** [[Protecting your email server with Alpine]]
** [[Setting up clamsmtp]]

=== Other Servers ===

* [[Chrony and GPSD | Chrony, gpsd, and a garmin LVC 18 as a Stratum 1 NTP source ]]
* [[Glpi]] ''(Manage inventory of technical resources)''
* [[How to setup a Alpine Linux mirror]]
* [[Setting up a nfs-server|nfs-server]]
* [[Odoo]]
* [[Configure OpenLDAP | OpenLDAP]] ''(Installing and configuring the Alpine package for OpenLDAP)''
* [[Setting up a samba-ad-dc|samba-ad-dc]] ''(Active Directory compatible domain controller)''
* [[Setting up a samba-server|samba-server]] ''(standard file sharing)''
* [[Setting up Transmission (bittorrent) with Clutch WebUI]]
* [[UniFi Controller]]

=== Software development ===

* [[Cgit]]
* [[OsTicket]] ''(Ticket system)''
* [[Patchwork]] ''(Patch review management system)''
* [[Redmine]] ''(Project management system)''
* [[Request Tracker]] ''(Ticket system)''
* [[Setting up trac wiki|Trac]] ''(Enhanced wiki and issue tracking system for software development projects)''

== Storage ==

* [[Setting up disks manually|Disk setup (manual)]]
* [[Disk Replication with DRBD|DRBD: Disk Replication]]
* [[Filesystems]]
** [[Burning ISOs]]
* [[Setting up iSCSI|iSCSI Setup]]
** [[iSCSI Raid and Clustered File Systems]]
** [[Linux iSCSI Target (TCM)|iSCSI Target (TCM)/LinuxIO (LIO)]]
* [[Setting up Logical Volumes with LVM|LVM Setup]]
** [[Setting up LVM on GPT-labeled disks|LVM on GPT-labeled disks]]
** [[Installing on GPT LVM|LVM on GPT-labeled disks (updated)]]
** [[LVM on LUKS]]
* RAID
** [[Raid Administration]]
** [[Setting up a software RAID array]]
* ZFS
** [[Root on ZFS with native encryption]]
** [[Setting up ZFS on LUKS]]

== Virtualization ==

* [[Docker]]
* [[Installing Alpine in a virtual machine]]
** [[Install Alpine on VirtualBox]]
** [[Install Alpine on VMware ESXi]]
* [[KVM]] ''(Setting up Alpine as a KVM hypervisor)''
* [[LXC]] ''(Setting up a Linux container in Alpine Linux)''
* [[QEMU]]
* Xen
** [[Xen Dom0]] ''(Setting up Alpine as a dom0 for Xen hypervisor)''
** [[Xen Dom0 on USB or SD]]
** [[Create Alpine Linux PV DomU|Xen DomU (paravirtualized)]]
** [[Xen LiveCD]]
** [[Xen PCI Passthrough]]

= Tutorials =

== Miscellaneous ==

* [[Dynamic Multipoint VPN (DMVPN)]] combined with [[Small Office Services]]
* [[DIY Fully working Alpine Linux for Allwinner and Other ARM SOCs]]
* [[Experiences with OpenVPN-client on ALIX.2D3]]
* [[Fault Tolerant Routing with Alpine Linux]]
* [[High Availability High Performance Web Cache]] ''(uCarp + HAProxy for High Availability Services such as Squid web proxy)''
* [[High performance SCST iSCSI Target on Linux software Raid]]
* [[ISP Mail Server HowTo]] ''(Postfix+PostfixAdmin+DoveCot+Roundcube+ClamAV+Spamd - A full-serivce ISP mail server)''
** [[ISP Mail Server Upgrade 2.x]]
** [[ISP Mail Server 2.x HowTo]] ''(Beta, please test)''
** [[ISP Mail Server 3.x HowTo]]
* [[Replacing non-Alpine Linux with Alpine remotely]]
* [[Setting up A Network Monitoring and Inventory System]] ''(Nagios + OpenAudit and related components)'' 
* [[Streaming Security Camera Video with VLC]]

== Newbie corner ==

* [[Alpine newbie]] (overall information)
* [[Alpine newbie developer]] (Developers: compilers, IDEs and tools)
** [[Alpine newbie developer: full stack web]]
** [[Alpine newbie developer: gitea|Alpine newbie developer: Git management web frontend gitea]]
* [[How to get regular stuff working]] ''some notes on need-to-know topics''

== Servers ==

* [[Alpine production deploy]]
** [[Production Web server: Lighttpd|Production web server: Lighttpd‎‎]]
** [[Production DataBases : mysql|Production database: MySql]]
** [[Production LAMP system: Lighttpd + PHP + MySQL‎‎]]
* Alpine production monitoring
** [[Cacti: traffic analysis and monitoring network]]
** [[Zabbix|Zabbix - the professional complete manager]]
* Kubernetes
** [[K8s]] Building a K8s Cluster on Alpine Linux