diff --git a/source/clear-linux/concepts/swupd-about.rst b/source/clear-linux/concepts/swupd-about.rst index ef1d9ee0..743f8b69 100644 --- a/source/clear-linux/concepts/swupd-about.rst +++ b/source/clear-linux/concepts/swupd-about.rst @@ -3,130 +3,78 @@ Software update ############### -|CL-ATTR| does software updates differently than traditional Linux-based -operating systems. Where traditional distributions rely on packages for -software deployment, |CL| uses the concept of a "bundle" for -deployment. Traditional Linux packages provide a particular utility or -library; |CL| bundles provide all necessary packages to enable a -specific function. +swupd is an OS-level software update program that applies updates to a +|CL-ATTR| or derivative. -With |CL|, updating equates to an entirely new OS version with a -specific set of bundles, as compared to a package-based distribution in -which packages may be updated individually. |CL| updates are -efficient, updating only changed files instead of entire packages. - -System administrators can customize or add bundles to the OS, while still -taking advantage of a controlled update stream. This enables system -administrators to focus on the pieces that make their deployment unique. +While traditional Linux\*-based distributions rely on packages for software +deployment, |CL-ATTR| uses bundles. In a traditional Linux\* distro, +packages provide a particular utility or library and are updated +individually. In contrast, the |CL| update process equates to installing an +entirely new OS version with a specific set of bundles. Extremely efficient, +updates only change files instead of entire packages. +Visit the `swupd man page`_ for more details. Bundles ======= -While we use packages to manage compiling source code into installable -binaries, we do not deploy software through packages. Instead, we use bundles -to deploy software, where each bundle encapsulates a particular functionality --- functionality that is enabled by composing all the required upstream -open-source projects and packages into one logical unit: a bundle. This -simplifies installing features on |CL|. +While |CL| uses packages to manage compiling source code into installable binaries, it does not deploy software through packages. Instead, |CL| uses bundles to deploy software. Each bundle encapsulates a particular functionality, which is enabled by composing all the required upstream open-source projects and packages into one logical unit. This simplifies installing features on the OS. For more resources, visit: -For additional resources regarding available bundles, useful bundle commands, -and compatible |CL| kernels, visit our :ref:`bundles-about` -page. +* :ref:`bundles` +* :ref:`bundles-about` +* :ref:`bundle commands` +* :ref:`compatible-kernels` Versioning ========== -In a traditional distribution, the process of describing current software -versioning usually involves: - -- Listing and keeping track of the current OS release (generally - uninformative about any singular packages or functionality). - -- Keeping track of packages and repositories being used, and updating them - individually. - -- Listing and tracking every package available and installed on the - system, none of which are directly tied to the current OS release. - -This can be done effectively, but given the nearly endless combinations of -packages and versions of packages a server may have, it quickly becomes -non-trivial to define what "version" the system is and what software it -is running without explicitly going through each system and inspecting -every package. - -With |CL|, we need only track: - -- One single number - -A number representing the **current** release of the OS is sufficient to -describe the versions of all the software on the OS. Each build is -composed of a specific set of bundles made from a particular version of -packages. This matters on a daily basis to system administrators, who -need to determine which of their systems do not have the latest security -fixes, or which combinations of software have been tested. Every release -of the same number is guaranteed to contain the same versions of software, -so there's no ambiguity between two systems running the same version of |CL|. +In a traditional Linux\* distro, describing current software versioning +involves keeping track of the current OS release and keeping track of the +packages while individually updating them. Packages are not directly tied +to the current OS release. +In |CL|, one single number represents the **current** release of the OS. +This number describes the versions of **all** the software on the OS. Each +release is composed of a specific set of bundles made from a particular +version of packages. This process offers other distinct advantages. System +administrators can be assured that all systems benefit from the latest +security fixes, all combinations of software have been tested, and all +package conflicts are resolved at build time. Further, every release--and by extension every target OS--that shares the same number is guaranteed to have the same versions of software. Updating ======== -Another notable difference between package-based distributions and |CL| -is how updates are managed. On a package-based OS, system administrators update -each individual package or piece of software to a newer (or older!) version. With -|CL|, an update translates to an entirely new OS version, containing one -or many updates. It is not possible to update a piece of the system while -remaining on the same version of |CL|. +|CL| promotes regular updating of the OS, automatically checking +for updates, and applying them by default. On a package-based OS, system +administrators update each individual package or piece of software. In |CL| +an update translates to an entirely new OS version, containing one or many +updates. It is not possible to update a piece of the system while remaining +on the same version of |CL|. -How is this useful? Although it seems, at first, like a huge restriction -or limitation, this method has many non-obvious benefits. Imagine a -cloud environment composed of numerous machines. Here, a homogeneous set of -software makes sense -- from the system administrator's level down to the -user level. Homogeneous systems allow users to focus on their contributions -and/or code, rather than configuring environments or worrying about -synchronizing versions and updates. At the system admin level, it ensures -security is tighter and makes it far easier to monitor and update patches. +While this may seem like a limitation, the method has several benefits: -|CL| promotes regular updating of the OS and will automatically check -for updates and apply them by default. +* In a cloud environment, |CL| allows you to run the exact same software + for all container hosts in a cluster. -To learn how to run an update of your system, visit our :ref:`swupd-guide` page. +* |CL| intends to help developers create custom |CL| derivatives. Using + :ref:`mixer `, system administrators can focus on customizing their deployments while staying on a controlled update stream. +* Regular updates ensure :ref:`security` is tighter, so it is + much easier to monitor and update patches. + +Learn how to update your system using :ref:`swupd `. Update speed -============ +------------ -Software updates with |CL| are also efficient. Bundles simply describe -a set of files, and the update technology updates *only* files that actually -changed by using binary-delta technology for efficiency [1]_. Operating systems -that use packages as the unit of deployment require full package updates (thus -hogging resources), even when one small file in that package has changed. +Software updates with |CL| are also efficient. Whereas an OS that uses +packages requires full package updates, bundles simply describe +a set of files, and updates are made *only* to files that actually +changed by using binary-delta technology [1]_. With this method, the OS +updates only those bits that changed, yielding very small update content ( +deltas) that are applied exceedingly fast. Major security patches and core update take merely seconds. -It is quite common for a full OS update fixing a security hole to be -only 15 kilobytes in total update size. If only several kilobytes need -to be changed, it does not make sense to re-download and reinstall an -entire package or suite of programs just to incorporate a minuscule (yet -important) update. Through binary deltas, the OS is able to update only -those bits that changed, yielding very small update content (deltas) -that can be applied exceedingly fast. As a result, major security patches -and core update take merely seconds. +.. [1] The software update technology for |CL-ATTR| was first presented at the Linux Plumbers conference in 2012. - -Customize the OS -================ - -While we realize our definition of bundles makes sense to us, data center -operators may have special needs and ideas. Therefore, we provide a -:ref:`mixer tool `. This tool allows users to customize and add bundles -or even add their own software, while keeping the operating -system and its updates as the basis. Using this tool, system administrators -can focus on the customization their deployments require while staying on -a controlled update stream. - -To learn more about mixing, visit our :ref:`mixer-about` page. - - -.. [1] The software update technology for |CL-ATTR| was first presented at the - Linux Plumbers conference in 2012. +.. _swupd man page: https://github.com/clearlinux/swupd-client/blob/master/docs/swupd.1.rst \ No newline at end of file