1.1 Zrýchlené školenie jazyka Scheme

Guix používa Guile implementáciu jazyka Scheme. Ak si chcete tento jazyk vyskúšať, nainštalujte si Guile pomocou guix install guile a spustite REPL, tzv. slučku čítaj-vykonaj-zobraz, zadaním guile v príkazovom riadku.

Môžete tiež použiť príkaz guix shell guile -- guile ak nechcete inštalovať Guile do vášho používateľského profilu.

Riadky v nasledovných príkladoch znázorňujú to, čo treba zadať v rámci REPL; riadky začínajúce na „⇒“ znázorňujú výsledok vykonania príkazu, zatiaľ čo riadky začínajúce na „-|“ znázorňujú to čo sa zobrazí na obrazovke. See Using Guile Interactively in GNU Guile Reference Manual, pre viac podrobností o REPL.

• Skladbu jazyka Scheme si možno predstaviť ako strom výrazov (alebo ako s-expression v jazyku Lisp). Výrazom môže byť priama konštanta, napr. číselná hodnota či reťazec znakov, alebo môže predstavovať zoznam iných zložených prvkov a priamych konštánt ohraničený v zátvorkách. #true a #false (skrátene #t a #f) znázorňujú logické hodnoty „pravda“ a „nepravda“.

  Príklady platných výrazov:

  "Ahoj svet!"
  ⇒ "Ahoj svet!"
  
  17
  ⇒ 17
  
  (display (string-append "Ahoj " "Guix" "\n"))
  -| Ahoj Guix!
  ⇒ #<unspecified>
  

• Tento posledný príklad znázorňuje volanie funkcie vnorené do iného volania funkcie. Pri vykonávaní výrazu v zátvorkách predstavuje prvá položka funkciu a zvyšok sú parametre volania. Návratová hodnota každej funkcie je výsledok vykonania posledného výrazu v nej.
• Anonymous functions—procedures in Scheme parlance—are declared with the lambda term:

  (lambda (x) (* x x))
  ⇒ #<procedure 120e348 at <unknown port>:24:0 (x)>
  

  Vyššie uvedená funkcia vracia druhú mocninu hodnoty jej parametra. Keďže všetko sa považuje za výraz, aj výraz lambda vracia bezmennú funkciu, ktorú je následne možné uplatniť na nejaký parameter:

  ((lambda (x) (* x x)) 3)
  ⇒ 9
  

  Procedures are regular values just like numbers, strings, Booleans, and so on.

• Všetkému je možné prideliť globálny názov pomocou define:

  (define a 3)
  (define druha-mocnina (lambda (x) (* x x)))
  (druha-mocnina a)
  ⇒ 9
  

• Funkcie možno zadávať aj v kratšom tvare s použitím nasledovnej skladby:

  (define (druha-mocnina x) (* x x))
  

• Zoznam je možné vytvoriť pomocou funkcie list:

  (list 2 a 5 7)
  ⇒ (2 3 5 7)
  

• Standard procedures are provided by the (srfi srfi-1) module to create and process lists (see list processing in GNU Guile Reference Manual). Here are some of the most useful ones in action:

  (use-modules (srfi srfi-1))  ;import list processing procedures
  
  (append (list 1 2) (list 3 4))
  ⇒ (1 2 3 4)
  
  (map (lambda (x) (* x x)) (list 1 2 3 4))
  ⇒ (1 4 9 16)
  
  (delete 3 (list 1 2 3 4))        ⇒ (1 2 4)
  (filter odd? (list 1 2 3 4))     ⇒ (1 3)
  (remove even? (list 1 2 3 4))    ⇒ (1 3)
  (find number? (list "a" 42 "b")) ⇒ 42
  

  Notice how the first argument to map, filter, remove, and find is a procedure!

• quote (jednoduchá úvodzovka) zabraňuje vykonaniu výrazu v zátvorke, ktorému sa tiež hovorí S-výraz alebo „s-exp“: prvá položka sa nevykoná ako volanie funkcie s ostatnými položkami ako parametrami (see quote in GNU Guile Reference Manual). Výsledkom je teda zoznam výrazov.

  '(display (string-append "Ahoj " "Guix" "\n"))
  ⇒ (display (string-append "Ahoj " "Guix" "\n"))
  
  '(2 a 5 7)
  ⇒ (2 a 5 7)
  

• quasiquote (`, obrátená jednoduchá úvodzovka) zabraňuje vykonaniu výrazu v zátvorke dovtedy, kým nie je jeho vykonanie opätovne povolené pomocou unquote (,, čiarky). Týmto spôsobom dopodrobna rozhodujeme o tom, čo sa vykoná a čo nie.

  `(2 a 5 7 (2 ,a 5 ,(+ a 4)))
  ⇒ (2 a 5 7 (2 3 5 7))
  

  Všimnite si, že hore uvedený výsledok je zoznam rôznorodých položiek: čísel, znakov (a) a posledná položka je tiež zoznam.

• Guix defines a variant of S-expressions on steroids called G-expressions or “gexps”, which come with a variant of quasiquote and unquote: #~ (or gexp) and #$ (or ungexp). They let you stage code for later execution.

  For example, you’ll encounter gexps in some package definitions where they provide code to be executed during the package build process. They look like this:

  (use-modules (guix gexp)           ;so we can write gexps
               (gnu packages base))  ;for 'coreutils'
  
  ;; Below is a G-expression representing staged code.
  #~(begin
      ;; Invoke 'ls' from the package defined by the 'coreutils'
      ;; variable.
      (system* #$(file-append coreutils "/bin/ls") "-l")
  
      ;; Create this package's output directory.
      (mkdir #$output))
  

  See G-Expressions in GNU Guix Reference Manual, for more on gexps.

• Pomocou let (see Local Bindings in GNU Guile Reference Manual) môžeme zadať a pomenovať viacero miestnych premenných:

  (define x 10)
  (let ((x 2)
        (y 3))
    (list x y))
  ⇒ (2 3)
  
  x
  ⇒ 10
  
  y
  error→ In procedure module-lookup: Unbound variable: y
  

  Ak chcete, aby bolo možné v neskorších zadaniach premenných odkazovať na predtým zadané premenné, použite let*.

  (let* ((x 2)
         (y (* x 3)))
    (list x y))
  ⇒ (2 6)
  

• Kľúčové slová sa bežne používajú na stotožnenie pomenovaných parametrov funkcie. Začínajú sa #: (mriežkou a dvojbodkou), po ktorých nasledujú písmenové či číselné znaky: #:takto. See Keywords in GNU Guile Reference Manual.
• Znak percento % je bežne používaný pre globálne premenné s prístupom len na čítanie počas zostavovania. Všimnite si, že je to len všeobecným zvykom, ako napr. _ v jazyku C. Scheme spracúva % ako hocijaký iný znak.
• Moduly sa vytvárajú pomocou define-module (see Creating Guile Modules in GNU Guile Reference Manual). Napríklad

  (define-module (guix build-system ruby)
    #:use-module (guix store)
    #:export (ruby-build
              ruby-build-system))
  

  určuje modul guix build-system ruby, ktorý má byť umiestnený v guix/build-system/ruby.scm niekde vo vyhľadávacej ceste Guilu. Závisí na module (guix store) a určuje dve premenné, ruby-build a ruby-build-system.

  See Package Modules in GNU Guix Reference Manual, for info on modules that define packages.

Dozvedieť sa viac: Scheme je jazyk, ktorý sa hojne využíva pri výuke programovania a sú na ňom založené mnohé podklady. V nasledovných dokumentoch sa môžete o Scheme dozvedieť viac:

• A Scheme Primer, od Christine Lemmer-Webberovej a Spritely Institute.
• Scheme at a Glance, od Steva Litta.
• Structure and Interpretation of Computer Programs, od Harolda Abelsona, Geralda Jay Sussmana a Julie Sussmanovej. Táto knižná príručka je bežne známa ako “SICP”.

  Môžete si ju tiež stiahnuť a prečítať na vašom počítači:

  guix install sicp info-reader
  info sicp
  

Ďalšie knihy, návody ako aj iné druhy zdrojov nájdete na https://schemers.org/.

2.1 Návod na zadávanie balíkov

GNU Guix sa vyznačuje ako prispôsobiteľný správca balíkov hlavne preto, že používa GNU Guile, výkonný vysokoúrovňový programovací jazyk, jedno z nárečí jazyka Scheme z jazykovej rodiny Lispu.

Zadania balíkov sú rovnako písané v jazyku Scheme, čo dáva Guixu jedinečnú výhodu v porovnaní s ostatnými správcami balíkov, ktoré používajú skripty shellu alebo jednoduché programovacie jazyky.

• Vo vašich zadaniach balíkov môžete využiť funkcie, štruktúry, makrá a všetku schopnosť vyjadrovania jazyka Scheme.
• Dedičnosť zjednodušuje prispôsobovanie balíka tým, že umožňuje zdediť vybraný jestvujúci balík a upraviť len to čo je potrebné.
• Dávkové spracovanie: celú zbierku balíkov je možné načítať, prefiltrovať a spracovať. Potrebujete zostaviť server bez grafického rozhrania? Dá sa to. Potrebujete opätovne zostaviť všetko zo zdrojových súborov s použitím odlišných optimalizačných príznakov? Pridajte parameter #:make-flags "..." do zoznamu balíkov. Tiež by nebolo od veci spomenúť Gentoo príznak USE, ale to je na dlhšie: tvorca balíkov nemusí vopred myslieť na tieto zmeny, pretože ich môže neskôr naprogramovať koncový používateľ!

Nasledovný návod vysvetľuje základy vytvárania balíkov s Guixom. Nepredpokladá žiadnu znalosť systému Guix ani jazyka Lisp. Čitateľ by však mal byť oboznámený s príkazovým riadkom a mať aspoň základnú znalosť programovania.

• Balík „Vitaj svet“
• Nastavenie
• Zložitejší príklad
• Ďalšie zostavovacie systémy
• Programovateľné a automatické zadávanie balíkov
• Získavanie pomoci
• Záver
• Odkazy

(define-public hello
  (package
    (name "hello")
    (version "2.10")
    (source (origin
              (method url-fetch)
              (uri (string-append "mirror://gnu/hello/hello-" version
                                  ".tar.gz"))
              (sha256
               (base32
                "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i"))))
    (build-system gnu-build-system)
    (synopsis "Hello, GNU world: An example GNU package")
    (description
     "GNU Hello prints the message \"Hello, world!\" and then exits.  It
serves as an example of standard GNU coding practices.  As such, it supports
command-line arguments, multiple languages, and so on.")
    (home-page "https://www.gnu.org/software/hello/")
    (license gpl3+)))

(use-modules (guix packages)
             (guix download)
             (guix build-system gnu)
             (guix licenses))

(package
  (name "my-hello")
  (version "2.10")
  (source (origin
            (method url-fetch)
            (uri (string-append "mirror://gnu/hello/hello-" version
                                ".tar.gz"))
            (sha256
             (base32
              "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i"))))
  (build-system gnu-build-system)
  (synopsis "Hello, Guix world: An example custom Guix package")
  (description
   "GNU Hello prints the message \"Hello, world!\" and then exits.  It
serves as an example of standard GNU coding practices.  As such, it supports
command-line arguments, multiple languages, and so on.")
  (home-page "https://www.gnu.org/software/hello/")
  (license gpl3+))

$ guix download mirror://gnu/hello/hello-2.10.tar.gz

Starting download of /tmp/guix-file.JLYgL7
From https://ftpmirror.gnu.org/gnu/hello/hello-2.10.tar.gz...
following redirection to `https://mirror.ibcp.fr/pub/gnu/hello/hello-2.10.tar.gz'...
 …10.tar.gz  709KiB                                 2.5MiB/s 00:00 [##################] 100.0%
/gnu/store/hbdalsf5lpf01x4dcknwx6xbn6n5km6k-hello-2.10.tar.gz
0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i

$ guix download mirror://gnu/hello/hello-2.10.tar.gz.sig

Starting download of /tmp/guix-file.03tFfb
From https://ftpmirror.gnu.org/gnu/hello/hello-2.10.tar.gz.sig...
following redirection to `https://ftp.igh.cnrs.fr/pub/gnu/hello/hello-2.10.tar.gz.sig'...
 ….tar.gz.sig  819B                                                                                                                       1.2MiB/s 00:00 [##################] 100.0%
/gnu/store/rzs8wba9ka7grrmgcpfyxvs58mly0sx6-hello-2.10.tar.gz.sig
0q0v86n3y38z17rl146gdakw9xc4mcscpk8dscs412j22glrv9jf
$ gpg --verify /gnu/store/rzs8wba9ka7grrmgcpfyxvs58mly0sx6-hello-2.10.tar.gz.sig /gnu/store/hbdalsf5lpf01x4dcknwx6xbn6n5km6k-hello-2.10.tar.gz
gpg: Podpis vytvorený Ne 16. november 2014, 13:08:37 CET
gpg:                pomocou RSA kľúča A9553245FDE9B739
gpg: Dobrý podpis od "Sami Kerola <kerolasa@iki.fi>" neznáme
gpg:                 alias "Sami Kerola (http://www.iki.fi/kerolasa/) <kerolasa@iki.fi>" neznáme
gpg: VAROVANIE: Tento kľúč nie certifikovaný dôveryhodným podpisom!
gpg:          Nič nenaznačuje tomu, že tento podpis patrí vlastníkovi kľúča.
Primárny fingerprint kľúča: 8ED3 96E3 7E38 D471 A005  30D3 A955 3245 FDE9 B739

$ guix package --install-from-file=my-hello.scm

$ guix package --list-installed=my-hello
my-hello	2.10	out
/gnu/store/f1db2mfm8syb8qvc357c53slbvf1g9m9-my-hello-2.10

  -f, --install-from-file=SÚBOR
                         inštalovať balíky priamo definované
                         v SÚBORE

mkdir ~/my-channel

(define-module (my-hello)
  #:use-module (guix licenses)
  #:use-module (guix packages)
  #:use-module (guix build-system gnu)
  #:use-module (guix download))

(define-public my-hello
  (package
    (name "my-hello")
    (version "2.10")
    (source (origin
              (method url-fetch)
              (uri (string-append "mirror://gnu/hello/hello-" version
                                  ".tar.gz"))
              (sha256
               (base32
                "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i"))))
    (build-system gnu-build-system)
    (synopsis "Hello, Guix world: An example custom Guix package")
    (description
     "GNU Hello prints the message \"Hello, world!\" and then exits.  It
serves as an example of standard GNU coding practices.  As such, it supports
command-line arguments, multiple languages, and so on.")
    (home-page "https://www.gnu.org/software/hello/")
    (license gpl3+)))

;; ...
(define-public my-hello
  ;; ...
  )

my-hello

guix show -L ~/my-channel my-hello
guix build -L ~/my-channel my-hello

cd ~/my-channel
git init
git add my-hello.scm
git commit -m "First commit of my channel."

(append (list (channel
                (name 'my-channel)
                (url (string-append "file://" (getenv "HOME")
                                    "/my-channel"))))
        %default-channels)

$ git clone https://git.savannah.gnu.org/git/guix.git

(define-module (gnu packages version-control)
  #:use-module ((guix licenses) #:prefix license:)
  #:use-module (guix utils)
  #:use-module (guix packages)
  #:use-module (guix git-download)
  #:use-module (guix build-system cmake)
  #:use-module (gnu packages compression)
  #:use-module (gnu packages pkg-config)
  #:use-module (gnu packages python)
  #:use-module (gnu packages ssh)
  #:use-module (gnu packages tls)
  #:use-module (gnu packages web))

(define-public my-libgit2
  (let ((commit "e98d0a37c93574d2c6107bf7f31140b548c6a7bf")
        (revision "1"))
    (package
      (name "my-libgit2")
      (version (git-version "0.26.6" revision commit))
      (source (origin
                (method git-fetch)
                (uri (git-reference
                      (url "https://github.com/libgit2/libgit2/")
                      (commit commit)))
                (file-name (git-file-name name version))
                (sha256
                 (base32
                  "17pjvprmdrx4h6bb1hhc98w9qi6ki7yl57f090n9kbhswxqfs7s3"))
                (patches (search-patches "libgit2-mtime-0.patch"))
                (modules '((guix build utils)))
                ;; Odstrániť pribalený softvér.
                (snippet '(delete-file-recursively "deps"))))
      (build-system cmake-build-system)
      (outputs '("out" "debug"))
      (arguments
       `(#:tests? #true                         ; Preveriť výsledok zostavenia (predvolené).
         #:configure-flags '("-DUSE_SHA1DC=ON") ; Zisťovanie rozporov v odtlačkoch SHA-1
         #:phases
         (modify-phases %standard-phases
           (add-after 'unpack 'fix-hardcoded-paths
             (lambda _
               (substitute* "tests/repo/init.c"
                 (("#!/bin/sh") (string-append "#!" (which "sh"))))
               (substitute* "tests/clar/fs.h"
                 (("/bin/cp") (which "cp"))
                 (("/bin/rm") (which "rm")))))
           ;; Bohatší výstup pri preverovaní zostavenia
           (replace 'check\n"
             (lambda* (#:key tests? #:allow-other-keys)\n"
               (when tests?\n"
                 (invoke \"./libgit2_clar\" \"-v\" \"-Q\"))))\n"
           (add-after 'unpack 'make-files-writable-for-tests
             (lambda _ (for-each make-file-writable (find-files "." ".*")))))))
      (inputs
       (list libssh2 http-parser python-wrapper))
      (native-inputs
       (list pkg-config))
      (propagated-inputs
       ;; Tieto dve knižnice sa nachádzajú v „Requires.private“ v libgit2.pc.
       (list openssl zlib))
      (home-page "https://libgit2.github.com/")
      (synopsis "Library providing Git core methods")
      (description
       "Libgit2 is a portable, pure C implementation of the Git core methods
provided as a re-entrant linkable library with a solid API, allowing you to
write native speed custom Git applications in any language with bindings.")
      ;; GPLv2 s odkazovou výnimkou
      (license license:gpl2))))

git clone https://github.com/libgit2/libgit2/
cd libgit2
git checkout v0.26.6
guix hash -rx .

#:make-flags (list (string-append "prefix=" (assoc-ref %outputs "out"))
                   "CC=gcc")

$ make CC=gcc prefix=/gnu/store/...-<out>

#:configure-flags '("-DUSE_SHA1DC=ON")

(define %standard-phases
  ;; Standard build phases, as a list of symbol/procedure pairs.
  (let-syntax ((phases (syntax-rules ()
                         ((_ p ...) `((p . ,p) ...)))))
    (phases set-SOURCE-DATE-EPOCH set-paths install-locale unpack
            bootstrap
            patch-usr-bin-file
            patch-source-shebangs configure patch-generated-file-shebangs
            build check install
            patch-shebangs strip
            validate-runpath
            validate-documentation-location
            delete-info-dir-file
            patch-dot-desktop-files
            install-license-files
            reset-gzip-timestamps
            compress-documentation)))

(add-to-load-path "/path/to/guix/checkout")
,use (guix build gnu-build-system)
(map first %standard-phases)
⇒ (set-SOURCE-DATE-EPOCH set-paths install-locale unpack bootstrap patch-usr-bin-file patch-source-shebangs configure patch-generated-file-shebangs build check install patch-shebangs strip validate-runpath validate-documentation-location delete-info-dir-file patch-dot-desktop-files install-license-files reset-gzip-timestamps compress-documentation)

(define* (unpack #:key source #:allow-other-keys)
  "Unpack SOURCE in the working directory, and change directory within the
source.  When SOURCE is a directory, copy it in a sub-directory of the current
working directory."
  (if (file-is-directory? source)
      (begin
        (mkdir "source")
        (chdir "source")

        ;; Preserve timestamps (set to the Epoch) on the copied tree so that
        ;; things work deterministically.
        (copy-recursively source "."
                          #:keep-mtime? #true))
      (begin
        (if (string-suffix? ".zip" source)
            (invoke "unzip" source)
            (invoke "tar" "xvf" source))
        (chdir (first-subdirectory "."))))
  #true)

(lambda* (#:key inputs outputs #:allow-other-keys)
  (let ((bash-directory (assoc-ref inputs "bash"))
        (output-directory (assoc-ref outputs "out"))
        (doc-directory (assoc-ref outputs "doc")))
    ;; ...
    #true))

$ guix import cran --recursive walrus

(define-public r-mc2d
    ; ...
    (license gpl2+)))

(define-public r-jmvcore
    ; ...
    (license gpl2+)))

(define-public r-wrs2
    ; ...
    (license gpl3)))

(define-public r-walrus
  (package
    (name "r-walrus")
    (version "1.0.3")
    (source
      (origin
        (method url-fetch)
        (uri (cran-uri "walrus" version))
        (sha256
          (base32
            "1nk2glcvy4hyksl5ipq2mz8jy4fss90hx6cq98m3w96kzjni6jjj"))))
    (build-system r-build-system)
    (propagated-inputs
      (list r-ggplot2 r-jmvcore r-r6 r-wrs2))
    (home-page "https://github.com/jamovi/walrus")
    (synopsis "Robust Statistical Methods")
    (description
      "This package provides a toolbox of common robust statistical
tests, including robust descriptives, robust t-tests, and robust ANOVA.
It is also available as a module for 'jamovi' (see
<https://www.jamovi.org> for more information).  Walrus is based on the
WRS2 package by Patrick Mair, which is in turn based on the scripts and
work of Rand Wilcox.  These analyses are described in depth in the book
'Introduction to Robust Estimation & Hypothesis Testing'.")
    (license gpl3)))

$ guix refresh hello

$ guix refresh hello --update

(define-public adwaita-icon-theme
  (package (inherit gnome-icon-theme)
    (name "adwaita-icon-theme")
    (version "3.26.1")
    (source (origin
              (method url-fetch)
              (uri (string-append "mirror://gnome/sources/" name "/"
                                  (version-major+minor version) "/"
                                  name "-" version ".tar.xz"))
              (sha256
               (base32
                "17fpahgh5dyckgz7rwqvzgnhx53cx9kr2xw0szprc6bnqy977fi8"))))
    (native-inputs (list `(,gtk+ "bin")))))

3.1 Automatické pripojenie k určitému TTY

Zatiaľ čo príručka pre Guix popisuje automatické prihlásenie jedného používateľa ku všetkým TTY (see auto-login to TTY in GNU Guix Reference Manual), mohol by vám viac vyhovovať stav, keď je jeden používateľ pripojený k jednému TTY a ostatné TTY sú nastavené na prihlasovanie ďalších používateľov alebo nikoho. Všimnite si, že jedného používateľa je možné automaticky prihlásiť k akémukoľvek TTY. Avšak, je lepšie vynechať tty1, ktorý je predvolene využívaný na zobrazovanie varovaných a chybových hlásení.

Takto je možné nastaviť automatické prihlásenie jedného používateľa k jednému TTY:

(define (auto-login-to-tty config tty user)
  (if (string=? tty (mingetty-configuration-tty config))
        (mingetty-configuration
         (inherit config)
         (auto-login user))
        config))

(define %my-services
  (modify-services %base-services
    ;; …
    (mingetty-service-type config =>
                           (auto-login-to-tty
                            config "tty3" "alice"))))

(operating-system
  ;; …
  (services %my-services))

Tiež je možné použiť compose (see Higher-Order Functions in The Guile Reference Manual) s auto-login-to-tty pre prihlásenie viacerých používateľov k viacerým TTY.

Varovanie na koniec. Nastavenie automatického prihlásenia k TTY znamená, že ktokoľvek môže zapnúť váš počítač a spúšťať príkazy ako zvyčajný používateľ. Hoci, ak používate zašifrovaný koreňový systém a pri spustení systému je nutné zadať heslo, automatické prihlásenie predstavuje praktickú možnosť.

3.2 Prispôsobenie jadra

Guix je, vo svojom jadre, distribúcia založená na zdrojových súboroch a náhradách (see Substitutes in GNU Guix Reference Manual). Zostavovanie balíkov z ich zdrojových súborov je teda prirodzenou súčasťou inštalácie a aktualizácie balíkov. Vzhľadom na túto skutočnosť dáva zmysel snaha o zníženie množstva času potrebného na zostavenie balíkov a nedávne zmeny v zostavovaní a šírení náhrad sú aj naďalej súčasťou rozhovorov vrámci projektu Guix.

Aj keď nevyžaduje veľké množstvo pamäte RAM, zostavenie jadra na priemerných počítačoch môže trvať veľmi dlho. Oficiálne nastavenie jadra, tak ako je to v prípade mnohých iných distribúcií GNU/Linuxu, sa prikláňa k širšej ponuke súčastí a to je to, čo spôsobuje, že zostavenie jadra zo zdrojových súborov trvá tak dlho.

Avšak, aj samotné jadro Linuxu možno opísať ako balík a teda prispôsobiť ho rovnako ako hociktorý iný balík. Postup je mierne odlišný, aj keď hlavne kvôli tomu ako je zadanie balíka napísané.

Balík jadra linux-libre je vlastne funkcia tvoriaca balík.

(define* (make-linux-libre* version gnu-revision source supported-systems
                            #:key
                            (extra-version #f)
                            ;; Funkcia vyžadujúca označenie a druh architektúry.
                            ;; Viď príklad v kernel-config.
                            (configuration-file #f)
                            (defconfig "defconfig")
                            (extra-options (default-extra-linux-options version)))
  ...)

Terajší balík linux-libre pre vydania 5.15.x je zadaný nasledovne:

(define-public linux-libre-5.15
  (make-linux-libre* linux-libre-5.15-version
                     linux-libre-5.15-gnu-revision
                     linux-libre-5.15-source
                     '("x86_64-linux" "i686-linux" "armhf-linux"
                       "aarch64-linux" "riscv64-linux")
                     #:configuration-file kernel-config))

Kľúče, ktoré nemajú pridelenú hodnotu dedia ich predvolenú hodnotu zo zadania make-linux-libre. Pri porovnávaní vyššie uvedených úryvkov zdrojového kódu si všimnite komentár odvolávajúci sa na #:configuration-file. Kvôli tomu vlastne nie je jednoduché zahrnúť do zadania svoje vlastné nastavenie jadra, ale nezúfajte, pretože jestvujú ďalšie spôsoby ako pracovať s tým čo máme.

Jestvujú dva spôsoby ako vytvoriť jadro s vlastným nastavením. Prvý je poskytnúť zvyčajný súbor .config počas zostavenia zahrnutím tohto súboru do pôvodných vstupov nášho vlastného jadra. Nižšie je uvedený úryvok kódu vlastného 'configure kroku zo zadania balíka make-linux-libre:

(let ((build  (assoc-ref %standard-phases 'build))
      (config (assoc-ref (or native-inputs inputs) "kconfig")))

  ;; Použiť vlastný alebo predvolený súbor
  ;; nastavenia jadra.
  (if config
      (begin
        (copy-file config ".config")
        (chmod ".config" #o666))
      (invoke "make" ,defconfig)))

Tu je príklad balíka jadra. Balík linux-libre nie je ničím výnimočný, môžeme ho zdediť a nahradiť jeho pôvodné polia ako pri hociktorom inom balíku:

(define-public linux-libre/E2140
  (package
    (inherit linux-libre)
    (native-inputs
     `(("kconfig" ,(local-file "E2140.config"))
      ,@(alist-delete "kconfig"
                      (package-native-inputs linux-libre))))))

V rovnakom priečinku, kde je súbor zadávajúci linux-libre-E2140 je aj súbor s názvom E2140.config, ktorý predstavuje súbor nastavenia jadra. Kľúčové slovo defconfig funkcie make-linux-libre je tu ponechané prázdne, takže jediné nastavenie jadra v balíku je to, ktoré bolo zahrnuté do poľa native-inputs.

Druhý spôsob ako vytvoriť vlastné jadro je dať novú hodnotu kľúčovému slovu extra-options funkcie make-linux-libre. Kľúčové slovo extra-options funguje s inou funkciou zadanou nižšie:

(define (default-extra-linux-options version)
  `(;; https://lists.gnu.org/archive/html/guix-devel/2014-04/msg00039.html
   ("CONFIG_DEVPTS_MULTIPLE_INSTANCES" . #true)
   ;; Moduly potrebné pre initrd:
   ("CONFIG_NET_9P" . m)
   ("CONFIG_NET_9P_VIRTIO" . m)
   ("CONFIG_VIRTIO_BLK" . m)
   ("CONFIG_VIRTIO_NET" . m)
   ("CONFIG_VIRTIO_PCI" . m)
   ("CONFIG_VIRTIO_BALLOON" . m)
   ("CONFIG_VIRTIO_MMIO" . m)
   ("CONFIG_FUSE_FS" . m)
   ("CONFIG_CIFS" . m)
   ("CONFIG_9P_FS" . m)))

(define (config->string options)
  (string-join (map (match-lambda
                      ((option . 'm)
                       (string-append option "=m"))
                      ((option . #true)
                       (string-append option "=y"))
                      ((option . #false)
                       (string-append option "=n")))
                    options)
               "\n"))

A vo vlastnom „configure“ skripte balíka „make-linux-libre“:

;; Vkladanie na koniec funguje aj keď voľba v súbore nebola.
;; Pri viacnásobnom uvedení prevažuje to posledné.
(let ((port (open-file ".config" "a"))
      (extra-configuration ,(config->string extra-options)))
  (display extra-configuration port)
  (close-port port))

(invoke "make" "oldconfig")

Takže, neposkytnutie súboru nastavenia spôsobí, že je súbor .config spočiatku prázdny. Potom doň zapíšeme voľby, ktoré chceme. Viď ďalšie vlastné zadanie jadra:

(define %macbook41-full-config
  (append %macbook41-config-options
          %file-systems
          %efi-support
          %emulation
          ((@@ (gnu packages linux) default-extra-linux-options) version)))

(define-public linux-libre-macbook41
  ;; XXX: Prístup k funkcii „make-linux-libre*“, ktorá je súkromná,
  ;; neexportuje sa a v budúcnosti by sa mohla zmeniť.
  ((@@ (gnu packages linux) make-linux-libre*)
   (@@ (gnu packages linux) linux-libre-version)
   (@@ (gnu packages linux) linux-libre-gnu-revision)
   (@@ (gnu packages linux) linux-libre-source)
   '("x86_64-linux")
   #:extra-version "macbook41"
   #:extra-options %macbook41-config-options))

In the above example %file-systems is a collection of flags enabling different file system support, %efi-support enables EFI support and %emulation enables a x86_64-linux machine to act in 32-bit mode also. The default-extra-linux-options procedure is the one defined above, which had to be used to avoid loosing the default configuration options of the extra-options keyword.

Všetko toto znie veľmi dobre, ale ako zistiť, ktoré moduly vyžaduje určitý systém? Na túto otázku nám môžu pomôcť odpovedať dva zdroje: Príručka Gentoo a dokumentácia samotného jadra. Podľa dokumentácie jadra sa zdá, že make localmodconfig je príkaz, ktorý hľadáme.

Skôr ako budeme môcť spustiť make localmodconfig, musíme stiahnuť a rozbaliť zdrojové súbory jadra:

tar xf $(guix build linux-libre --source)

V priečinku obsahujúcom zdrojové súbory spustite touch .config pre vytvorenie počiatočného prázdneho .config súboru. make localmodconfig funguje tak, že zistí, čo ste už zadali do .config a povie vám, čo vám ešte chýba. Ak je súbor prázdny, tak vám chýba všetko. Ďalším krokom je spustiť:

guix shell -D linux-libre -- make localmodconfig

a pozrite si výstup. Všimnite si, že súbor .config je stále prázdny. Výstup obvykle obsahuje dva druhy varovných správ. Prvá začína slovom „WARNING“ a v našom prípade si ju nemusíme všímať. Druhá správa nám hovorí, že:

module pcspkr did not have configs CONFIG_INPUT_PCSPKR

Pre každý z týchto riadkov skopírujte časť CONFIG_XXXX_XXXX do .config súboru priečinka a pridajte =m tak, aby nakoniec vyzeral takto:

CONFIG_INPUT_PCSPKR=m
CONFIG_VIRTIO=m

Po skopírovaní všetkých volieb nastavenia znova spustite make localmodconfig, aby ste sa uistili, že výstup už neobsahuje žiadne správy začínajúce slovom „module“. Okrem všetkých týchto modulov vzťahujúcich sa k stroju nám ostáva ešte niekoľko ďalších dôležitých modulov. CONFIG_MODULES umožňuje zostavovať a načítavať moduly oddelene, aby nemuseli byť zabudované do jadra. CONFIG_BLK_DEV_SD umožňuje čítať pevné disky. Je tiež možné, že budete potrebovať aj iné moduly.

Tento príspevok nemá za úlohu vás previesť nastavením vášho vlastného jadra. Ak sa rozhodnete zostaviť si vlastné jadro, budete si musieť nájsť iné návody na vytvorenie jadra, ktoré vám bude vyhovovať.

Druhý spôsob nastavenia jadra využíva funkcie Guixu vo väčšej miere a umožňuje vám zdieľať časti nastavenia medzi rôznymi jadrami. Napríklad, všetky stroje používajúce na zavádzanie EFI vyžadujú určitý počet volieb nastavenia EFI. Je tiež pravdepodobné, že viaceré jadrá budú zdieľať podporu niekoľkých súborových systémov. Použitím premenných je jednoduchšie spozorovať, ktoré súčasti sú povolené a uistiť sa, či nie sú niektoré z nich prítomné v jednom jadre ale v druhom chýbajú.

Nepozreli sme sa však na initrd a jeho prispôsobenie. Je pravdepodobné, že budete potrebovať prispôsobiť initrd na stroji s vlastným jadrom, keďže niektoré moduly nemusia byť dostupné pre zahrnutie do initrd.

3.3 API pre vytváranie obrazov systému Guix

Z dejinného pohľadu je systém Guix sústredený okolo štruktúry operating-system. Táto štruktúra obsahuje rôzne polia počínajúc zadaním zavádzača a jadra až k službám, ktoré sa majú nainštalovať.

Požiadavky na obraz sa môžu značne líšiť v závislosti na cieľovom stroji, čo môže byť obvyklý x86_64 alebo malý jednodoskový počítač ako Pine64. Výrobcovia technického vybavenia presadzujú rôzne formáty obrazov s rôznymi veľkosťami a umiestneniami oddielov.

Na vytváranie obrazov vhodných pre všetky tieto stroje je nevyhnutné ďalšie zovšeobecnenie, čo je cieľom záznamu image. Tento záznam obsahuje všetky potrebné údaje k premene na samostatný obraz, ktorý je možno priamo zaviesť na hocijakom cieľovom stroji.

(define-record-type* <image>
  image make-image
  image?
  (name               image-name ;symbol
                      (default #f))
  (format             image-format) ;symbol
  (target             image-target
                      (default #f))
  (size               image-size  ;size in bytes as integer
                      (default 'guess))
  (operating-system   image-operating-system  ;<operating-system>
                      (default #f))
  (partitions         image-partitions ;list of <partition>
                      (default '()))
  (compression?       image-compression? ;boolean
                      (default #t))
  (volatile-root?     image-volatile-root? ;boolean
                      (default #t))
  (substitutable?     image-substitutable? ;boolean
                      (default #t)))

Tento záznam obsahuje operačný systém na zostavenie. Pole format určuje druh obrazu a medzi jeho platné hodnoty patria efi-raw, qcow2 alebo iso9660. V budúcnosti by sa mohli rozšíriť o docker a ďalšie druhy obrazov.

Na zadávanie obrazov bol spomedzi zdrojových súborov Guixu vyhradený nový priečinok. Zatiaľ sa v ňom nachádzajú štyri súbory:

• gnu/system/images/hurd.scm
• gnu/system/images/pine64.scm
• gnu/system/images/novena.scm
• gnu/system/images/pinebook-pro.scm

Pozrime sa na pine64.scm. Obsahuje premennú pine64-barebones-os predstavujúcu najmenšie možné zadanie operačného systému určeného pre dosku Pine A64 LTS.

(define pine64-barebones-os
  (operating-system
   (host-name "vignemale")
   (timezone "Europe/Bratislava")
   (locale "sk_SK.utf8")
   (bootloader (bootloader-configuration
                (bootloader u-boot-pine64-lts-bootloader)
                (targets '("/dev/vda"))))
   (initrd-modules '())
   (kernel linux-libre-arm64-generic)
   (file-systems (cons (file-system
                        (device (file-system-label "moj-korenovy-system"))
                        (mount-point "/")
                        (type "ext4"))
                       %base-file-systems))
   (services (cons (service agetty-service-type
                            (agetty-configuration
                             (extra-options '("-L")) ; bez zisťovania nosného signálu
                             (baud-rate "115200")
                             (term "vt100")
                             (tty "ttyS0")))
                   %base-services))))

Polia kernel a bootloader odkazujú na balíky určené pre túto dosku.

Tesne pod nimi je zadaná aj premenná pine64-image-type.

(define pine64-image-type
  (image-type
   (name 'pine64-raw)
   (constructor (cut image-with-os arm64-disk-image <>))))

Využíva záznam, o ktorom sme ešte nehovorili, a teda image-type, zadaný nasledovne:

(define-record-type* <image-type>
  image-type make-image-type
  image-type?
  (name           image-type-name) ; znak
  (constructor    image-type-constructor)) ; <operating-system> -> <image>

Hlavným účelom tohto záznamu je priradiť názov funkcii pretvárajúcej operating-system na obraz. Aby sme pochopili, prečo je to dôležité, pozrime sa na príkaz vytvárajúci obraz zo súboru nastavení operating-system:

guix system image moj-os.scm

Tento príkaz očakáva nastavenie druhu operating-system, ale ako by sme mali určiť, že chceme obraz pre dosku Pine64? Musíme poskytnúť doplňujúci údaj, image-type, pomocou voľby --image-type alebo -t a to takto:

guix system image --image-type=pine64-raw moj-os.scm

Tento image-type parameter odkazuje na pine64-image-type uvedený vyššie. Na operating-system zadaný v moj-os.scm sa teda použije funkcia (cut image-with-os arm64-disk-image <>) pre vytvorenie obrazu.

Výsledný obraz vyzerá asi takto:

(image
 (format 'disk-image)
 (target "aarch64-linux-gnu")
 (operating-system moj-os)
 (partitions
  (list (partition
         (inherit root-partition)
         (offset root-offset)))))

čo je združenie člena operating-system zadaného v moj-os.scm so záznamom arm64-disk-image.

Stačilo už tohto Scheme šialenstva. Čo toto API prináša používateľom Guixu?

Môžete spustiť:

mathieu@cervin:~$ guix system --list-image-types
Dostupné druhy obrazov sú:

   - unmatched-raw
   - rock64-raw
   - pinebook-pro-raw
   - pine64-raw
   - novena-raw
   - hurd-raw
   - hurd-qcow2
   - qcow2
   - iso9660
   - uncompressed-iso9660
   - tarball
   - efi-raw
   - mbr-raw
   - docker
   - wsl2
   - raw-with-offset
   - efi32-raw

a vytvorením súboru druhu operating-system, založenom na pine64-barebones-os, si môžete váš obraz prispôsobiť v súbore (moj-pine-os.scm) asi takto:

(use-modules (gnu services linux)
             (gnu system images pine64))

(let ((base-os pine64-barebones-os))
  (operating-system
    (inherit base-os)
    (timezone "Europe/Bratislava")
    (services
     (cons
      (service earlyoom-service-type
               (earlyoom-configuration
                (prefer-regexp "icecat|chromium")))
      (operating-system-user-services base-os)))))

spustite:

guix system image --image-type=pine64-raw moj-os.scm

alebo

guix system image --image-type=hurd-raw moj-hurd-os.scm

pre získanie obrazu, ktorý možno zapísať priamo na pevný disk a zaviesť.

Bezo zmeny v moj-hurd-os.scm, volanie:

guix system image --image-type=hurd-qcow2 moj-hurd-os.scm

namiesto toho vytvorí Hurd QEMU obraz.

3.4 Používanie bezpečnostných kľúčov

Používanie bezpečnostných kľúčov môže zvýšiť vašu bezpečnosť tým, že hlavnému predmetu utajenia (heslo - niečo, čo poznáte) poskytne podružný zdroj overenia, ktorý nemožno jednoducho ukradnúť alebo skopírovať (niečo, čo vlastníte), aspoň v prípade vzdialených protivníkov, čo znižuje riziko krádeže totožnosti.

Nižšie uvedený podrobný príklad znázorňuje najstručnejšie možné nastavenie potrebné pre umožnenie používania bezpečnostného kľúča Yubico v systéme Guix. Dúfame, že toto nastavenie bude, s menšími úpravami, možné použiť aj pre iné bezpečnostné kľúče.

• Nastavenie pre použitie v rámci dvojstupňového overenia (2FA)
• Disabling OTP code generation for a Yubikey
• Requiring a Yubikey to open a KeePassXC database

(use-package-modules ... security-token ...)
...
(operating-system
 ...
 (users (cons* (user-account
               (name "vas-pouzivatelsky-ucet")
               (group "users")
               (supplementary-groups
		'("wheel" "netdev" "audio" "video"
                  "plugdev"))           ;<- pridaná systémová skupina
               (home-directory "/home/vas-pouzivatelsky-ucet"))
              %base-user-accounts))
 ...
 (services
  (cons*
   ...
   (udev-rules-service 'fido2 libfido2 #:groups '("plugdev")))))

guix shell ungoogled-chromium -- chromium chrome://settings/securityKeys

guix shell python-yubikey-manager -- ykman config usb --force --disable OTP

(use-package-modules ... security-token ...)
...
(operating-system
 ...
 (services
  (cons*
   ...
   (udev-rules-service 'yubikey yubikey-personalization))))

guix shell yubikey-manager-qt -- ykman-gui

3.5 mcron úloha pre dynamický DNS

If your ISP (Internet Service Provider) only provides dynamic IP addresses, it can be useful to setup a dynamic DNS (Domain Name System) (also known as DDNS (Dynamic DNS)) service to associate a static host name to a public but dynamic (often changing) IP address. There are multiple existing services that can be used for this; in the following mcron job, DuckDNS is used. It should also work with other dynamic DNS services that offer a similar interface to update the IP address, such as https://freedns.afraid.org/, with minor adjustments.

The mcron job is provided below, where DOMAIN should be substituted for your own domain prefix, and the DuckDNS provided token associated to DOMAIN added to the /etc/duckdns/DOMAIN.token file.

(define duckdns-job
  ;; Update personal domain IP every 5 minutes.
  #~(job '(next-minute (range 0 60 5))
	 #$(program-file
            "duckdns-update"
            (with-extensions (list guile-gnutls) ;required by (web client)
              #~(begin
                  (use-modules (ice-9 textual-ports)
                               (web client))
                  (let ((token (string-trim-both
                                (call-with-input-file "/etc/duckdns/DOMAIN.token"
                                  get-string-all)))
                        (query-template (string-append "https://www.duckdns.org/"
                                                       "update?domains=DOMAIN"
                                                       "&token=~a&ip=")))
                    (http-get (format #f query-template token))))))
         "duckdns-update"
         #:user "nobody"))

The job then needs to be added to the list of mcron jobs for your system, using something like:

(operating-system
 (services
  (cons* (service mcron-service-type
           (mcron-configuration
             (jobs (list duckdns-job ...))))
         ...
         %base-services)))

3.6 Pripojenie k Wireguard VPN

Pre pripojenie k serveru Wireguard VPN je potrebné načítať príslušný modul jadra ako aj balík poskytujúci sieťové nástroje, ktoré ho podporujú (napr. wireguard-tools alebo network-manager).

Nasleduje príklad nastavenia pre jadrá Linux-Libre < 5.6, ktoré príslušný modul nezahŕňajú a vyžadujú jeho ručné načítanie. V novších vydaniach jadra je modul už zabudovaný a takéto nastavenie nie je potrebné:

(use-modules (gnu))
(use-service-modules desktop)
(use-package-modules vpn)

(operating-system
  ;; …
  (services (cons (simple-service 'wireguard-module
                                  kernel-module-loader-service-type
                                  '("wireguard"))
                  %desktop-services))
  (packages (cons wireguard-tools %base-packages))
  (kernel-loadable-modules (list wireguard-linux-compat)))

Po znovunastavení a opätovnom spustení systému môžete použiť buď nástroje Wireguard alebo NetworkManager pre pripojenie k VPN serveru.

• Použitie nástrojov Wireguard
• Použitie nástroja NetworkManager

# nmcli connection import type wireguard file wg0.conf
Connection 'wg0' (edbee261-aa5a-42db-b032-6c7757c60fde) successfully added

$ nmcli connection up wg0
Connection successfully activated (D-Bus active path: /org/freedesktop/NetworkManager/ActiveConnection/6)

# nmcli connection modify wg0 connection.autoconnect no

3.7 Prispôsobenie správcu okien

• StumpWM
• Uzamykanie sedenia

(use-modules (gnu))
(use-package-modules wm)

(operating-system
  ;; …
  (packages (append (list sbcl stumpwm `(,stumpwm "lib"))
                    %base-packages)))

(use-modules (gnu))
(use-package-modules fonts wm)

(operating-system
  ;; …
  (packages (append (list sbcl stumpwm `(,stumpwm "lib"))
                    sbcl-ttf-fonts font-dejavu %base-packages)))

(require :ttf-fonts)
(setf xft:*font-dirs* '("/run/current-system/profile/share/fonts/"))
(setf clx-truetype:+font-cache-filename+ (concat (getenv "HOME")
                                                 "/.fonts/font-cache.sexp"))
(xft:cache-fonts)
(set-font (make-instance 'xft:font :family "DejaVu Sans Mono"
                                   :subfamily "Book" :size 11))

xss-lock -- slock &
exec stumpwm

(service screen-locker-service-type
         (screen-locker-configuration
          (name "slock")
          (program (file-append slock "/bin/slock"))))

3.8 Spúšťanie Guixu na serveri Linode

Ak chcete spustiť Guix na serveri hosťovanom na Linode, začnite s odporúčaným Debianovým serverom. Na zavedenie Guixu vám odporúčame použiť predvolenú distribúciu. Vytvorte si kľúče SSH.

ssh-keygen

Pridajte si SSH kľúč pre rýchle prihlasovanie na vzdialený server. Vďaka grafickému rozhraniu Linode je pridávanie SSH kľúčov veľmi jednoduché. Choďte do vášho profilu a kliknite na Pridať SSH kľúč. Tam potom skopírujte výstup príkazu:

cat ~/.ssh/<pouzivatel>_rsa.pub

Vypnite Linode.

Na karte „Storage“ (úložisko) v Linode zmenšite disk s Debianom. Odporúča sa 30 GB voľného priestoru. Potom kliknite na „Add a disk“ (pridať disk) a vyplňte formulár nasledujúcimi údajmi:

• Label (menovka): "Guix"
• Filesystem (súborový systém): ext4
• Využite zvyšné voľné miesto

Na karte „Configurations“ (nastavenia) kliknite na „Edit“ (upraviť) pri predvolenom profile Debianu. Pod „Block Device Assignment“ (pridelenie diskových zariadení) kliknite na „Add a Device“ (pridať zariadenie). Malo by to byť /dev/sdc a môžete pridať disk „Guix“. Uložte zmeny.

Teraz „Add a Configuration“ (pridať nastavenie) s nasledovným:

• Label (menovka): Guix
• Kernel (jadro): GRUB 2 (je to naspodku! Tento krok je DÔLEŽITÝ!)
• Block device assignment (pridelenie diskových zariadení):
• /dev/sda: Guix
• /dev/sdb: swap (odkladací priestor)
• Root device (koreňové zariadenie): /dev/sda
• Vypnite všetky pomocné programy pre systém súborov a zavádzanie

Teraz opätovne spustite server s nastavením Debianu. Po spustení sa k vášmu serveru pripojte cez SSH pomocou ssh root@<IP-adresa-vasho-servera-tu> (IP adresu vášho servera môžete nájsť v odseku „Summary“, t.j. zhrnutie, na Linode). Teraz môžete vykonať inštalačné kroky z see Binary Installation in GNU Guix:

sudo apt-get install gpg
wget https://sv.gnu.org/people/viewgpg.php?user_id=15145 -qO - | gpg --import -
wget https://git.savannah.gnu.org/cgit/guix.git/plain/etc/guix-install.sh
chmod +x guix-install.sh
./guix-install.sh
guix pull

Teraz je čas dať dohromady nastavenia servera. Kľúčové poznatky sú uvedené nižšie. Uložte výsledný súbor ako guix-config.scm.

(use-modules (gnu)
             (guix modules))
(use-service-modules networking
                     ssh)
(use-package-modules admin
                     package-management
                     ssh
                     tls)

(operating-system
  (host-name "moj-server")
  (timezone "Europe/Bratislava")
  (locale "sk_SK.UTF-8")
  ;; Tento kód vytvorí grub.cfg
  ;; bez inštalácie grubu na disk.
  (bootloader (bootloader-configuration
               (bootloader
                (bootloader
                 (inherit grub-bootloader)
                 (installer #~(const #true))))))
  (file-systems (cons (file-system
                        (device "/dev/sda")
                        (mount-point "/")
                        (type "ext4"))
                      %base-file-systems))


  (swap-devices (list "/dev/sdb"))


  (initrd-modules (cons "virtio_scsi"    ; Potrebné pre nájdenie disku
                        %base-initrd-modules))

  (users (cons (user-account
                (name "jozkomrkvicka")
                (group "users")
                ;; Pridá účet do skupiny „wheel“,
                ;; aby sa z neho stal sudoer.
                (supplementary-groups '("wheel"))
                (home-directory "/home/jozkomrkvicka"))
               %base-user-accounts))

  (packages (cons* openssh-sans-x
                   %base-packages))

  (services (cons*
             (service dhcp-client-service-type)
             (service openssh-service-type
                      (openssh-configuration
                       (openssh openssh-sans-x)
                       (password-authentication? #false)
                       (authorized-keys
                        `(("jozkomrkvicka" ,(local-file "jozkomrkvicka_rsa.pub"))
                          ("root" ,(local-file "jozkomrkvicka_rsa.pub"))))))
             %base-services)))

Nahraďte nasledovné polia vo vyššie uvedenom nastavení:

(host-name "moj-server")       ; nahraďte názvom vášho servera
; ak si vyberiete Linode server mimo Slovenska, tak pomocou
; tzselect vyhľadajte správne nastavenie časového pásma
(timezone "Europe/Bratislava") ; v prípade potreby, nahraďte časové pásmo
(name "jozkomrkvicka")              ; nahraďte vašim používateľským menom
("jozkomrkvicka" ,(local-file "jozkomrkvicka_rsa.pub")) ; nahraďte vašim používateľským menom a SSH kľúčom
("root" ,(local-file "jozkomrkvicka_rsa.pub")) ; nahraďte vašim SSH kľúčom

Posledný riadok vo vyššie uvedenom príklade vám umožňuje prihlásiť sa na server ako root a nastaviť prvotné heslo používateľa root (viď poznámku o prihlasovaní používateľa root na konci receptu). Po tomto môžete daný riadok z nastavenia vymazať a znovunastaviť, aby ste zabránili prihlasovaniu ako root.

Skopírujte váš verejný SSH kľúč (napr. ~/.ssh/id_rsa.pub) do <vase-pouzivatelske-meno-tu>_rsa.pub a premiestnite guix-config.scm do rovnakého priečinka. V novom príkazovom riadku vykonajte nasledovné príkazy.

sftp root@<ip adresa vzdialeného servera>
put /cesta/k/súborom/<používateľ>_rsa.pub .
put /cesta/k/súborom/guix-config.scm .

Vo vašom prvom príkazovom riadku pripojte disk guix:

mkdir /mnt/guix
mount /dev/sdc /mnt/guix

Kvôli spôsobu akým sme nastavili zavádzač v príslušnom oddieli guix-config.scm sa nainštaluje iba súbor nastavení grubu. Musíme, teda, prekopírovať nejaké súbory zavádzača GRUB, ktoré už sú nainštalované v systéme Debian:

mkdir -p /mnt/guix/boot/grub
cp -r /boot/grub/* /mnt/guix/boot/grub/

Teraz nastavte inštaláciu Guixu do východzieho stavu:

guix system init guix-config.scm /mnt/guix

Dobre, vypnite server! Cez príkazový riadok Linode spustite server a vyberte „Guix“.

Po spustení by ste mali byť schopní prihlásiť sa cez SSH! (Nastavenie servera ale bude zmenené.) Môžete sa stretnúť s chybou ako je táto:

$ ssh root@<ip adresa servera>
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@     WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!      @@@@@@@@@@@@@@@@@@@@@@@@@@@@@ IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!
Someone could be eavesdropping on you right now (man-in-the-middle attack)!
It is also possible that a host key has just been changed.
The fingerprint for the ECDSA key sent by the remote host is
SHA256:0B+wp33w57AnKQuHCvQP0+ZdKaqYrI/kyU7CfVbS7R4.
Please contact your system administrator.
Add correct host key in /home/jozkomrkvicka/.ssh/known_hosts to get rid of this message.
Offending ECDSA key in /home/jozkomrkvicka/.ssh/known_hosts:3
ECDSA host key for 198.58.98.76 has changed and you have requested strict checking.
Host key verification failed.

Buď odstráňte súbor ~/.ssh/known_hosts, alebo vymažte dotknutý riadok začínajúci IP adresou vášho servera.

Nezabudnite si nastaviť vaše heslo ako aj heslo používateľa root.

ssh root@<vzdialená ip adresa>
passwd  ; pre nastavenie hesla používateľa root
passwd <používateľ> ; pre nastavenie hesla daného používateľa

V tomto bode možno nebudete môcť vyššie uvedené príkazy vykonať. Ak máte ťažkosti so vzdialeným prihlásením cez SSH, tak možno budete musieť používateľské heslá nastaviť kliknutím na možnosť „Launch Console“ (spustiť príkazový riadok) vo vašom Linode. Vyberte „Glish“ namiesto „Weblish“. Teraz by ste už mali byť schopní prihlásiť sa do stroja.

Sláva! Teraz môžete server vypnúť, odstrániť disk s Debianom a rozšíriť disk Guixom. Blahoželáme!

Inak, ak teraz výsledok uložíte ako obraz disku, uľahčíte si tým spúšťanie nových obrazov s Guixom! Pre uloženie ako obraz disku možno budete musieť disk s Guixom zmenšiť na 6144 MB, ale potom ho môžete znovu rozšíriť na pôvodnú veľkosť.

3.9 Spúšťanie Guixu na Kimsufi serveri

To run Guix on a server hosted by Kimsufi, click on the netboot tab then select rescue64-pro and restart.

OVH will email you the credentials required to ssh into a Debian system.

Now you can run the "install guix from see Binary Installation in GNU Guix" steps:

wget https://git.savannah.gnu.org/cgit/guix.git/plain/etc/guix-install.sh
chmod +x guix-install.sh
./guix-install.sh
guix pull

Partition the drives and format them, first stop the raid array:

mdadm --stop /dev/md127
mdadm --zero-superblock /dev/sda2 /dev/sdb2

Then wipe the disks and set up the partitions, we will create a RAID 1 array.

wipefs -a /dev/sda
wipefs -a /dev/sdb

parted /dev/sda --align=opt -s -m -- mklabel gpt
parted /dev/sda --align=opt -s -m -- \
 mkpart bios_grub 1049kb 512MiB \
 set 1 bios_grub on
parted /dev/sda --align=opt -s -m -- \
 mkpart primary 512MiB -512MiB
 set 2 raid on
parted /dev/sda --align=opt -s -m -- mkpart primary linux-swap 512MiB 100%

parted /dev/sdb --align=opt -s -m -- mklabel gpt
parted /dev/sdb --align=opt -s -m -- \
     mkpart bios_grub 1049kb 512MiB \
     set 1 bios_grub on
parted /dev/sdb --align=opt -s -m -- \
     mkpart primary 512MiB -512MiB \
     set 2 raid on
parted /dev/sdb --align=opt -s -m -- mkpart primary linux-swap 512MiB 100%

Create the array:

mdadm --create /dev/md127 --level=1 --raid-disks=2 \
  --metadata=0.90 /dev/sda2 /dev/sdb2

Now create file systems on the relevant partitions, first the boot partitions:

mkfs.ext4  /dev/sda1
mkfs.ext4  /dev/sdb1

Then the root partition:

mkfs.ext4 /dev/md127

Initialize the swap partitions:

mkswap /dev/sda3
swapon /dev/sda3
mkswap /dev/sdb3
swapon /dev/sdb3

Mount the guix drive:

mkdir /mnt/guix
mount /dev/md127 /mnt/guix

Now is time to write an operating system declaration os.scm file; here is a sample:

(use-modules (gnu) (guix))
(use-service-modules networking ssh vpn virtualization sysctl admin mcron)
(use-package-modules ssh tls tmux vpn virtualization)

(operating-system
  (host-name "kimsufi")

  (bootloader (bootloader-configuration
	       (bootloader grub-bootloader)
	       (targets (list "/dev/sda" "/dev/sdb"))
	       (terminal-outputs '(console))))

  ;; Add a kernel module for RAID-1 (aka. "mirror").
  (initrd-modules (cons* "raid1"  %base-initrd-modules))

  (mapped-devices
   (list (mapped-device
          (source (list "/dev/sda2" "/dev/sdb2"))
          (target "/dev/md127")
          (type raid-device-mapping))))

  (swap-devices
   (list (swap-space
          (target "/dev/sda3"))
         (swap-space
          (target "/dev/sdb3"))))

  (issue
   ;; Default contents for /etc/issue.
   "\
This is the GNU system at Kimsufi.  Welcome.\n")

  (file-systems (cons* (file-system
		         (mount-point "/")
		         (device "/dev/md127")
		         (type "ext4")
		         (dependencies mapped-devices))
		       %base-file-systems))

  (users (cons (user-account
	        (name "guix")
	        (comment "guix")
	        (group "users")
	        (supplementary-groups '("wheel"))
	        (home-directory "/home/guix"))
	       %base-user-accounts))

  (sudoers-file
   (plain-file "sudoers" "\
root ALL=(ALL) ALL
%wheel ALL=(ALL) ALL
guix ALL=(ALL) NOPASSWD:ALL\n"))

  ;; Globally-installed packages.
  (packages (cons* tmux gnutls wireguard-tools %base-packages))
  (services
   (cons*
    (service static-networking-service-type
	     (list (static-networking
		    (addresses (list (network-address
				      (device "enp3s0")
				      (value "server-ip-address/24"))))
		    (routes (list (network-route
				   (destination "default")
				   (gateway "server-gateway"))))
		    (name-servers '("213.186.33.99")))))

    (service unattended-upgrade-service-type)

    (service openssh-service-type
	     (openssh-configuration
	      (openssh openssh-sans-x)
	      (permit-root-login #f)
	      (authorized-keys
	       `(("guix" ,(plain-file "ssh-key-name.pub"
                                      "ssh-public-key-content"))))))
    (modify-services %base-services
      (sysctl-service-type
       config =>
       (sysctl-configuration
	(settings (append '(("net.ipv6.conf.all.autoconf" . "0")
			    ("net.ipv6.conf.all.accept_ra" . "0"))
			  %default-sysctl-settings))))))))

Don’t forget to substitute the server-ip-address, server-gateway, ssh-key-name and ssh-public-key-content variables with your own values.

The gateway is the last usable IP in your block so if you have a server with an IP of ‘37.187.79.10’ then its gateway will be ‘37.187.79.254’.

Transfer your operating system declaration os.scm file on the server via the scp or sftp commands.

Now all that is left is to install Guix with a guix system init and restart.

However we first need to set up a chroot, because the root partition of the rescue system is mounted on an aufs partition and if you try to install Guix it will fail at the GRUB install step complaining about the canonical path of "aufs".

Install packages that will be used in the chroot:

guix install bash-static parted util-linux-with-udev coreutils guix

Then run the following to create directories needed for the chroot:

cd /mnt && \
mkdir -p bin etc gnu/store root/.guix-profile/ root/.config/guix/current \
  var/guix proc sys dev

Copy the host resolv.conf in the chroot:

cp /etc/resolv.conf etc/

Mount block devices, the store and its database and the current guix config:

mount --rbind /proc /mnt/proc
mount --rbind /sys /mnt/sys
mount --rbind /dev /mnt/dev
mount --rbind /var/guix/ var/guix/
mount --rbind /gnu/store gnu/store/
mount --rbind /root/.config/ root/.config/
mount --rbind /root/.guix-profile/bin/ bin
mount --rbind /root/.guix-profile root/.guix-profile/

Chroot in /mnt and install the system:

chroot /mnt/ /bin/bash

guix system init /root/os.scm /guix

Finally, from the web user interface (UI), change ‘netboot’ to ‘boot to disk’ and restart (also from the web UI).

Wait a few minutes and try to ssh with ssh guix@server-ip-address> -i path-to-your-ssh-key

You should have a Guix system up and running on Kimsufi; congratulations!

3.10 Nastavenie podvojného pripojenia

Pre vytvorenie podvojného pripojenia systému súborov je najskôr nutné pridať niekoľko zadaní do oddielu operating-system v zadaní systému. Aby sme nevyčerpávali hlavný SSD disk, v tomto príklade vytvoríme podvojné pripojenie pre priečinok z pevného disku k /tmp bez nutnosti vyhradenia celého jedného oddielu pre /tmp.

Po prvé, zdrojové zariadenie s priečinkom, pre ktorý chceme vytvoriť podvojné pripojenie, musí byť dané, aby na ňom mohlo podvojné pripojenie závisieť.

(define zdrojove-zariadenie ;; „zdrojove-zariadenie“ môžete ľubovoľne nahradiť
   (file-system
    (device (uuid "sem príde UUID"))
    (mount-point "/sem-príde-cesta-k-pevnému-disku")
    (type "ext4"))) ;Uistite sa, že druh systému súborov zodpovedá tomu, čo je na disku.

Zdrojový priečinok musí byť taktiež určený, aby Guix vedel, že sa jedná o priečinok, a nie o diskovú jednotku.

;; „zdrojovy-priecinok“ môžete nahradiť ľubovoľným platným názvom premennej.
(define (%zdrojovy-priecinok) "/sem-príde-cesta-k-pevnému-disku/tmp")

Nakoniec musíme samotné pripojenie pridať do zadania file-systems.

(file-systems (cons*

                ...<ostatné pripojenia sme vynechali>...

                ;; Musí sa zhodovať s názvom, ktorý ste pridelili zdrojovému
                ;; zariadeniu vyššie.
                zdrojove-zariadenie

                (file-system
                 ;; „zdrojovy-priecinok“ sa musí zhodovať s predošlým zadaním.
                 (device (%zdrojovy-priecinok))
                 (mount-point "/tmp")
                 ;; Pripájame priečinok, nie zväzok, takže tento druh
                 ;; musí byť „none“ (žiadny)
                 (type "none")
                 (flags '(bind-mount))
                 ;; „zdrojove-zariadenie“ sa musí zhodovať s predošlým zadaním.
                 (dependencies (list zdrojove-zariadenie))
                 )

                 ...<ostatné pripojenia sme vynechali>...

                ))

3.11 Získavanie náhrad prostredníctvom Tor

Démon Guixu môže na získavanie náhrad využívať HTTP proxy server. V tomto prípade ho nastavíme tak, aby ich získaval cez Tor.

Upozornenie: Nie všetka sieťová prevádzka démona Guixu bude prechádzať cez Tor! Presmerované bude len HTTP/HTTPS; protokol Git, SSH, atď. pôjdu aj naďalej cez otvorenú sieť. Znova, toto nastavenie nie je dokonalé a časť vašej prevádzky poputuje aj naďalej mimo siete Tor. Použite ho na vlastné riziko.

Vedzte tiež, že opísaný postup sa vzťahuje len na náhrady balíkov. Ak chcete pri aktualizovaní vašej distribúcie pomocou guix pull presmerovať pripojenie ku git repozitáru Guixu cez Tor , budete musieť použiť torsocks.

Server náhrad Guixu je dostupný ako Onion služba. Ak chcete náhrady získavať cez Tor, nastavte váš systém nasledovne:

(use-modules (gnu))
(use-service-module base networking)

(operating-system
  …
  (services
    (cons
      (service tor-service-type
              (tor-configuration
                (config-file (plain-file "tor-config"
                                         "HTTPTunnelPort 127.0.0.1:9250"))))
      (modify-services %base-services
        (guix-service-type
          config => (guix-configuration
                      (inherit config)
                      ;; Onion služba na ci.guix.gnu.org
                      (substitute-urls "\
https://4zwzi66wwdaalbhgnix55ea3ab4pvvw66ll2ow53kjub6se4q2bclcyd.onion")
                      (http-proxy "http://localhost:9250")))))))

Toto udrží spustený proces tor poskytujúci tunel HTTP CONNECT, ktorý použije guix-daemon. Démon môže využívať aj iné protokoly ako HTTP(S) pre získavanie vzdialených zdrojov. Avšak požiadavky spoliehajúce sa na iné protokoly nebudú prechádzať cez Tor, keďže tu nastavujeme len HTTP tunel. Vedzte, že substitutes-urls využíva HTTPS. Kvôli obmedzeniu spojenému s Tor tunelom by to cez HTTP nefungovalo. Takýmto obmedzeniam sa môžete vyhnúť použitím privoxy.

Ak nechcete pre získavanie náhrad prechádzať cez Tor neustále ale iba niekedy, preskočte guix-configuration. Keď budete chcieť získať náhradu cez tunel Tor, spustite:

sudo herd set-http-proxy guix-daemon http://localhost:9250
guix build \
  --substitute-urls=https://4zwzi66wwdaalbhgnix55ea3ab4pvvw66ll2ow53kjub6se4q2bclcyd.onion …

3.12 Nastavenia NGINX a Lua

NGINX možno rozšíriť pomocou Lua skriptov.

Guix poskytuje NGINX službu so schopnosťou načítať Lua moduly a určité Lua balíky ako aj odpovedať na požiadavky vyhodnocovaním Lua skriptov.

Nasledovný príklad znázorňuje zadanie systému s nastavením, ktoré vyhodnotí Lua skript index.lua pri HTTP požiadavke na koncový bod http://localhost/ahoj:

local shell = require "resty.shell"

local stdin = ""
local timeout = 1000  -- ms
local max_size = 4096  -- byte

local ok, stdout, stderr, reason, status =
   shell.run([[/run/current-system/profile/bin/ls /tmp]], stdin, timeout, max_size)

ngx.say(stdout)

(use-modules (gnu))
(use-service-modules #;… web)
(use-package-modules #;… lua)
(operating-system
  ;; …
  (services
   ;; …
   (service nginx-service-type
            (nginx-configuration
             (modules
              (list
               (file-append nginx-lua-module "/etc/nginx/modules/ngx_http_lua_module.so")))
             (lua-package-path (list lua-resty-core
                                     lua-resty-lrucache
                                     lua-resty-signal
                                     lua-tablepool
                                     lua-resty-shell))
             (lua-package-cpath (list lua-resty-signal))
             (server-blocks
              (list (nginx-server-configuration
                     (server-name '("localhost"))
                     (listen '("80"))
                     (root "/etc")
                     (locations (list
                                 (nginx-location-configuration
                                  (uri "/ahoj")
                                  (body (list #~(format #f "content_by_lua_file ~s;"
                                                        #$(local-file "index.lua"))))))))))))))

3.13 Hudobný server so zvukom cez Bluetooth

MPD, démon hudobného prehrávača, je pružná serverová aplikácia na prehrávanie hudby. Klientske programy na rôznych strojoch na sieti — mobilný telefón, prenosný počítač, stolný počítač — sa k nej môžu pripojiť a ovládať prehrávanie zvukových súborov z vašej miestnej hudobnej zbierky. MPD číta zvukové súbory a prehráva ich na jednom alebo viacerých výstupoch.

Ak nie je nastavené inak, MPD prehráva na predvolenom zvukovom zariadení. V nižšie uvedenom príklade to spravíme trochu zaujímavejšie a nastavíme si bezobrazovkový hudobný server. Nepoužijeme grafické používateľské rozhranie, démona Pulseaudio ani miestny zvukový výstup. Namiesto toho nastavíme MPD s dvomi výstupmi: s bluetooth reproduktorom a webovým serverom poskytujúcim zvukové toky ľubovoľnému prehrávaču hudby.

Nastavenie Bluetooth býva otravné. Budete musieť spárovať vaše Bluetooth zariadenie a zabezpečiť, aby sa po zapnutí samo pripájalo. Systémová Bluetooth služba vrátená funkciou bluetooth-service poskytuje podklady potrebné pre toto nastavenie.

Znovunastavte váš systém s aspoň týmito službami a balíkmi:

(operating-system
  ;; …
  (packages (cons* bluez bluez-alsa
                   %base-packages))
  (services
   ;; …
   (dbus-service #:services (list bluez-alsa))
   (bluetooth-service #:auto-enable? #t)))

Spustite službu bluetooth a zistite Bluetooth zariadenia pomocou bluetoothctl. Pokúste sa stotožniť váš Bluetooth reproduktor a vyberte jeho označenie z výsledného zoznamu zariadení, ktorý je nepochybne plný rôznych hračičiek vašich susedov. Toto je potrebné urobiť iba raz:

$ bluetoothctl 
[NEW] Controller 00:11:22:33:95:7F BlueZ 5.40 [default]

[bluetooth]# power on
[bluetooth]# Changing power on succeeded

[bluetooth]# agent on
[bluetooth]# Agent registered

[bluetooth]# default-agent
[bluetooth]# Default agent request successful

[bluetooth]# scan on
[bluetooth]# Discovery started
[CHG] Controller 00:11:22:33:95:7F Discovering: yes
[NEW] Device AA:BB:CC:A4:AA:CD Môj Bluetooth reproduktor
[NEW] Device 44:44:FF:2A:20:DC TV môjho suseda
…

[bluetooth]# pair AA:BB:CC:A4:AA:CD
Attempting to pair with AA:BB:CC:A4:AA:CD
[CHG] Device AA:BB:CC:A4:AA:CD Connected: yes

[My Bluetooth Speaker]# [CHG] Device AA:BB:CC:A4:AA:CD UUIDs: 0000110b-0000-1000-8000-00xxxxxxxxxx
[CHG] Device AA:BB:CC:A4:AA:CD UUIDs: 0000110c-0000-1000-8000-00xxxxxxxxxx
[CHG] Device AA:BB:CC:A4:AA:CD UUIDs: 0000110e-0000-1000-8000-00xxxxxxxxxx
[CHG] Device AA:BB:CC:A4:AA:CD Paired: yes
Pairing successful

[CHG] Device AA:BB:CC:A4:AA:CD Connected: no

[bluetooth]# 
[bluetooth]# trust AA:BB:CC:A4:AA:CD
[bluetooth]# [CHG] Device AA:BB:CC:A4:AA:CD Trusted: yes
Changing AA:BB:CC:A4:AA:CD trust succeeded

[bluetooth]# 
[bluetooth]# connect AA:BB:CC:A4:AA:CD
Attempting to connect to AA:BB:CC:A4:AA:CD
[bluetooth]# [CHG] Device AA:BB:CC:A4:AA:CD RSSI: -63
[CHG] Device AA:BB:CC:A4:AA:CD Connected: yes
Connection successful

[My Bluetooth Speaker]# scan off
[CHG] Device AA:BB:CC:A4:AA:CD RSSI is nil
Discovery stopped
[CHG] Controller 00:11:22:33:95:7F Discovering: no

Blahoželáme, už sa môžete samočinne pripojiť k vášmu Bluetooth reproduktoru!

Teraz je čas nastaviť ALSA na používanie Bluetooth modulu bluealsa, aby ste mohli určiť ALSA pcm zariadenie zodpovedajúce vášmu Bluetooth reproduktoru. Pre bezobrazovkový server je použitie bluealsa s pevne určeným Bluetooth zariadením pravdepodobne jednoduchšie ako nastavenie Pulseaudia a prepínania tokov. ALSA nastavíme vytvorením vlastného nastavenia alsa-configuration pre druh alsa-service-type. Nastavenie zadá bluealsa pcm druhu z modulu bluealsa poskytovaného balíkom bluez-alsa a potom určí pcm zariadenie daného druhu pre váš Bluetooth reproduktor.

Už zostáva len nastaviť MPD tak, aby odosielal zvukové údaje na toto ALSA zariadenie. Pridáme tiež podvojný MPD výstup, ktorý sprístupní práve prehrávané zvukové súbory ako tok cez webový server na koncovom bode 8080. Ak je zvukový tok dostupný, zariadenia na sieti ho môžu počúvať pripojením ľubovoľného hudobného prehrávača ku koncovému bodu 8080 HTTP servera nezávisle od stavu Bluetooth reproduktora.

Nasleduje náčrt zadania operating-system, ktoré by malo umožniť vyššie uvedené úlohy:

(use-modules (gnu))
(use-service-modules audio dbus sound #;… etc)
(use-package-modules audio linux #;… etc)
(operating-system
  ;; …
  (packages (cons* bluez bluez-alsa
                   %base-packages))
  (services
   ;; …
   (service mpd-service-type
            (mpd-configuration
             (user "vase-pouzivatelske-meno")
             (music-dir "/cesta/k/vašej/hudbe")
             (address "192.168.178.20")
             (outputs (list (mpd-output
                             (type "alsa")
                             (name "MPD")
                             (extra-options
                              ;; Použite rovnaký názov ako
                              ;; v nižšie uvedenom nastavení ALSA.
                              '((device . "pcm.btspeaker"))))
                            (mpd-output
                             (type "httpd")
                             (name "streaming")
                             (enabled? #false)
                             (always-on? #true)
                             (tags? #true)
                             (mixer-type 'null)
                             (extra-options
                              '((encoder . "vorbis")
                                (port    . "8080")
                                (bind-to-address . "192.168.178.20")
                                (max-clients . "0") ; bez obmedzení
                                (quality . "5.0")
                                (format  . "44100:16:1"))))))))
   (dbus-service #:services (list bluez-alsa))
   (bluetooth-service #:auto-enable? #t)
   (service alsa-service-type
            (alsa-configuration
             (pulseaudio? #false) ; nepotrebujeme ho!
             (extra-options
              #~(string-append "\
# Zadáva zvukové Bluetooth zariadenie druhu \"bluealsa\" z modulu bluealsa
pcm_type.bluealsa {
    lib \""
#$(file-append bluez-alsa "/lib/alsa-lib/libasound_module_pcm_bluealsa.so") "\"
}

# Zadáva overovacie zariadenie druhu \"bluealsa\" z rovnakého modulu
ctl_type.bluealsa {
    lib \""
#$(file-append bluez-alsa "/lib/alsa-lib/libasound_module_ctl_bluealsa.so") "\"
}

# Určuje zvukové Bluetooth zariadenie.
pcm.btspeaker {
    type bluealsa
    device \"AA:BB:CC:A4:AA:CD\" # jedinečné označenie zariadenia
    profile \"a2dp\"
}

# Určuje súvisiaci overovač.
ctl.btspeaker {
    type bluealsa
}
"))))))

Užite si hudbu s MPD klientom podľa vlastného výberu alebo s hudobným prehrávačom schopným prijímať zvukové toky cez HTTP!

4.1 Kontajnery Guix

Najľahším spôsobom ako začať je použitie príkazu proc s voľbou --container. See Invoking guix shell in GNU Guix Reference Manual pre popis dostupných volieb.

Nasledovný úryvok kódu spúšťa jednoduchý proces shellu s väčšinou oblastí mien nezdieľaných so systémom. Proces vidí súčasný pracovný priečinok, ale zvyšok súborového systému je mu nedostupný. Toto mimoriadne oddelenie sa môže hodiť keď sa chcete zbaviť všetkých nechcených zásahov premenných prostredia, celosystémovo nainštalovaných knižníc alebo súborov nastavení.

guix shell --container

Je to čisté, holé a vyprahnuté prostredie. Zistíte, že neobsahuje ani GNU coreutils, takže pre prebádanie tejto pustiny musíte použiť vstavané príkazy shellu. Aj z obvykle obrovského priečinka /gnu/store zostal iba tieň.

$ echo /gnu/store/*
/gnu/store/…-gcc-10.3.0-lib
/gnu/store/…-glibc-2.33
/gnu/store/…-bash-static-5.1.8
/gnu/store/…-ncurses-6.2.20210619
/gnu/store/…-bash-5.1.8
/gnu/store/…-profile
/gnu/store/…-readline-8.1.1

V podobnom prostredí sa toho veľa urobiť nedá okrem toho, že ho opustíte. Na to vám poslúži klávesová skratka ^D alebo príkaz exit.

V kontajneri môžete sprístupniť aj iné priečinky. Použite --expose=PRIEČINOK pre podvojné pripojenie daného priečinka ku kontajneru len na čítanie, alebo použite --share=PRIEČINOK, aby sa do daného priečinka dalo aj zapisovať. Pridaním dodatočného parametra za cestou k priečinku môžete ovládať názov priečinka vrámci kontajnera. V nasledovnom príklade mapujeme /etc hostiteľského systému ako /hosť/etc v kontajneri obsahujúcom GNU coreutils.

$ guix shell --container --share=/etc=/hosť/etc coreutils
$ ls /hosť/etc

Tiež je možné zabrániť mapovaniu súčasného pracovného priečinka v kontajneri pomocou voľby --no-cwd. Ďalším dobrým nápadom je vytvorenie vyhradeného priečinka, ktorý kontajneru poslúži ako domovský priečinok, v ktorom sa spustí shell kontajnera.

Na cudzom systéme možno kontajnerové prostredie využiť na preklad programov, ktoré nemožno spojiť so systémovými knižnicami alebo so systémovým vývojovým reťazcom. Obvyklým príkladom je oblasť výskumu, kde používatelia často inštalujú balíky vrámci sedenia R. Mimo kontajnerového prostredia je pravdepodobné, že cudzí vývojový reťazec či nevhodné systémové knižnice budú nájdené ako prvé. Výsledkom sú potom nevyhovujúce binárne súbory, ktoré R nemôže využiť. V kontajneri tento problém zaniká, keďže systémové knižnice a spustiteľné súbory jednoducho nie sú prístupné kvôli nezdieľanej oblasti mien pripojení mount.

Vezmime si zrozumiteľný balíkospis poskytujúci pohodlné vývojové prostredie pre použitie s R:

(specifications->manifest
  (list "r-minimal"

        ;; základné balíky
        "bash-minimal"
        "glibc-locales"
        "nss-certs"

        ;; Všeobecné nástroje príkazového riadka, bez ktorých by bol kontajner pripustý.
        "coreutils"
        "grep"
        "which"
        "wget"
        "sed"

        ;; Nástroje značkovacieho jazyka R
        "pandoc"

        ;; Vývojový reťazec a všeobecné knižnice pre „install.packages“
        "gcc-toolchain@10"
        "gfortran-toolchain"
        "gawk"
        "tar"
        "gzip"
        "unzip"
        "make"
        "cmake"
        "pkg-config"
        "cairo"
        "libxt"
        "openssl"
        "curl"
        "zlib"))

Použime tento balíkospis pre spustenie R v kontajnerovom prostredí. Pre zjednodušenie zdieľame sieťovú oblasť mien net pre prístup k sieťovým rozhraniam hostiteľského systému. Teraz môžeme zostavovať balíky R zo zdrojového kódu obvyklým spôsobom bez obáv o rozpory týkajúce sa ABI alebo o iné ťažkosti.

$ guix shell --container --network --manifest=balikospis.scm -- R

R version 4.2.1 (2022-06-23) -- "Funny-Looking Kid"
Copyright (C) 2022 The R Foundation for Statistical Computing
…
> e <- Sys.getenv("GUIX_ENVIRONMENT")
> Sys.setenv(GIT_SSL_CAINFO=paste0(e, "/etc/ssl/certs/ca-certificates.crt"))
> Sys.setenv(SSL_CERT_FILE=paste0(e, "/etc/ssl/certs/ca-certificates.crt"))
> Sys.setenv(SSL_CERT_DIR=paste0(e, "/etc/ssl/certs"))
> install.packages("Cairo", lib=paste0(getwd()))
…
* installing *source* package 'Cairo' ...
…
* DONE (Cairo)

The downloaded source packages are in
	'/tmp/RtmpCuwdwM/downloaded_packages'
> library("Cairo", lib=getwd())
> # success!

Používanie kontajnerov je zábavné, ale pri viac ako jednom interaktívnom procese sa môžu zdať ťažkopádne. Niektoré úlohy sú oveľa ľahšie zvládnuteľné ak sú založené na skalopevnom základe plného systému Guix a jeho bohatej množine systémových služieb. V ďalšom oddieli si ukážeme ako spustiť plný systém Guix v kontajneri.

4.2 Kontajnery systému Guix

Systém Guix poskytuje široké pole systémových služieb s deklaratívnym nastavením vzájomne prepojených tak, aby vytvárali spoľahlivý a bezstavový základ GNU systému pre akékoľvek úlohy. Aj pri použití Guixu na cudzej distribúcií môžete využiť výhody systému Guix spustením systémovej inštancie v podobe kontajnera. Vďaka vlastnostiam nezdieľaných oblastí mien spomínaných v predošlom oddieli je výsledná inštancia systému Guix oddelená od hostiteľského systému a zdieľa s ním len tie umiestnenia súborového systému, ktoré ste si výslovne zvolili.

Kontajner systému Guix sa od procesu shell vytvoreného pomocou guix shell --container v mnohých ohľadoch líši. Zatiaľčo v kontajnerovom shelle je hlavným oddeleným procesom Bash, v kontajneri so systémom Guix beží pod PID 1 Shepherd. V tomto prípade sú tiež všetky systémové služby (see Services in GNU Guix Reference Manual) nastavené tak, ako by boli v systéme Guix vrámci virtuálneho stroja alebo na skutočnom vybavení. To zahŕňa démonov spravovaných GNU Shepherdom (see Shepherd Services in GNU Guix Reference Manual) ako aj ďalšie druhy rozšírení operačného systému (see Service Composition in GNU Guix Reference Manual).

Pozorovanú zvýšenú zložitosť v používaní kontajnerov so systémom Guix možno jednoducho zdôvodniť keď sa musíte vysporiadať so zložitými aplikáciami, ktoré majú vyššie či len prísnejšie požiadavky na prostredie, v ktorom sú spúšťané, napr. súbory nastavení, vyhradené používateľské účty, priečinky vyrovnávacej pamäte, súbory záznamov a pod. Systém Guix tento druh požiadaviek spĺňa nasadením systémových služieb.

• Databázový kontajner
• Prístup do siete vrámci kontajnera

(service postgresql-service-type
         (postgresql-configuration
          (postgresql postgresql-14)))

(use-modules (gnu))
(use-package-modules databases)
(use-service-modules databases)

(operating-system
  (host-name "container")
  (timezone "Europe/Bratislava")
  (file-systems (cons (file-system
                        (device (file-system-label "co-ma-po-tom"))
                        (mount-point "/")
                        (type "ext4"))
                      %base-file-systems))
  (bootloader (bootloader-configuration
               (bootloader grub-bootloader)
               (targets '("/dev/sdX"))))
  (services
   (cons* (service postgresql-service-type
                   (postgresql-configuration
                    (postgresql postgresql-14)
                    (config-file
                     (postgresql-config-file
                      (log-destination "stderr")
                      (hba-file
                       (plain-file "pg_hba.conf"
                                   "\
local	all	all			trust
host	all	all	10.0.0.1/32 	trust"))
                      (extra-config
                       '(("listen_addresses" "*")
                         ("log_directory"    "/var/log/postgresql")))))))
          (service postgresql-role-service-type
                   (postgresql-role-configuration
                    (roles
                     (list (postgresql-role
                            (name "skuska")
                            (create-database? #t))))))
          %base-services)))

$ guix system container os.scm
Zostavia sa nasledovné odvodeniny:
  /gnu/store/…-run-container.drv
  …
building /gnu/store/…-run-container.drv...
/gnu/store/…-run-container

$ sudo /gnu/store/…-run-container
systémový kontajner beží pod PID 5983
…

$ guix shell util-linux
$ sudo nsenter -a -t 5983
root@container /# pgrep -a postgres
49 /gnu/store/…-postgresql-14.4/bin/postgres -D /var/lib/postgresql/data --config-file=/gnu/store/…-postgresql.conf -p 5432
51 postgres: checkpointer
52 postgres: background writer
53 postgres: walwriter
54 postgres: autovacuum launcher
55 postgres: stats collector
56 postgres: logical replication launcher
root@container /# exit

pid=5983
ns="guix-skuska"
host="veth-skuska"
client="ceth-skuska"

# Pripojiť novú oblasť mien „guix-skuska“ k PID kontajnera.
sudo ip netns attach $ns $pid

# Vytvoriť pár zariadení.
sudo ip link add $host type veth peer name $client

# Presunúť klientske zariadenie do oblasti mien kontajnera.
sudo ip link set $client netns $ns

sudo ip link set $host up
sudo ip addr add 10.0.0.1/24 dev $host

sudo ip netns exec $ns  ip link set lo up
sudo ip netns exec $ns  ip link set $client up
sudo ip netns exec $ns  ip addr add 10.0.0.2/24 dev $client

$ psql -h 10.0.0.2 -U skuska
psql (14.4)
Type "help" for help.

skuska=> CREATE TABLE ahoj (kto TEXT NOT NULL);
CREATE TABLE
skuska=> INSERT INTO ahoj (kto) VALUES ('svet');
INSERT 0 1
skuska=> SELECT * FROM ahoj;
  kto
-------
 svet
(1 row)

sudo kill $pid
sudo ip netns del $ns
sudo ip link del $host

5.1 Sieťový most pre QEMU

By default, QEMU uses a so-called “user mode” host network back-end, which is convenient as it does not require any configuration. Unfortunately, it is also quite limited. In this mode, the guest VM (virtual machine) can access the network the same way the host would, but it cannot be reached from the host. Additionally, since the QEMU user networking mode relies on ICMP, ICMP-based networking tools such as ping do not work in this mode. Thus, it is often desirable to configure a network bridge, which enables the guest to fully participate in the network. This is necessary, for example, when the guest is to be used as a server.

• Creating a network bridge interface
• Configuring the QEMU bridge helper script
• Invoking QEMU with the right command line options
• Networking issues caused by Docker

# nmcli con add type bridge con-name br0 ifname br0

# nmcli con add type bridge-slave ifname enp2s0 master br0

(privileged-programs
 (cons (privileged-program
         (program (file-append qemu "/libexec/qemu-bridge-helper"))
         (setuid? #t))
       %default-privileged-programs))

(extra-special-file "/etc/qemu/host.conf" "allow br0\n")

$ qemu-system-x86_64 [...] \
    -device virtio-net-pci,netdev=user0,mac=XX:XX:XX:XX:XX:XX \
    -netdev bridge,id=user0,br=br0 \
    [...]

mac_address="52:54:00:$(dd if=/dev/urandom bs=512 count=1 2>/dev/null \
                           | md5sum \
                           | sed -E 's/^(..)(..)(..).*$/\1:\2:\3/')"
echo $mac_address

(service iptables-service-type
             (iptables-configuration
              (ipv4-rules (plain-file "iptables.rules" "\
*filter
:INPUT ACCEPT [0:0]
:FORWARD DROP [0:0]
:OUTPUT ACCEPT [0:0]
-A FORWARD -i br0 -o br0 -j ACCEPT
COMMIT
"))

5.2 Smerovaná sieť pre libvirt

If the machine hosting your virtual machines is connected wirelessly to the network, you won’t be able to use a true network bridge as explained in the preceding section (see Sieťový most pre QEMU). In this case, the next best option is to use a virtual bridge with static routing and to configure a libvirt-powered virtual machine to use it (via the virt-manager GUI for example). This is similar to the default mode of operation of QEMU/libvirt, except that instead of using NAT (Network Address Translation), it relies on static routes to join the VM (virtual machine) IP address to the LAN (local area network). This provides two-way connectivity to and from the virtual machine, which is needed for exposing services hosted on the virtual machine.

• Creating a virtual network bridge
• Configuring the static routes for your virtual bridge

<network>
  <name>virbr0</name>
  <bridge name="virbr0" />
  <forward mode="route"/>
  <ip address="192.168.2.0" netmask="255.255.255.0">
    <dhcp>
      <range start="192.168.2.1" end="192.168.2.254"/>
    </dhcp>
  </ip>
</network>

virsh net-define /tmp/virbr0.xml
virsh net-autostart virbr0
virsh net-start virbr0

6.1 Profily Guix v praxi

Guix má veľmi užitočnú schopnosť, o ktorej noví používatelia málokedy vedia: profily. Sú spôsobom ako zoskupiť inštalácie balíkov a všetci používatelia rovnakého systému môžu používať toľko rôznych profil, koľko len chcú.

Či už ste vývojár alebo nie, profily vám môžu poskytnúť veľa možností. Napriek tomu, že sa od tradičných správcov balíkov myšlienkovo líšia, môžu byť veľmi užitočné, keď sa s nimi naučíte pracovať.

Poznámka: This section is an opinionated guide on the use of multiple profiles. It predates guix shell and its fast profile cache (see Invoking guix shell in GNU Guix Reference Manual).

In many cases, you may find that using guix shell to set up the environment you need, when you need it, is less work that maintaining a dedicated profile. Your call!

Ak ste oboznámení s ‘virtualenv’ v Pythone, môžete si profily predstaviť ako všeobecné ‘virtualenv’, ktoré môžu obsahovať ľubovoľné programové vybavenie, a nie len to založené na Pythone. Okrem toho, profily sú sebestačné: zachytávajú všetky závislosti potrebné pre beh programov, čo zaručuje, že všetky programy v profile budú fungovať vždy a v každom čase.

Viacero profilov má mnoho výhod:

• Jasné významové oddelenie rozličných balíkov, ktoré využívate v rôznych súvislostiach.
• Viacero profilov možno v prostredí sprístupniť buď pri prihlásení, alebo vrámci vyhradeného shellu.
• Profily možno načítať na požiadanie. Napríklad, môžete používať viacero shellov a v každom z nich môže bežať iný profil.
• Oddelenie: Programy z jedného profilu nebudú používať programy z druhého. Môžete tiež nainštalovať rôzne vydania rovnakých programov do dvoch rôznych profilov bez vzájomných rozporov.
• Znásobenie: Profily môžu zdieľať rovnaké závislosti, čo umožňuje ušetriť úložné miesto.
• Opakovateľné: pri použití so zadaným balíkospisom môže byť profil jasne určený úpravou Guixu, ktorá bola použitá pri jeho spustení. To znamená, že ten istý profil možno napodobniť kdekoľvek a kedykoľvek iba na základe údaju o použitej úprave. Viď oddiel Opakovateľné profily.
• Jednoduchšie aktualizácie a spravovanie: Pri viacerých profiloch je jednoduché udržiavať zoznamy balíkov poruke a zaistiť ich bezstarostné aktualizovanie.

Niekoľko príznačných a často používaných profilov:

• Závislosti projektu, na ktorom pracujete.
• Knižnice vášho obľúbeného programovacieho jazyka.
• Programy príznačné pre prenosný počítač (ako ‘powertop’), ktoré nepotrebujete na stolnom počítači.
• TeXlive (tento sa môže zvlášť hodiť, keď potrebujete nainštalovať len jeden balík pre dokument, ktorý vám práve prišiel elektronickou poštou).
• Hry.

Ponorme sa do toho!

• Základné použitie balíkospisov
• Požadované balíky
• Predvolený profil
• Výhody balíkospisov
• Opakovateľné profily

(specifications->manifest
  '("balik-1"
    ;; Vydanie 1.3 balíka balik-2.
    "balik-2@1.3"
    ;; Výstup „lib“ balíka balik-3.
    "balik-3:lib"
    ; ...
    "balik-N"))

GUIX_DOPLNKOVE_PROFILY=$HOME/.guix-extra-profiles
mkdir -p "$GUIX_DOPLNKOVE_PROFILY"/moj-projekt # ak ešte nejestvuje
guix package --manifest=/cesta/ku/guix-balikospis-mojho-projektu.scm \
 --profile="$GUIX_DOPLNKOVE_PROFILY"/moj-projekt/moj-projekt

guix package --list-profiles

for i in $GUIX_DOPLNKOVE_PROFILY/*; do
  profile=$i/$(basename "$i")
  if [ -f "$profile"/etc/profile ]; then
    GUIX_PROFILE="$profile"
    . "$GUIX_PROFILE"/etc/profile
  fi
  unset profile
done

for i in "$GUIX_DOPLNKOVE_PROFILY"/moj-projekt-1 "$GUIX_DOPLNKOVE_PROFILY"/moj-projekt-2; do
  profile=$i/$(basename "$i")
  if [ -f "$profile"/etc/profile ]; then
    GUIX_PROFILE="$profile"
    . "$GUIX_PROFILE"/etc/profile
  fi
  unset profile
done

GUIX_PROFILE="cesta/k/moj-projekt" ; . "$GUIX_PROFILE"/etc/profile

guix package --search-paths=prefix --profile=$moj_profil"

guix package -m /cesta/ku/guix-balikospis-mojho-projektu.scm \
 -p "$GUIX_DOPLNKOVE_PROFILY"/moj-projekt/moj-projekt

for profile in "$GUIX_DOPLNKOVE_PROFILY"/*; do
  guix package --profile="$profil" \
   --manifest="$HOME/.guix-manifests/guix-$profil-balikospis.scm"
done

guix package -p "$GUIX_DOPLNKOVE_PROFILY"/moj-projekt/moj-projekt --list-generations

guix package -p "$GUIX_DOPLNKOVE_PROFILY"/moj-projekt/moj-projekt --switch-generations=17

env -i $(which bash) --login --noprofile --norc
. moj-projekt/etc/profile

guix install balik-jablko
guix upgrade balik-hruska

GUIX_DOPLNKOVE_PROFILY=$HOME/.guix-doplnkove-profily
GUIX_DOPLNKY=$HOME/.guix-doplnky

mkdir -p "$GUIX_DOPLNKY"/moj-projekt
guix pull --channels=urcenie-kanalov.scm --profile="$GUIX_DOPLNKY/moj-projekt/guix"

mkdir -p "$GUIX_DOPLNKOVE_PROFILY/moj-projekt"
"$GUIX_DOPLNKY"/moj-projekt/guix/bin/guix package \
 --manifest=/cesta/ku/guix-balikospis-mojho-projektu.scm \
 --profile="$GUIX_DOPLNKOVE_PROFILY"/moj-projekt/moj-projekt

7.1 Začíname

How do we go about “Guixifying” a repository? The first step, as we’ve seen, will be to add a guix.scm at the root of the repository in question. We’ll take Guile as an example in this chapter: it’s written in Scheme (mostly) and C, and has a number of dependencies—a C compilation tool chain, C libraries, Autoconf and its friends, LaTeX, and so on. The resulting guix.scm looks like the usual package definition (see Defining Packages in GNU Guix Reference Manual), just without the define-public bit:

;; The ‘guix.scm’ file for Guile, for use by ‘guix shell’.

(use-modules (guix)
             (guix build-system gnu)
             ((guix licenses) #:prefix license:)
             (gnu packages autotools)
             (gnu packages base)
             (gnu packages bash)
             (gnu packages bdw-gc)
             (gnu packages compression)
             (gnu packages flex)
             (gnu packages gdb)
             (gnu packages gettext)
             (gnu packages gperf)
             (gnu packages libffi)
             (gnu packages libunistring)
             (gnu packages linux)
             (gnu packages pkg-config)
             (gnu packages readline)
             (gnu packages tex)
             (gnu packages texinfo)
             (gnu packages version-control))

(package
  (name "guile")
  (version "3.0.99-git")                          ;funky version number
  (source #f)                                     ;no source
  (build-system gnu-build-system)
  (native-inputs
   (append (list autoconf
                 automake
                 libtool
                 gnu-gettext
                 flex
                 texinfo
                 texlive-base                 ;for "make pdf"
                 texlive-epsf
                 gperf
                 git
                 gdb
                 strace
                 readline
                 lzip
                 pkg-config)

           ;; When cross-compiling, a native version of Guile itself is
           ;; needed.
           (if (%current-target-system)
               (list this-package)
               '())))
  (inputs
   (list libffi bash-minimal))
  (propagated-inputs
   (list libunistring libgc))

  (native-search-paths
   (list (search-path-specification
          (variable "GUILE_LOAD_PATH")
          (files '("share/guile/site/3.0")))
         (search-path-specification
          (variable "GUILE_LOAD_COMPILED_PATH")
          (files '("lib/guile/3.0/site-ccache")))))
  (synopsis "Scheme implementation intended especially for extensions")
  (description
   "Guile is the GNU Ubiquitous Intelligent Language for Extensions,
and it's actually a full-blown Scheme implementation!")
  (home-page "https://www.gnu.org/software/guile/")
  (license license:lgpl3+))

Quite a bit of boilerplate, but now someone who’d like to hack on Guile now only needs to run:

guix shell

That gives them a shell containing all the dependencies of Guile: those listed above, but also implicit dependencies such as the GCC tool chain, GNU Make, sed, grep, and so on. See Invoking guix shell in GNU Guix Reference Manual, for more info on guix shell.

The chef’s recommendation: Our suggestion is to create development environments like this:

guix shell --container --link-profile

... or, for short:

guix shell -CP

That gives a shell in an isolated container, and all the dependencies show up in $HOME/.guix-profile, which plays well with caches such as config.cache (see Cache Files in Autoconf) and absolute file names recorded in generated Makefiles and the likes. The fact that the shell runs in a container brings peace of mind: nothing but the current directory and Guile’s dependencies is visible inside the container; nothing from the system can possibly interfere with your development.

7.2 Level 1: Building with Guix

Now that we have a package definition (see Začíname), why not also take advantage of it so we can build Guile with Guix? We had left the source field empty, because guix shell above only cares about the inputs of our package—so it can set up the development environment—not about the package itself.

To build the package with Guix, we’ll need to fill out the source field, along these lines:

(use-modules (guix)
             (guix git-download)  ;for ‘git-predicate’
             …)

(define vcs-file?
  ;; Return true if the given file is under version control.
  (or (git-predicate (current-source-directory))
      (const #t)))                                ;not in a Git checkout

(package
  (name "guile")
  (version "3.0.99-git")                          ;funky version number
  (source (local-file "." "guile-checkout"
                      #:recursive? #t
                      #:select? vcs-file?))
  …)

Here’s what we changed compared to the previous section:

1. We added (guix git-download) to our set of imported modules, so we can use its git-predicate procedure.
2. We defined vcs-file? as a procedure that returns true when passed a file that is under version control. For good measure, we add a fallback case for when we’re not in a Git checkout: always return true.
3. We set source to a local-file—a recursive copy of the current directory ("."), limited to files under version control (the #:select? bit).

From there on, our guix.scm file serves a second purpose: it lets us build the software with Guix. The whole point of building with Guix is that it’s a “clean” build—you can be sure nothing from your working tree or system interferes with the build result—and it lets you test a variety of things. First, you can do a plain native build:

guix build -f guix.scm

But you can also build for another system (possibly after setting up see offloading in GNU Guix Reference Manual or see transparent emulation in GNU Guix Reference Manual):

guix build -f guix.scm -s aarch64-linux -s riscv64-linux

… or cross-compile:

guix build -f guix.scm --target=x86_64-w64-mingw32

You can also use package transformations to test package variants (see Package Transformation Options in GNU Guix Reference Manual):

# What if we built with Clang instead of GCC?
guix build -f guix.scm \
  --with-c-toolchain=guile@3.0.99-git=clang-toolchain

# What about that under-tested configure flag?
guix build -f guix.scm \
  --with-configure-flag=guile@3.0.99-git=--disable-networking

Handy!

7.3 Level 2: The Repository as a Channel

We now have a Git repository containing (among other things) a package definition (see Level 1: Building with Guix). Can’t we turn it into a channel (see Channels in GNU Guix Reference Manual)? After all, channels are designed to ship package definitions to users, and that’s exactly what we’re doing with our guix.scm.

Turns out we can indeed turn it into a channel, but with one caveat: we must create a separate directory for the .scm file(s) of our channel so that guix pull doesn’t load unrelated .scm files when someone pulls the channel—and in Guile, there are lots of them! So we’ll start like this, keeping a top-level guix.scm symlink for the sake of guix shell:

mkdir -p .guix/modules
mv guix.scm .guix/modules/guile-package.scm
ln -s .guix/modules/guile-package.scm guix.scm

To make it usable as part of a channel, we need to turn our guix.scm file into a package module (see Package Modules in GNU Guix Reference Manual): we do that by changing the use-modules form at the top to a define-module form. We also need to actually export a package variable, with define-public, while still returning the package value at the end of the file so we can still use guix shell and guix build -f guix.scm. The end result looks like this (not repeating things that haven’t changed):

(define-module (guile-package)
  #:use-module (guix)
  #:use-module (guix git-download)   ;for ‘git-predicate’
  …)

(define vcs-file?
  ;; Return true if the given file is under version control.
  (or (git-predicate (dirname (dirname (current-source-directory))))
      (const #t)))                                ;not in a Git checkout

(define-public guile
  (package
    (name "guile")
    (version "3.0.99-git")                          ;funky version number
    (source (local-file "../.." "guile-checkout"
                        #:recursive? #t
                        #:select? vcs-file?))
    …))

;; Return the package object define above at the end of the module.
guile

We need one last thing: a .guix-channel file so Guix knows where to look for package modules in our repository:

;; This file lets us present this repo as a Guix channel.

(channel
  (version 0)
  (directory ".guix/modules"))  ;look for package modules under .guix/modules/

To recap, we now have these files:

.
├── .guix-channel
├── guix.scm → .guix/modules/guile-package.scm
└── .guix
    └── modules
       └── guile-package.scm

And that’s it: we have a channel! (We could do better and support channel authentication so users know they’re pulling genuine code. We’ll spare you the details here but it’s worth considering!) Users can pull from this channel by adding it to ~/.config/guix/channels.scm, along these lines:

(append (list (channel
                (name 'guile)
                (url "https://git.savannah.gnu.org/git/guile.git")
                (branch "main")))
        %default-channels)

After running guix pull, we can see the new package:

$ guix describe
Generation 264  May 26 2023 16:00:35    (current)
  guile 36fd2b4
    repository URL: https://git.savannah.gnu.org/git/guile.git
    branch: main
    commit: 36fd2b4920ae926c79b936c29e739e71a6dff2bc
  guix c5bc698
    repository URL: https://git.savannah.gnu.org/git/guix.git
    commit: c5bc698e8922d78ed85989985cc2ceb034de2f23
$ guix package -A ^guile$
guile   3.0.99-git      out,debug       guile-package.scm:51:4
guile   3.0.9           out,debug       gnu/packages/guile.scm:317:2
guile   2.2.7           out,debug       gnu/packages/guile.scm:258:2
guile   2.2.4           out,debug       gnu/packages/guile.scm:304:2
guile   2.0.14          out,debug       gnu/packages/guile.scm:148:2
guile   1.8.8           out             gnu/packages/guile.scm:77:2
$ guix build guile@3.0.99-git
[…]
/gnu/store/axnzbl89yz7ld78bmx72vpqp802dwsar-guile-3.0.99-git-debug
/gnu/store/r34gsij7f0glg2fbakcmmk0zn4v62s5w-guile-3.0.99-git

That’s how, as a developer, you get your software delivered directly into the hands of users! No intermediaries, yet no loss of transparency and provenance tracking.

With that in place, it also becomes trivial for anyone to create Docker images, Deb/RPM packages, or a plain tarball with guix pack (see Invoking guix pack in GNU Guix Reference Manual):

# How about a Docker image of our Guile snapshot?
guix pack -f docker -S /bin=bin guile@3.0.99-git

# And a relocatable RPM?
guix pack -f rpm -R -S /bin=bin guile@3.0.99-git

7.4 Bonus: Package Variants

We now have an actual channel, but it contains only one package (see Level 2: The Repository as a Channel). While we’re at it, we can define package variants (see Defining Package Variants in GNU Guix Reference Manual) in our guile-package.scm file, variants that we want to be able to test as Guile developers—similar to what we did above with transformation options. We can add them like so:

;; This is the ‘.guix/modules/guile-package.scm’ file.

(define-module (guile-package)
  …)

(define-public guile
  …)

(define (package-with-configure-flags p flags)
  "Return P with FLAGS as additional 'configure' flags."
  (package/inherit p
    (arguments
     (substitute-keyword-arguments (package-arguments p)
       ((#:configure-flags original-flags #~(list))
        #~(append #$original-flags #$flags))))))

(define-public guile-without-threads
  (package
    (inherit (package-with-configure-flags guile
                                           #~(list "--without-threads")))
    (name "guile-without-threads")))

(define-public guile-without-networking
  (package
    (inherit (package-with-configure-flags guile
                                           #~(list "--disable-networking")))
    (name "guile-without-networking")))


;; Return the package object defined above at the end of the module.
guile

We can build these variants as regular packages once we’ve pulled the channel. Alternatively, from a checkout of Guile, we can run a command like this one from the top level:

guix build -L $PWD/.guix/modules guile-without-threads

7.5 Level 3: Setting Up Continuous Integration

The channel we defined above (see Level 2: The Repository as a Channel) becomes even more interesting once we set up continuous integration (CI). There are several ways to do that.

You can use one of the mainstream continuous integration tools, such as GitLab-CI. To do that, you need to make sure you run jobs in a Docker image or virtual machine that has Guix installed. If we were to do that in the case of Guile, we’d have a job that runs a shell command like this one:

guix build -L $PWD/.guix/modules guile@3.0.99-git

Doing this works great and has the advantage of being easy to achieve on your favorite CI platform.

That said, you’ll really get the most of it by using Cuirass, a CI tool designed for and tightly integrated with Guix. Using it is more work than using a hosted CI tool because you first need to set it up, but that setup phase is greatly simplified if you use its Guix System service (see Continuous Integration in GNU Guix Reference Manual). Going back to our example, we give Cuirass a spec file that goes like this:

;; Cuirass spec file to build all the packages of the ‘guile’ channel.
(list (specification
        (name "guile")
        (build '(channels guile))
        (channels
         (append (list (channel
                         (name 'guile)
                         (url "https://git.savannah.gnu.org/git/guile.git")
                         (branch "main")))
                 %default-channels))))

It differs from what you’d do with other CI tools in two important ways:

• Cuirass knows it’s tracking two channels, guile and guix. Indeed, our own guile package depends on many packages provided by the guix channel—GCC, the GNU libc, libffi, and so on. Changes to packages from the guix channel can potentially influence our guile build and this is something we’d like to see as soon as possible as Guile developers.
• Build results are not thrown away: they can be distributed as substitutes so that users of our guile channel transparently get pre-built binaries! (see Substitutes in GNU Guix Reference Manual, for background info on substitutes.)

From a developer’s viewpoint, the end result is this status page listing evaluations: each evaluation is a combination of commits of the guix and guile channels providing a number of jobs—one job per package defined in guile-package.scm times the number of target architectures.

As for substitutes, they come for free! As an example, since our guile jobset is built on ci.guix.gnu.org, which runs guix publish (see Invoking guix publish in GNU Guix Reference Manual) in addition to Cuirass, one automatically gets substitutes for guile builds from ci.guix.gnu.org; no additional work is needed for that.

7.6 Bonus: Build manifest

The Cuirass spec above is convenient: it builds every package in our channel, which includes a few variants (see Level 3: Setting Up Continuous Integration). However, this might be insufficiently expressive in some cases: one might want specific cross-compilation jobs, transformations, Docker images, RPM/Deb packages, or even system tests.

To achieve that, you can write a manifest (see Writing Manifests in GNU Guix Reference Manual). The one we have for Guile has entries for the package variants we defined above, as well as additional variants and cross builds:

;; This is ‘.guix/manifest.scm’.

(use-modules (guix)
             (guix profiles)
             (guile-package))   ;import our own package module

(define* (package->manifest-entry* package system
                                   #:key target)
  "Return a manifest entry for PACKAGE on SYSTEM, optionally cross-compiled to
TARGET."
  (manifest-entry
    (inherit (package->manifest-entry package))
    (name (string-append (package-name package) "." system
                         (if target
                             (string-append "." target)
                             "")))
    (item (with-parameters ((%current-system system)
                            (%current-target-system target))
            package))))

(define native-builds
  (manifest
   (append (map (lambda (system)
                  (package->manifest-entry* guile system))

                '("x86_64-linux" "i686-linux"
                  "aarch64-linux" "armhf-linux"
                  "powerpc64le-linux"))
           (map (lambda (guile)
                  (package->manifest-entry* guile "x86_64-linux"))
                (cons (package
                        (inherit (package-with-c-toolchain
                                  guile
                                  `(("clang-toolchain"
                                     ,(specification->package
                                       "clang-toolchain")))))
                        (name "guile-clang"))
                      (list guile-without-threads
                            guile-without-networking
                            guile-debug
                            guile-strict-typing))))))

(define cross-builds
  (manifest
   (map (lambda (target)
          (package->manifest-entry* guile "x86_64-linux"
                                    #:target target))
        '("i586-pc-gnu"
          "aarch64-linux-gnu"
          "riscv64-linux-gnu"
          "i686-w64-mingw32"
          "x86_64-linux-gnu"))))

(concatenate-manifests (list native-builds cross-builds))

We won’t go into the details of this manifest; suffice to say that it provides additional flexibility. We now need to tell Cuirass to build this manifest, which is done with a spec slightly different from the previous one:

;; Cuirass spec file to build all the packages of the ‘guile’ channel.
(list (specification
        (name "guile")
        (build '(manifest ".guix/manifest.scm"))
        (channels
         (append (list (channel
                         (name 'guile)
                         (url "https://git.savannah.gnu.org/git/guile.git")
                         (branch "main")))
                 %default-channels))))

We changed the (build …) part of the spec to '(manifest ".guix/manifest.scm") so that it would pick our manifest, and that’s it!

7.7 Wrapping Up

We picked Guile as the running example in this chapter and you can see the result here:

• .guix-channel;
• .guix/modules/guile-package.scm with the top-level guix.scm symlink;
• .guix/manifest.scm.

These days, repositories are commonly peppered with dot files for various tools: .envrc, .gitlab-ci.yml, .github/workflows, Dockerfile, .buildpacks, Aptfile, requirements.txt, and whatnot. It may sound like we’re proposing a bunch of additional files, but in fact those files are expressive enough to supersede most or all of those listed above.

With a couple of files, we get support for:

• development environments (guix shell);
• pristine test builds, including for package variants and for cross-compilation (guix build);
• continuous integration (with Cuirass or with some other tool);
• continuous delivery to users (via the channel and with pre-built binaries);
• generation of derivative build artifacts such as Docker images or Deb/RPM packages (guix pack).

This a nice (in our view!) unified tool set for reproducible software deployment, and an illustration of how you as a developer can benefit from it!

8.1 Guix prostredie cez direnv

Guix poskytuje balík ‘direnv’, ktorým možno rozšíriť prostredie shellu po zmene priečinka. Tento nástroj sa dá využiť na prípravu čistého prostredia Guix.

Nasledovný príklad poskytuje shellovskú funkciu pre súbor ~/.direnvrc, ktorú možno použiť z Git repozitára Guixu v súbore ~/src/guix/.envrc na nastavenie vývojového prostredia podobnému tomu, ktoré je opísané v see Building from Git in GNU Guix Reference Manual.

Vytvorte súbor ~/.direnvrc obsahujúci nasledovný kód Bash:

# Vďaka <https://github.com/direnv/direnv/issues/73#issuecomment-152284914>
export_function()
{
  local name=$1
  local alias_dir=$PWD/.direnv/aliases
  mkdir -p "$alias_dir"
  PATH_add "$alias_dir"
  local target="$alias_dir/$name"
  if declare -f "$name" >/dev/null; then
    echo "#!$SHELL" > "$target"
    declare -f "$name" >> "$target" 2>/dev/null
    # Všimnite si, že pridávame premenné shellu do spúšťača funkcie.
    echo "$name \$*" >> "$target"
    chmod +x "$target"
  fi
}

use_guix()
{
    # Nastaviť žetón pre GitHub.
    export GUIX_GITHUB_TOKEN="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

    # Vyčistiť „GUIX_PACKAGE_PATH“.
    export GUIX_PACKAGE_PATH=""

    # Opätovne vytvoriť koreň zberača odpadkov.
    gcroots="$HOME/.config/guix/gcroots"
    mkdir -p "$gcroots"
    gcroot="$gcroots/guix"
    if [ -L "$gcroot" ]
    then
        rm -v "$gcroot"
    fi

    # Doplnkové balíky.
    PACKAGES_MAINTENANCE=(
        direnv
        git
        git:send-email
        git-cal
        gnupg
        guile-colorized
        guile-readline
        less
        ncurses
        openssh
        xdot
    )

    # Balíky prostredia.
    PACKAGES=(help2man guile-sqlite3 guile-gcrypt)

    # Vďaka <https://lists.gnu.org/archive/html/guix-devel/2016-09/msg00859.html>
    eval "$(guix shell --search-paths --root="$gcroot" --pure \
     --development guix ${PACKAGES[@]} ${PACKAGES_MAINTENANCE[@]} "$@")"

    # Vopred zadať voľby nastavenia.
    configure()
    {
        ./configure
    }
    export_function configure

    # Spustiť „make“ a možno niečo zostaviť.
    build()
    {
        make -j 2
        if [ $# -gt 0 ]
        then
            ./pre-inst-env guix build "$@"
        fi
    }
    export_function build

    # Vopred zadať Git príkaz pre odoslanie zmien.
    push()
    {
        git push --set-upstream origin
    }
    export_function push

    clear                        # Vyčistiť obrazovku.
    git-cal --author='Vaše meno' # Zobraziť kalendár zmien.

    # Zobraziť pomocníka príkazov.
    echo "
build          zostaviť balík alebo iba projekt ak nebol poskytnutý žiaden parameter
configure      vykonať ./configure s predvolenými voľbami
push           odoslať zmeny do vzdialeného repozitára Git
"
}

Každý projekt obsahujúci .envrc s reťazcom use guix bude mať vopred pripravené premenné prostredia a funkcie.

Vykonajte direnv allow pre prvé nastavenie prostredia.

9.1 Nastavenie hlavného uzla

Odporúčaný postup je nastaviť jeden hlavný uzol, kde bude bežať guix-daemon, a /gnu/store uzlom sprístupniť cez NFS.

Zapamätajte si, že guix-daemon je zodpovedný za spúšťanie zostavovacích procesov a sťahovaní v mene klientov (see Invoking guix-daemon in GNU Guix Reference Manual), a v širšom ohľade za prístup ku /gnu/store, ktoré obsahuje binárne súbory všetkých balíkov zostavené každým z používateľov. „Klient“ tu odkazuje na všetky Guix príkazy prístupné pre používateľov, ako guix install. Na zhluku počítačov môžu tieto príkazy bežať na výpočtových uzloch a musia byť v spojení s guix-daemon na hlavnom uzle.

Na začiatok, inštaláciu na hlavný uzol možno vykonať podľa obvyklého postupu (see Binary Installation in GNU Guix Reference Manual). Vďaka inštalačnému skriptu by to malo byť rýchle. Po dokončení inštalácie musíme vykonať niekoľko prispôsobení.

Pretože chceme, aby bol guix-daemon dostupný nie len z hlavného uzla, ale aj z výpočtových uzlov, musíme to zariadiť tak, aby zisťoval prichádzajúce pripojenia cez TCP/IP. Upravíme, teda, spúšťací súbor systemd /etc/systemd/system/guix-daemon.service pre guix-daemon a pridáme voľbu --listen na riadok s ExecStart asi takto:

ExecStart=/var/guix/profiles/per-user/root/current-guix/bin/guix-daemon --build-users-group=guixbuild --listen=/var/guix/daemon-socket/socket --listen=0.0.0.0

Pre uplatnenie zmien musíme službu opätovne spustiť:

systemctl daemon-reload
systemctl restart guix-daemon

Poznámka: --listen=0.0.0.0 znamená, že guix-daemon spracuje všetky TCP pripojenia prichádzajúce cez koncový bod 44146 (see Invoking guix-daemon in GNU Guix Reference Manual). V prípade zhluku počítačov, kde je hlavný uzol prístupný výhradne z miestnej, je to vyhovujúce. Nechcete, predsa, aby bol guix-daemon prístupný aj z internetu!

Ďalším krokom je sprístupnenie úložiska cez NFS v /etc/exports asi takto:

/gnu/store    *(ro)
/var/guix     *(rw, async)
/var/log/guix *(ro)

Priečinok /gnu/store môže byť sprístupnený len na čítanie, keďže guix-daemon na hlavnom uzle ho nikdy nebude upravovať. /var/guix obsahuje profily používateľov, ktoré spravuje guix package. Aby mohli používatelia inštalovať s guix package, toto umiestnenie musí zostať prístupné aj na čítanie, aj na zápis.

Používatelia si môžu okrem predvoleného profilu ~/.guix-profile vytvoriť toľko profilov, koľko len chcú. Napríklad, guix package -p ~/dev/python-dev -i python nainštaluje Python do profilu prístupného cez symbolický odkaz ~/dev/python-dev. Aby sme sa uistili, že sa zberač odpadkov tomuto profilu vyhne—t.j., že Python nebude z /gnu/store odstránený pokiaľ sa profil používa—domovské priečinky by tiež mali byť pripojené k rovnakému uzlu. guix-daemon tak bude vedieť o týchto neobvyklých profiloch a zabráni vyčisteniu programového vybavenia, na ktoré odkazujú.

Môže byť užitočné pravidelne odstraňovať nepoužívané súbory z /gnu/store pomocou guix gc (see Invoking guix gc in GNU Guix Reference Manual). Nastavíte to pridaním vstupu contrab na hlavný uzol:

root@master# crontab -e

… s niečím takýmto:

# Každé ráno o 5:00 spustiť zberač odpadkov a zabezpečiť,
# že v /gnu/store je aspoň 10 GB voľného miesta.
0 5 * * 1  /usr/local/bin/guix gc -F10G

S hlavným uzlom sme hotoví! Pozrime sa teraz na výpočtové uzly.

9.2 Nastavenie výpočtových uzlov

Predovšetkým musíme na výpočtových uzloch pripojiť NFS priečinky sprístupnené hlavným uzlom. Môžeme tak urobiť pridaním nasledovných riadkov do /etc/fstab:

hlavny-uzol:/gnu/store    /gnu/store    nfs  defaults,_netdev,vers=3 0 0
hlavny-uzol:/var/guix     /var/guix     nfs  defaults,_netdev,vers=3 0 0
hlavny-uzol:/var/log/guix /var/log/guix nfs  defaults,_netdev,vers=3 0 0

… kde hlavny-uzol je názov alebo IP adresa vášho hlavného uzla. Potom, predpokladajúc, že prípojné body sú prítomné, by ste mali byť schopní pripojiť každý z nich ku výpočtovým uzlom.

Ďalej musíme používateľom poskytnúť predvolený guix príkaz, ktorý môžu spustiť po prvom prihlásení k zhluku počítačov (nakoniec si spustením guix pull vytvoria „vlastný“ guix príkaz). Podobne ako to inštalačný skript zariadil na hlavnom uzle, uložíme ho do /usr/local/bin:

mkdir -p /usr/local/bin
ln -s /var/guix/profiles/per-user/root/current-guix/bin/guix \
      /usr/local/bin/guix

Potom musíme guixu povedať, aby bol v spojení s démonom bežiacim na hlavnom uzle, pridaním týchto riadkov do /etc/profile:

GUIX_DAEMON_SOCKET="guix://hlavny-uzol"
export GUIX_DAEMON_SOCKET

Aby sme predišli varovným správam a uistili sa, že guix používa správne miestne jazykové nastavenie, musíme ho nastaviť na používanie údajov poskytovaných Guixom (see Application Setup in GNU Guix Reference Manual):

GUIX_LOCPATH=/var/guix/profiles/per-user/root/guix-profile/lib/locale
export GUIX_LOCPATH

# Tu musíme použiť platný názov miestneho jazykového nastavenia.
# Dostupné nastavenia môžete zobraziť pomocou „ls $GUIX_LOCPATH/*“.
LC_ALL=sk_SK.utf8
export LC_ALL

For convenience, guix package automatically generates ~/.guix-profile/etc/profile, which defines all the environment variables necessary to use the packages—PATH, C_INCLUDE_PATH, PYTHONPATH, etc. Likewise, guix pull does that under ~/.config/guix/current. Thus it’s a good idea to source both from /etc/profile:

for GUIX_PROFILE in "$HOME/.config/guix/current" "$HOME/.guix-profile"
do
  if [ -f "$GUIX_PROFILE/etc/profile" ]; then
    . "$GUIX_PROFILE/etc/profile"
  fi
done

Konečne, Guix poskytuje dopĺňanie príkazov hlavne pre Bash a zsh. Zvážte pridanie nasledovného riadka do /etc/bashrc:

. /var/guix/profiles/per-user/root/current-guix/etc/bash_completion.d/guix

A je to!

Prihláste sa na jeden z výpočtových uzlov a overte či všetko pracuje správne spustením:

guix install hello

Démon na hlavnom uzle by mal vašim menom stiahnuť pred-zostavené binárne súbory a rozbaliť ich v /gnu/store. guix install by mal vytvoriť ~/.guix-profile obsahujúci príkaz ~/.guix-profile/bin/hello.

9.3 Prístup do siete

Guix vyžaduje prístup do siete pre sťahovanie zdrojových kódov a pred-zostavených binárnych súborov. Dobrá správa je, že táto podmienka platí len pre hlavný uzol, keďže koná aj v mene výpočtových uzlov.

Uzly v zhluku počítačov majú obvykle prístup len k hostiteľom zaradeným na bielej listine. Pre náš hlavný uzol je dôležité na túto bielu listinu zaradiť aspoň ci.guix.gnu.org, odkiaľ predvolene získava pred-zostavené náhrady pre všetky balíky prítomné v samotnom Guixe.

ci.guix.gnu.org naschvál slúži aj ako zrkadlo s asociatívnym prístupom pre získavanie zdrojových kódov balíkov. Preto stačí na bielu listinu pridať len ci.guix.gnu.org.

Balíky spravované vrámci iných repozitárov, napr. v rozličných HPC kanáloch, samozrejme nie sú na ci.guix.gnu.org dostupné. Pre zahrnutie týchto balíkov môžete bielu listinu rozšíriť tak, aby bolo možné sťahovať príslušné zdrojové kódy a pred-zostavené binárne súbory (predpokladajúc, že tieto servery tretej strany pred-zostavené binárne súbory pre dotknuté balíky poskytujú). Ako poslednú možnosť si používatelia môžu zdrojový kód stiahnuť na svojom počítači a potom ho takto pridať do /gnu/store na zhluku počítačov:

GUIX_DAEMON_SOCKET=ssh://vypoctovy-uzol.priklad.sk \
  guix download http://starpu.gforge.inria.fr/files/starpu-1.2.3/starpu-1.2.3.tar.gz

Horeuvedený príkaz stiahne starpu-1.2.3.tar.gz a cez SSH ho odošle démonovi guix-daemon na zhluku počítačov.

Zhluky počítačov odpojené od vonkajšej siete vyžadujú väčšie úsilie. V tejto chvíli vám odporúčame stiahnuť všetok potrebný zdrojový kód na pracovnej stanici s Guixom. V nižšie uvedenom príklade uvádzame ako sa dá stiahnuť všetok zdrojový kód, na ktorom závisí balík openmpi pomocou voľby --sources príkazu guix build (see Invoking guix build in GNU Guix Reference Manual):

$ guix build --sources=transitive openmpi

…

/gnu/store/xc17sm60fb8nxadc4qy0c7rqph499z8s-openmpi-1.10.7.tar.bz2
/gnu/store/s67jx92lpipy2nfj5cz818xv430n4b7w-gcc-5.4.0.tar.xz
/gnu/store/npw9qh8a46lrxiwh9xwk0wpi3jlzmjnh-gmp-6.0.0a.tar.xz
/gnu/store/hcz0f4wkdbsvsdky3c0vdvcawhdkyldb-mpfr-3.1.5.tar.xz
/gnu/store/y9akh452n3p4w2v631nj0injx7y0d68x-mpc-1.0.3.tar.gz
/gnu/store/6g5c35q8avfnzs3v14dzl54cmrvddjm2-glibc-2.25.tar.xz
/gnu/store/p9k48dk3dvvk7gads7fk30xc2pxsd66z-hwloc-1.11.8.tar.bz2
/gnu/store/cry9lqidwfrfmgl0x389cs3syr15p13q-gcc-5.4.0.tar.xz
/gnu/store/7ak0v3rzpqm2c5q1mp3v7cj0rxz0qakf-libfabric-1.4.1.tar.bz2
/gnu/store/vh8syjrsilnbfcf582qhmvpg1v3rampf-rdma-core-14.tar.gz
…

(Pre lepšiu predstavu, jedná sa o približne 320 MiB stlačeného zdrojového kódu.)

Všetko to potom môžme zbaliť do jedného veľkého stlačeného súboru (see Invoking guix archive in GNU Guix Reference Manual):

$ guix archive --export \
    `guix build --sources=transitive openmpi` \
    > openmpi-zdrojovy-kod.nar

… presunúť na zhluk počítačov na vymeniteľnom zariadení a rozbaliť:

$ guix archive --import < openmpi-zdrojovy-kod.nar

Tento postup je potrebné zopakovať zakaždým, keď potrebujeme na zhluk počítačov preniesť ďalší zdrojový kód.

V čase keď bolo toto napísané, nemali vedecké zariadenia zapojené do Guix-HPC zhluky počítačov neprístupné z vonkajšej siete. Ak s takýmto nastavením máte skúsenosti, radi by sme si vypočuli vašu spätnú väzbu a návrhy.

9.4 Využitie úložného priestoru

Spoločnou otázkou systémových správcov je, či to všetko zožerie veľa úložného priestoru. Ak má niečo vyčerpať miesto na disku, tak to budú skôr vedecké údaje ako zostavené programové vybavenie—to je naša viac ako desaťročná skúsenosť s používaním Guixu na vysokovýkonných zhlukoch počítačov. Avšak, stojí za to pozrieť sa na to, ako Guix vplýva na využitie úložného priestoru.

V prvom rade, uchovávanie viacerých verzií daného balíka v /gnu/store nutne nestojí veľa, pretože guix-daemon si dokáže účinne poradiť s ukladaním podvojných súborov a spomínané verzie balíkov pravdepodobne zdieľajú veľké množstvo rovnakých súborov.

Ako sme už spomínali, odporúčame nastaviť si cron úlohu, ktorá by pravidelne spúšťala guix gc, čo odstráni nepotrebné programové vybavenie z /gnu/store. Avšak, používatelia si aj tak môžu vo svojich profiloch uchovávať veľké množstvo programov a predošlých pokolení profilov, ktoré sa z pohľadu guix gc nedajú odstrániť.

Riešením pre používateľov je pravidelne odstraňovať staré pokolenia profilov. Napríklad, nasledovný príkaz odstráni pokolenia, ktoré sú staršie ako dva mesiace:

guix package --delete-generations=2m

Podobne je dobré nabádať používateľov, aby si pravidelne aktualizovali profil, čo zníži počet verzií daných balíkov uložených v /gnu/store:

guix pull
guix upgrade

V krajnom prípade môžu systémoví správcovia niektoré z týchto úkonov vykonať aj v mene používateľov. Napriek tomu, jednou z myšlienok Guixu je slobodné zaobchádzanie a úplný dohľad nad prostrediami s programovým vybavením, takže dôrazne odporúčame nechať používateľom voľnú ruku.

9.5 Úvahy o zabezpečení

Vrámci vysokovýkonného zhluku počítačov sa Guix obvykle využíva na správu vedecky zameraného programového vybavenia. Pre bezpečnosť nevyhnutné vybavenie ako je jadro operačného systému a služby ako sshd a plánovač dávkových úloh zostávajú pod dohľadom systémových správcov.

Projekt Guix má dobré výsledky v oblasti včasného poskytovania aktualizácií zabezpečenia (see Security Updates in GNU Guix Reference Manual). Aktualizácie sa získavajú vykonaním guix pull && guix upgrade.

Vďaka tomu, že Guix osobitne označuje rozličné verzie programov, je jednoduché zistiť, či sa používa nejaký zraniteľný program. Napríklad, pomocou nasledovného príkazu môžeme zistiť, či niektorý z používateľských profilov odkazuje na glibc 2.25 bez zaplátanej zraniteľnosti „Stack Clash“:

guix gc --referrers /gnu/store/…-glibc-2.25

Takto sa dozvieme, či jestvujú profily, ktoré odkazujú na presne túto verziu glibc.