Suivant: , Précédent: , Monter: Configuration du système   [Table des matières][Index]

3.9 Lancer Guix sur un serveur Kimsufi

Pour lancer Guix sur un serveur hébergé par Kimsufi, cliquez sur l’onglet netboot puis choisissez rescue64-pro et redémarrez.

OVH vous enverra un courriel avec les identifiants requis pour vous connecter en ssh à un système Debian.

Maintenant vous pouvez exécuter les étapes de « installer guix de voir Installation binaire dans GNU Guix » : 

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

Partitionnez les lecteurs et formatez-les, en commençant par arrêter la grappe raid : 

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

Ensuite, effacez les disques et créez les partitions. Nous allons créer une grappe RAID 1. 

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%

Créez la grappe : 

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

Maintenant, créez les systèmes de fichiers sur les bonnes partitions, en commençant par la partition de démarrage : 

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

Puis la partition racine : 

mkfs.ext4 /dev/md127

Initialisez les partitions d’échange : 

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

Montez le disque guix : 

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

Maintenant vous pouvez écrire une déclaration de système d’exploitation dans un fichier os.scm. Voici un exemple : 

(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))))

  ;; Ajouter un module noyau pour le RAID-1 (appelé « miroir »).
  (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
   ;; Contenu par défaut de /etc/issue.
   "\
Ceci est le système GNU sur Kimsufi.  Bienvenue.\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"))

  ;; Paquets installés sur tout le système.
  (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 "adresse-ip-du-serveur/24"))))
		    (routes (list (network-route
				   (destination "default")
				   (gateway "passerelle-du-serveur"))))
		    (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 "nom-de-clé-ssh.pub"
                                      "contenu-de-clé-ssh"))))))
    (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))))))))

N’oubliez pas de modifier les variables adresse-ip-du-serveur, passerelle-du-serveur, nom-de-clé-ssh et contenu-de-clé-ssh avec vos propres valeurs.

La passerelle est la dernière IP utilisable dans votre bloc donc si vous avez un serveur avec l’IP ‘37.187.79.10’, sa passerelle sera ‘37.187.79.254’.

Transférez votre déclaration de système d’exploitation os.scm sur le serveur via les commandes scp ou sftp.

Maintenant, tout ce qu’il reste à faire est d’installer Guix avec guix system init et redémarrer.

Cependant nous devons d’abord paramétrer un chroot, car la partition racine du système de secours est monté sur une partition aufs et si vous essayez d’installer Guix cela ne marchera pas à l’étape d’installation de GRUB. Il se plaindra du chemin canonique de « aufs ».

Installez les paquets qui seront utilisés dans le chroot : 

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

Ensuite, exécutez ce qui suit pour créer les répertoires nécessaires au chroot : 

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

Copiez le resolv.conf hôte dans le chroot : 

cp /etc/resolv.conf etc/

Montez les périphériques de type bloc, le dépôt et sa base de données et la configuration guix actuelle : 

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/

Entrez dans le chroot sur /mnt et installez le système : 

chroot /mnt/ /bin/bash

guix system init /root/os.scm /guix

Enfin, à partir de l’interface utilisateur web, modifiez ‘netboot’ en ‘boot to disk’ et redémarrez (également depuis l’interface web).

Attendez quelques minutes et essayez de vous connecter en ssh avec ssh guix@adresse-ip-du-serveur> -i chemin-vers-votre-clé-ssh

Votre système Guix devrait être opérationnel sur Kimsufi. Félicitations !

Suivant: Mettre en place un montage dupliqué, Précédent: Lancer Guix sur un serveur Linode, Monter: Configuration du système   [Table des matières][Index]