{"id":15626,"date":"2024-09-09T07:00:58","date_gmt":"2024-09-09T07:00:58","guid":{"rendered":"http:\/\/TheNextWeb=1410017"},"modified":"2024-09-09T07:00:58","modified_gmt":"2024-09-09T07:00:58","slug":"are-the-operating-systems-of-the-future-immutable","status":"publish","type":"post","link":"https:\/\/www.londonchiropracter.com\/?p=15626","title":{"rendered":"Are the operating systems of the future immutable?"},"content":{"rendered":"\n

Developers talk a lot about \u201cimmutability.\u201d Outside the technical world, it usually means something negative: unmoving, inflexible, and entrenched. However, in the technical field, these features become an advantage and mean that a system is reliable and reproducible.<\/span><\/p>\n

Like many concepts and trends in technology<\/a>, it\u2019s nothing new. <\/span>NixOS<\/span><\/a> (more on it later) has existed for over twenty years, and <\/span>ChromeOS<\/span><\/a> is probably the most widely used immutable operating system (OS). However, the widespread adoption of containers with <\/span>Docker<\/span><\/a> just over 10 years ago brought the concept to broader attention. <\/span><\/p>\n

Typically, you define a container in a text file, and a container runtime turns that definition into running services. This means it\u2019s relatively easy to shut down, recreate, and reboot the container based on that definition. No matter how many times you recreate and reboot it, you can rely on it being the same \u2014 immutable.<\/span><\/p>\n

Development teams<\/a> now use containers widely, managed and orchestrated by tools such as <\/span>Kubernetes<\/span><\/a>. Containers take the concept of immutability some of the way. <\/span><\/p>\n

\n
\n
<\/div>\n

\n

The <3 of EU tech<\/p>\n

The latest rumblings from the EU tech scene, a story from our wise ol’ founder Boris, and some questionable AI art. It’s free, every week, in your inbox. Sign up now!<\/p>\n<\/div>\n<\/div>\n<\/div>\n

There is still an operating system and many other levels of software surrounding them. Everything needs to be immutable to have a fully trustable, reliable, and reproducible operating system. <\/span><\/p>\n

This possibly sounds extreme to those of us who use Windows, macOS, or most distributions of Linux regularly. But from edge devices and servers to the desktop machines you and I use daily, immutable operating systems are now entering a practical reality.<\/span><\/p>\n

Why is this happening now? As Canonical\u2019s product manager of Ubuntu Core, Gabriel Aguiar Noury, tells me, it\u2019s because of the growth of cybersecurity regulations from governments around the World. \u201c<\/span>These regulations generally tell device makers and developers that things will change,\u201d Noury says. \u201cWe need to be more compliant. We need to be sure that every element in our products has a security plan, which includes security maintenance.\u201d<\/span><\/p>\n

The EU introduced <\/span>cybersecurity regulation<\/span><\/a> in 2019, and Noury adds that the act\u2019s deadline for compliance is bringing a lot of interest. <\/span>\u201cThe EU cybersecurity regulation is getting traction, and in 2027, we will start having to comply with it. So right now, we\u2019re in this period where we must make the devices we launch compliant with that. And, the idea of immutability plays into that.\u201d<\/span><\/p>\n

Nix and NixOS<\/b><\/h2>\n

Nix is the oldest still active immutable operating system. People often use \u201cNix\u201d and \u201cNixOS\u201d interchangeably, but they are different. Nix is a package manager used to build and install small dependencies, such as OpenSSL, to larger ones, such as Firefox or a programming language toolchain.<\/span><\/p>\n

As Valentin Gagarin, part of the Nix maintainer team, says: \u201c<\/span>Nix is many things to many people. But at the core, Nix is astonishingly simple.\u201d<\/span><\/p>\n

Almost every package you install doesn\u2019t live in isolation and uses its own complex tree of dependencies. To handle this and remain immutable, when you build and install a package with Nix, it retains a cryptographic hash of everything used to install that dependency at the time of installation. <\/span><\/p>\n

If you install the dependency again later, Nix creates a new hash, meaning you can switch back to the functioning version if there are issues. <\/span>\u201cNix wires up the relationships between files in a file system that become part of one application binary and records them in an immutable way,\u201d Gagarin says. \u201cWhenever you want to transfer these files somewhere else, pulling on one end gives you the entire thing rather than falling apart.\u201d<\/span><\/p>\n

NixOS takes this further. You can define the entire operating system from packages in the Nix package manager and the configuration of those packages. The configuration depends on the packages you install but could include boot devices, login messages, user accounts, and more. Also, Nix executes each process that creates these files in an isolated sandbox, further enhancing security.<\/span><\/p>\n

To anyone who has ever used mobile device management (MDM) or something similar to roll out consistent system images across a fleet of machines, this may not sound that revolutionary, but NixOS doesn\u2019t require sending large image files of multiple gigabytes across networks, it\u2019s just a text file built at rollout. <\/span><\/p>\n

Again, like the package manager, you can roll back if there\u2019s an issue. NixOS allows you to switch between different operating system configurations in the only time it takes to build that system. The same applies if an installation process is interrupted. On reboot, it restores the system to the last good state, and you can try again.<\/span><\/p>\n

Nix has developed these ideas for a long time despite their modern-sounding application. It has existed for more than 20 years and is older than Docker and Git.<\/span><\/p>\n

As Gagarin adds, it wasn\u2019t even first. \u201c<\/span>Nix was also not the first attempt to change Linux packaging. Nix had precursors, which essentially did the same thing but were more complicated and less accessible to the general Linux audience. And I think what made Nix different is its conceptual simplicity. And it\u2019s still around as opposed to many others.\u201d <\/span><\/p>\n

Community and business<\/b><\/h3>\n

The Nix community is open-source and donation-funded, with around 800 active monthly contributors. But the modern trend for immutability and how well Nix fits into it hasn\u2019t passed businesses by, even though Gagarin admits he isn\u2019t completely sure of the origins of the rise in interest. <\/span><\/p>\n

Three of the most interesting commercial products based on NixOS are <\/span>Determinate Systems<\/span><\/a>, <\/span>Flox<\/span><\/a>, and <\/span>DevBox<\/span><\/a>. All are in the early stages, but they and tools like them recognise that maybe the \u201csimpler\u201d world of developing using container runtimes such as Docker wasn\u2019t as simple as promised and offer an alternative.<\/span><\/p>\n

Ubuntu Core<\/b><\/h2>\n

When many think of Linux, they think of <\/span>Ubuntu<\/span><\/a> from <\/span>Canonical<\/span><\/a>. It\u2019s hard to get realistic numbers, as most sources report desktop usage, whereas, in reality, its data centres and servers are where Linux reigns supreme. <\/span><\/p>\n

Canonical\u2019s immutable offering, <\/span>Ubuntu Core<\/span><\/a>, is aimed not at desktop users but at edge devices. These are the small computing devices now found everywhere, from cars to robots to smart cities and industry. Often running only a handful of services on small embedded boards, edge devices are typically managed remotely, at scale, and running crucial functions where security and reliability are paramount. A perfect use case for an immutable operating system. <\/span><\/p>\n

Noury explains the use cases. \u201c<\/span>Think about the core operating system and the core elements of your device. They shouldn\u2019t change during normal operations, and you shouldn\u2019t need to maintain them.\u201d<\/span><\/p>\n

Instead, Ubuntu Core lets you focus on the unique functional components for your use case and trust that they won\u2019t change without your input. <\/span>\u201cWhen you are deploying a digital kiosk, smart home device, or robot running in a manufacturing line, you want to focus on tackling your problems and be sure that the components you rely on won\u2019t change until you change them,\u201d Noury adds. <\/span><\/p>\n

Canonical\u2019s <\/span>Snap format and Snap Store<\/span><\/a> are similar to the Nix package manager. Installing a dependency from the Snap Store contains all the dependencies at the time of installation, with additional protections that protect the host operating system from the \u201csnapped\u201d application. <\/span><\/p>\n

To any macOS user, this may sound a lot like installing from the App Store, but as Linux users are more used to building software<\/a> as they install, it\u2019s a more novel approach and one that divides the Linux community.<\/span><\/p>\n

Ubuntu Core works differently from NixOS. Instead of configuring with a text file, you use a series of models to define the core components of an operating system, such as the architecture, the base of the operating system, the snaps and snap versions to install, and the levels of security to use. <\/span><\/p>\n

With that done, you can roll out, build, and install an image across machines. If you use Canonical\u2019s <\/span>Multipass<\/span><\/a> tool, you can also create, test and build images locally in a virtual machine before rolling them out and browse pre-built images to base yours on.<\/span><\/p>\n

While Ubuntu Desktop remains non-immutable, it also has the Snap store for a degree of immutability, and <\/span>this post from a Canonical engineer<\/span><\/a> details how it <\/span>could<\/span><\/i> work.<\/span><\/p>\n

Fedora Silverblue and Vanilla OS<\/b><\/h2>\n

From one of the other big names in Linux distributions, <\/span>Fedora<\/span><\/a>\u2018s immutable offering, <\/span>Silverblue<\/span><\/a>, combines elements of NixOS and Ubuntu Core. For larger graphical applications, Silverblue uses <\/span>Flatpak<\/span><\/a>, which works similarly to the Snap Store (and App Store), distributing applications as one self-contained bundle. <\/span><\/p>\n

Developer tools use <\/span>Toolbx<\/span><\/a>, which in turn uses containers to allow developers to have a per-project series of functioning dependencies with no effect on the base operating system. However, there\u2019s no configuration file tying everything together as with NixOS and Ubuntu Core.<\/span><\/p>\n

Vanilla OS<\/span><\/a> is similar. The entire operating system isn\u2019t immutable, but key parts of it are. It has its own approach to a package manager in the form of <\/span>Apx<\/span><\/a>, which installs packages into a container, isolating everything from the host operating system and, again, making it easy to switch between versions. <\/span><\/p>\n

In addition to individual installations, you can also define developer environments based on other Linux distributions with Apx, which positions Vanilla OS as a kind of Linux hub. It also handles system updates differently, creating temporary partitions (again, based on container images) for the update that it only switches to after a successful reboot (recent versions of macOS do something similar). <\/span><\/p>\n

Finally, if you want to be extra cautious and immutable, you can make the entire file system read-only, meaning everything has to run in containers.<\/span><\/p>\n

Both Fedora Silverblue and Vanilla OS don\u2019t go to the immutable extremes that NixOS does, but they do make the most important and vulnerable parts immutable.<\/span><\/p>\n

Who to trust<\/b><\/h2>\n

Trust is a central aspect throughout this discussion. The selling point of immutable operating systems is that they are trustworthy and secure. But why should you trust them? <\/span><\/p>\n

As Noury says, \u201cimmutability doesn\u2019t necessarily mean security.\u201d At base, the preventatives are that they allow you to test and roll back if there are problems, and that typically, services run in isolated sandboxes (be that containers or something else), meaning that any rogue service can have minimal impact on anything else.<\/span><\/p>\n

For commercial offerings such as Ubuntu Core or commercially supported NixOS, the maintainers usually watch Common Vulnerabilities and Exposures (CVE) databases to ensure releases are vulnerability-free. Still, these sources are far from perfect and don\u2019t highlight bugs, so developers still need to do their own testing \u2014 which, thankfully, immutable operating systems make easier.<\/span><\/p>\n

An immutable future<\/b><\/h2>\n

As I\u2019ve covered throughout this article, even if you don\u2019t want to go all out with a fully immutable operating system like NixOS and all of the caveats that come with it, the increased need for security in modern consumer devices means that many of the operating systems you use are already partially immutable anyway, especially when it comes to installing updates. <\/span><\/p>\n

One of my recent articles covered Homebrew<\/span><\/a>, the package manager for macOS (and also now Linux), and that adds a degree of immutability to installing applications, depending on how you use it.<\/span><\/p>\n

While the communities around the immutable operating systems mentioned in this article have worked hard to build systems as accessible and usable as possible, a fully immutable operating system is still more complex than a \u201cconventional\u201d one. You need to understand that one application doesn\u2019t necessarily equal one installation and how to switch between them. Because of the multiple installations, they can also take up more disk space, which is easy to forget.<\/span><\/p>\n

I\u2019m not sure that fully immutable operating systems are the future of operating systems just yet, but some of their concepts and principles definitely are. They constitute a classic example of how, sometimes, it can take 20 years or more for a technical concept to find its time.<\/span><\/p>\n

Source<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"

Developers talk a lot about \u201cimmutability.\u201d Outside the technical world, it usually means something negative: unmoving, inflexible, and entrenched. However, in the technical field, these features become an advantage and mean that…<\/p>\n","protected":false},"author":1,"featured_media":15627,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1],"tags":[],"_links":{"self":[{"href":"https:\/\/www.londonchiropracter.com\/index.php?rest_route=\/wp\/v2\/posts\/15626"}],"collection":[{"href":"https:\/\/www.londonchiropracter.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.londonchiropracter.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.londonchiropracter.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.londonchiropracter.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=15626"}],"version-history":[{"count":0,"href":"https:\/\/www.londonchiropracter.com\/index.php?rest_route=\/wp\/v2\/posts\/15626\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.londonchiropracter.com\/index.php?rest_route=\/wp\/v2\/media\/15627"}],"wp:attachment":[{"href":"https:\/\/www.londonchiropracter.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=15626"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.londonchiropracter.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=15626"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.londonchiropracter.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=15626"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}