Learn Alpine Linux - History, Background & Why You Need It

#Introduction

Before writing any configuration, it's important to understand where Alpine Linux comes from and why its design looks "different" from other distros. Episode 1 traces the birth history of Alpine, the philosophy that shaped it, its major release history, and the practical reasons why so many people now need it.

A question that always comes up: why choose Alpine over Ubuntu or Debian? The answer isn't about having the newest version, but three design pillars: small, simple, and secure. Let's unpack each of them one by one.

#The Birth of Alpine

#A Distro for Small Routers

Alpine Linux was born in 2010 out of a small router project that wanted an extremely compact yet still maintainable Linux system. The project grew out of a base system called LEAF (Linux Embedded Appliance Framework), and was then rebuilt into the standalone distro we know today. Its original focus was indeed embedded and networking devices: routers, firewalls, and small appliances.

That's why Alpine isn't built on the heavy GNU toolchain. Instead, Alpine uses musl libc as its C library and BusyBox as its utility set — two fundamental decisions that persist to this day and that we'll examine in episode 2.

#The "Small. Simple. Secure." Philosophy

Alpine Linux's official motto is "Small. Simple. Secure." These three words aren't just a slogan; they're design criteria:

• Small: the base image is only about 5 MB and the installer ISO is only a few dozen MB.
• Simple: a minimal system structure, plain-text configuration, and tooling that's easy to understand.
• Secure: the kernel is patched with PAX mitigations and hardening, musl offers better memory safety, and the system runs with a small attack surface.

Choosing musl and BusyBox reduces size while also reducing the amount of exploitable code. This is the main reason Alpine is often used as a secure container base image.

Beyond that, Alpine follows a disciplined semi-annual release model: a new version ships around May and December, with a support cycle of about two years per major version. That means you can always use a fresh stable version without waiting too long, and you have plenty of time to plan migration between versions. This release behavior is also why so many cloud tools and container images use Alpine as their foundation.

#Major Release History

Alpine ships a major version twice a year, and some of them bring significant changes:

• 3.8 (2018): a big leap in the toolchain and the 4.14 LTS kernel.
• 3.14 (2021): the transition to OpenSSL 3 by default, marking a cryptography modernization.
• 3.19 (2023): full Raspberry Pi 5 support and the 6.6 LTS kernel.
• 3.23 (December 2025): the launch of apk v3 and the replacement of linux-edge with linux-stable.
• 3.24 (June 2026): the latest stable release with the newest LTS kernel and a maturing apk v3.

Besides the releases above, Alpine also maintains an always-active edge branch: where the latest package development happens before being pushed into the next stable release. For general users, edge is useful for sampling new features, but for production you should stay on a stable release.

Check your release version with the following commands:

cat /etc/alpine-release
apk --version
uname -r

From the apk --version output, you can see whether you're using apk v2 or v3 — we cover this difference fully in episode 4. For context, Alpine 3.23 and 3.24 use apk v3, while all releases before 3.23 use apk v2. Even though the everyday command syntax is the same, the index format and dependency resolution speed differ significantly.

It's also important to note that every Alpine major version is supported for about two years. This means you can stay on one version for a long time, but you still need to plan the migration before the support window ends. The endoflife.date website always carries Alpine's release and end-of-support schedule for production planning.

#Why You Need Alpine

#Minimal Size and Footprint

Alpine is one of the most resource-efficient distros. The alpine:latest container image is only about 5 MB, so image pulls are fast, disk usage is low, and container cold-start times are short. On both physical servers and VMs, Alpine's RAM requirements are very low — it runs comfortably on devices with 256 MB of RAM. This makes it a top choice for cloud, edge, and embedded devices.

#Security by Design

Security in Alpine is designed in from the start, not bolted on later:

• musl libc has better memory-safety habits and a smaller code surface than glibc.
• Alpine's kernel has historically applied PAX/Grsecurity hardening.
• OpenRC, being non-systemd, means fewer components running, and each service only runs what it needs.
• Packages are compiled with hardening flags like -fstack-protector-strong and PIE by default.

Check the system's basic security with:

id
ps aux | wc -l

The output of ps aux | wc -l on Alpine is usually far fewer lines than on systemd-based distros because so few components are running. Also try ps aux --sort=-rss | head -5 to see which processes use the most memory — on Alpine you'll notice there are no resource-hungry daemons.

#Popular as a Container Base Image and Firewall

Alpine's two biggest use cases are:

• Container base image: alpine:latest is used by millions of containers worldwide because it's small and fast.
• Router and firewall: its lightweight nature makes Alpine a classic choice for gateways, VPNs, and network appliances.

In episode 10 we'll build an nftables firewall, and in episode 16 we'll use Alpine as a base image. Both of these use cases come directly from the design decisions covered in episode 1.

For developers coming from the container world, there's one more practical reason: Alpine uses lightweight namespaces and tooling, so starting a container takes very little time and resources. When you run hundreds of containers on a single node, saving a few MB per container quickly accumulates into big savings in memory and disk.

#Closing

Episode 1 explains where Alpine comes from and why its design is unique: born in 2010 for small routers, built on musl libc and BusyBox, guided by the Small Simple Secure motto, and now the distro of choice for containers and network devices.

Key takeaways:

• Alpine was born in 2010 as a distro for routers and embedded devices.
• Its three design pillars are Small, Simple, and Secure.
• musl libc and BusyBox are the two fundamental decisions that set it apart.
• Major releases that matter: 3.14 (OpenSSL 3), 3.19 (RPi 5), 3.23 (apk v3), and 3.24.
• Alpine's base image is only about 5 MB with a low RAM footprint.
• Alpine is popular as a container base image and firewall.

In the next episode, episode 2, we'll discuss Alpine's core concepts and main architecture — the deep differences between musl libc and glibc, how BusyBox and its applets work, apk's architecture with the main, community, and testing repositories, and the role of the linux-lts and linux-stable kernels.