Alpine Linux - User contributions [en]

Alpine Linux:About

2010-10-09T07:01:41Z

Louipc: /* What's It Like? */

[[Image:knotes.svg|96px|left|link=]]
{{TOC right}}
'''Alpine Linux''' is a community-developed operating system designed for x86 Routers, Firewalls, VPNs, VoIP and servers.

Alpine Linux is and always will be '''free of charge'''. You do not pay any licensing fees. You can download, use and share Alpine Linux with anyone for absolutely nothing.

Alpine Linux was designed with security in mind. It has '''proactive security''' features, such as [http://en.wikipedia.org/wiki/PaX PaX] and [http://en.wikipedia.org/wiki/Stack-smashing_protection SSP], that prevent security holes from being exploited.

Alpine Linux uses the [http://en.wikipedia.org/wiki/UClibc uClibc] C library and all of the base tools from [http://en.wikipedia.org/wiki/BusyBox BusyBox]. These are normally found on embedded systems and are '''smaller''' than the tools found on GNU/Linux systems.

== Why Should I Try It? ==

We're partial, of course, but here are a few reasons:

* '''It's quick:''' You can boot it from a USB stick and have a very usable system in less than 10 minutes.
* '''It's simple:''' The [[Alpine Linux package management|package management]] and [[Alpine Linux Init System|init system]] is a breeze to use.
* '''It's more secure:''' When The Linux 0-day [http://en.wikipedia.org/wiki/Vmsplice%28%29_local_root_exploit vmsplice vulnerability] was causing admins everywhere to upgrade their kernels post-haste, Alpine Linux systems were basically impervious. Yes, the code crashed the application, but the PaX protection prevented system compromise. The value of PaX and SSP has been proven on more than one occasion.
* '''It's small:''' The traditional GNU/Linux base system is over 100MB in size (excluding the kernel), while the base system in Alpine Linux is only 4-5MB in size (excluding the kernel).
* '''It has the [[Alpine Configuration Framework Design|Alpine Configuration Framework (ACF)]]:''' While optional, ACF is a powerful web application used to configure an Alpine Linux device. ([[User:K0gen/ACF_Screenshots|Screenshots]])
* '''It's great for experimenting:''' Since the system configuration can be backed up to a single file, you will be able to test configurations before deploying them to production systems. (See [[Alpine local backup|Alpine Local Backup]].)
* '''It supports [http://linux-vserver.org/ Linux-VServer]:''' Similar to FreeBSD Jails, it allows you to run virtual servers.

== What's It Like? ==

Its network configuration is similar to Debian's and its package management is, in some ways, similar to Debian's APT or RedHat's yum, the BSDs' <code>pkg_*</code> commands (<code>apk_*</code> under Alpine), and Arch Linux's PKGBUILDs (<code>APKBUILD</code> under Alpine).

Also, if you've ever used a BusyBox-based system before, you would know that its applets do not support all of the features of their GNU/Linux counterparts. However, in an effort to make the system run like any other, the Alpine developers have contributed a number of enhancements to the BusyBox project.

Having said that, there are situations where things do not run like they do on a traditional GNU/Linux system. When you run into those situations, just remember these two things:

* The base installation is kept small enough for a firewall or router system, so there's not much there except the basics. (You can probably get away with just using the tools that are there, although crudely. When combined, tools like sh, awk, sed, and grep can do everything Perl can — seriously.)
* Alpine does have a complete set of packages, but you have to explicitly choose what to install.

== What Should I Know? ==

In addition to basic *nix management, you should know that...

* Alpine Linux uses [[Alpine Linux package management|apk-tools]] for its package management system and [http://roy.marples.name/projects/openrc OpenRC] for [[Alpine Linux Init System|its init system]]. You will need to learn how to use them both before you can effectively manage an Alpine Linux system.
* Alpine Linux uses the [[Alpine local backup|Alpine Local Backup Utility]] (<code>lbu</code>) primarily for RAM-based installs so you don't lose everything between reboots — however — it can also be used on HDD installs to test configurations before deploying them to production systems.
* In some cases, there is not a lot of documentation available, and what is available can be scattered about the wiki and/or mailing lists. We're working on it, but could use some help. Please see the [[Contribute]] page if you would like to help out.

== How did Alpine Linux Begin? ==

Alpine Linux began as a fork of the [http://en.wikipedia.org/wiki/LEAF_Project LEAF Project].

The active members of the LEAF Project wanted to continue making a Linux distribution that ran off of a single floppy disk — and we think that's great — however, our needs required Squid, DansGuardian, Samba, and a slew of other heavyweight applications. So, we ended up with a set of packages that fit onto a CD-ROM.

The LEAF concept of "run from RAM" has a number of appealing features, especially for a firewall:

* If your configs are all on a floppy, an upgrade is as simple as burning a new CD and rebooting.
* If your configs are all on a (write-protected) floppy, recovering from a root-kit is as simple as rebooting.

Aside from the applications that we required, there were some things that we wanted to experiment with that wasn't easy to do in the LEAF build environment at that time, such as:

* A Complete Build-from-Source Environment (e.g. Gentoo-Style Build World)
* 2.6.x Kernel Support
* Stack-Smashing Support (SSP) in GCC
* PaX Kernel Security
* Better package management with dependencies, upgrade path, pre- and post-install scripts, etc.

And so the project began.

Although Alpine Linux won't fit on a floppy disk today, it has and always will be our goal to keep it as small and simple as possible.

== Why the Name Alpine? ==

"Alpine" originally stood for A Linux Powered Integrated Network Engine. The idea was that the distribution would be focused on networking, and be a tiny "engine" or framework, which larger systems could be built upon.

Today, "Alpine" is nothing more than a name, despite continuing to live up to its original name. As an example, here are a few of Alpine's achievements and real-world uses:

* The first open-source implementation of Cisco's DMVPN, called [http://sourceforge.net/projects/opennhrp/ OpenNHRP], was written for Alpine Linux.
* In addition to its use as a firewall or router system, Alpine Linux is also used in a number of installations as the basis for enterprise servers, running such software as PostgreSQL, Postfix, Asterisk, Kamailio, and being used for iSCSI SANs. It is the little engine that could.

Creating an Alpine package

2010-10-09T07:00:58Z

Louipc: /* depends & makedepends */

== General ==

This document assumes that you have a working [[Setting up the build environment|build environment]], or use a diskbased alpine installation.

=== The APKBUILDs ===

The ''[http://dev.alpinelinux.org/cgit/abuild/ abuild]'' script reads the ''[http://dev.alpinelinux.org/cgit/abuild/tree/sample.APKBUILD APKBUILD]'' and executes the steps needed to create a package.

=== The aports tree ===

The [http://dev.alpinelinux.org/cgit/aports aports] tree is a [http://dev.alpinelinux.org/cgit/aports/tree directory tree] with many APKBUILDs. Those files are used when building alpine from source.

== Installing and configuring the alpine-sdk ==

The alpine-sdk is a metapackage that pulls in the most essential packages used to build new packages. 
Install those packages now:

apk add alpine-sdk

This would be a good time to create a normal user account for you to work in. (You weren't going to develop as root now, were you!) To create the user:

adduser <yourusername>

To make life easier later, it's a good idea to add this user to /etc/sudoers. Append the line

<yourusername> ALL=(ALL) ALL

using the command:

visudo

Now logout of the root account, and login as <yourusername>. From here on everything can be done in a normal user account, and operations that require superuser privileges can be done with sudo.

The aports tree is in git so before we clone the aports tree we should configure git.

git config --global user.name "Your Full Name"
git config --global user.email "your@email.address"

Now we can clone the aports tree.

git clone git://dev.alpinelinux.org/aports

Before we start creating or modifying APKBUILD files we need to setup abuild to our system/user. Edit the file abuild.conf to your requirements. Most of the defaults can be left alone, unless you are developing for a custom platform, in which case the comments in the file should guide you. The one field to edit is PACKAGER, so that you can get credit (or blame) for packages you create.

sudo vi /etc/abuild.conf

The last step in preparation is to configure the security keys for abuild with the command:

abuild-keygen -a -i

== Getting some help ==

It might be wise to start by checking what the abuild program can/cannot do.

abuild -h

== Creating an APKBUILD file ==

=== Use a template APKBUILD ===

To create the actual APKBUILD file abuild has the option -n (new). It will simply copy an example/template APKBUILD file to the given directory and fill some variables. 
If you are create a daemon package which needs initd scripts you can add the -c making it:

abuild -c -n ''packagename''

'''''NOTE:''' The 'packagename' is a parameter to the -n option so order of -c and -n matters. Further, on newer Alpine systems, 'newapkbuild' has replaced abuild with the -n switch.''

This will copy the sample initd and confd files to the build directory. 
A third file sample.install file will be copied as well (we will discuss this later on).

=== 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 ====

Source is not only the link from which abuild will fetch the source, it should also hold all files abuild needs to build the apk. This could mean initd file, confd file, install file, patches or any other file needed. When you are finished adding them you can execute the following command to add their checksums to the APKBUILD file:

abuild checksum

Another thing to note is when a package is using sourceforge for hosting. If so you should specify the special mirrors link used by sf:

http://downloads.sourceforge.net/$pkgname/$pkgname-$pkgver.tar.gz

(or similar depending on the package).

Currently abuild supports the following archives/extensions:

*.tar.gz, *.tgz, *.tar.bz2, *.tar.lzma, *.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 [http://en.wikipedia.org/wiki/Rtfm RTFM].

No kidding, lots of important information can be found it the package INSTALL and README file (or the likes). Another good way is the run ./configure --help from the source directory to see which options are needed for configure to finish without errors. If you do not yet have a src directory you can create one with the command:

abuild unpack

Running configure will also show you how you can disable a specific option for this package. A good example is for instance "--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 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).

[http://www.gentoo-portage.com Search ebuilds]

[http://sources.gentoo.org/viewcvs.py/gentoo-x86/ Gentoo CVS]

[http://www.archlinux.org/packages/search/ Arch Linux packages]

After the package is successfully compiled and created we should make sure it didn't link to any package that is not present in the $depends variable. We do this by using scanelf. If scanelf is not yet installed on your system you can do that by installing pax-utils.

scanelf -nR pkg

An example output of libcurl would be:

ET_DYN libssl.so.0.9.8,libcrypto.so.0.9.8,libz.so.1,libc.so.0,ld-uClibc.so.0 pkg/usr/lib/libcurl.so.4.1.1

You can see the needed files and should be able to find out which file belongs to which package.

==== license ====

If a package has a special/custom license we need to provide it with the release. 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 build() function, depending on the license description file:

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.

==== url ====

Website address for the program. This is usefully 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.

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 if you change something to your APKBUILD file without changing the actual $pkgver you can higer 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 pkgver so apk finds this update and add the missing dependency.

==== 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:

===== $pkgname.pre-install =====
This script is executed before package is installed. Typical use is when package needs a user/group to be created. For example:
<pre>
#!/bin/sh
adduser -H -s /bin/false -D 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 apk add will exit with failure.

===== $pkgname.post-install =====
This script is executed after package is installed. Can be used to generate font cache and similar.

===== $pkgname.pre-upgrade =====
Same as pre-install but is executed before upgrading an already installed package.

===== $pkgname.post-upgrade =====
Same as post-install but is executed after upgrading an already installed package.

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

===== $pkgname.post-deinstall =====
This script is executed after a package have been uninstalled. Can be used to update font caches and restore busybox links. For example:
<pre>
#!/bin/sh
busybox --install -s
</pre>

If the package have an pre-install and post-install script the APKBUILD should have the ''install'' variable defined and the scripts should also be added to the source variable:
<pre>
...
install="$pkgname.pre-install $pkgname.post-install"
source="http://....
$install"
...
</pre>

==== subpackages ====

$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:

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:

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 applications will have except doc and dev files other non needed at run time files which we want to separate away from the base package. 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/
}

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 ====

Please make sure you always submit human readable patches. Way's to create them are:

directory compare:

diff -urp original_directory new_directory > filename.patch

file compare:

diff -up original.file new.file > filename.patch

If you are going to use multiple patches for a single package, the preferred way to handle those is a loop and numbering the patches.

for i in "$srcdir"/*.patch; do
msg "Applying ${i}"
patch -p0 -i $i || return 1
done

Because multiple patches can patch the same file, we could create offset for the next patch. To make sure we always patch in a specified way we should number the patches as followed:

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

This way we are always sure patch 1 is first and if we want to add additional patches between them we can use 11,12,21,22...

==== Configure options ====

Alpine has some default configure options we set by default. We use /usr for prefix to make sure everyting is installed with /usr in front of it. If you notice that anything is installed in the wrong directory please run ./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 [http://www.gnu.org/software/make/manual/make.html#Parallel parallel] building/installing. A normal make line would be:

make || return 1

To disable parallel we use:

make -j1 || return 1

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:

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 sudo when needed. If by accident the Makefile does not support DESTDIR variable it will fail to install in our build system system directories.

==== 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):

install -Dm644 doc/$pkgname.conf "$pkgdir"/etc/$pkgname.conf

== Build the package ==

If you did not already create the checksums as mentioned above you can do so now:

cd $pkgname
abuild checksum

Its about time we build our package. Because a build system should never have all the package installed to prevent linking to packages we dont want it to link we use a abuild recursively with the -r switch. It will install all dependency's from your repository and builds it, afterwards it will uninstall all those depending packages again. You could also use the -R switch which would build your package including the dependency packages.

abuild -r

== Commit your work ==

After you successfully build your package you can submit your APKBUILD to alpine git repository.

Update you git repo, before adding new files:

cd $aportsdir
git pull

This should pull all the changes made by others into you local git repo. When you think you are ready you can add your files to git:

cd $apkbuilddir
git add APKBUILD (include any other files needed for the build; $pkgname.install...)
git commit

Now your changes are only available locally in your repo. Because you do not have push rights to the alpine repo you need to create diff (patch) of the changes you made:

git format-patch -1

Where -1 sets how many commits you want to go back (mostly this is 1). This should create a patch called 0001......patch.

An easy way to send this patch to the list is with an program called 'email'.

apk_add email

to send to the mailing list you would do:

email -a 0001...patch alpine-devel@lists.alpinelinux.org

And provide a subject and body after you execute the above cmd.

 If you doubt to which repo your package belongs to you can safely use testing.