archlinux est une distribution Linux simple et légère. Elle est disponible pour les processeurs prenant en charge l’architecture ARM. Cette distribution est suffisamment souple pour une installation customisée. 

Nous allons l’utiliser dans un hôte macOS M1 et M2 avec l’utilitaire UTM.

L’émulation reproduit à l’identique (presque) le comportement d’un système d’exploitation et du matériel. Il va émuler le CPU pour faire fonctionner le logiciel. Cette technique demande beaucoup de puissance au système hôte pour obtenir un résultat utilisable. Cette technique peut s’avérer utile pour les nostalgiques en proposant d’émuler de vieux CPU comme 68000 de Motorola.

A contrario, la virtualisation va se servir du matériel du système hôte et donc profiter de toute sa puissance. La virtualisation utilise un hyperviseur. Il est intégré à tous les principaux systèmes d’exploitation modernes. Il ouvre la porte à l’hébergement d’une machine virtuelle (VM). Il organise l’accès partagé au CPU et à la mémoire. Il s’agit d’un API de bas niveau.

L’intérêt de mettre en place des machines virtuelles repose en partie sur la possibilité de tester des versions en cours de développement des systèmes d’exploitation (et anticiper éventuellement les adaptations logiciels) ou de réaliser des tests sur des flux de travail en vue d’un déploiement. Cela peut aussi être intéressant pour héberger et isoler certaines fonctionnalités (par ex. un serveur Web).

Il existe plusieurs solutions gratuites pour utiliser une machine virtuelle. Nous allons-nous intéresser à UTM qui propose deux approches de virtualisation avec des possibilités d’interaction entre l’hôte et l’invité (VM) :

• en utilisant le framework de virtualisation d’Apple (Virtualization.Framework). C’est une API de haut niveau qui complète et enrichi l’hyperviseur pour autoriser dans une machine hôte la coexistence avec des machines virtuelles. Le framework prend en charge les spécifications de Virtual I/O Device (virtiofs). Il s’agit d’une norme définissant des interfaces standards pour de nombreux périphériques (réseau, port série, stockage, entropy et mémoire).
• en utilisant le système QEmu ARM Virtual Machine associé à l’architecture aarch64

Pré-requis

Nous devons installer UTM. Nous avons au moins deux approches pour faire cela.

• En téléchargeant directement une archive DMG sur le site d’UTM
• En utilisant le gestionnaire de paquets brew

  gilles@Air-de-Gilles ~ % brew install utm
  

Préparation de la machine virtuelle

Pour installer cette distribution nous pouvons utiliser deux sources :

• une image ISO
• une kernel et une image minimal au format Initramfs.

Image ISO

En premier lieu, nous devons récupérer une image ISO de la distribution ArchLinux. 

Ensuite, nous allons mettre en place une machine virtuelle.

• Nous créons une nouvelle machine virtuelle en cliquant sur l’icône + ou avec le raccourci ⌘N
• Nous cliquons sur Virtualiser
• Dans le dialogue Système d’Exploitation, nous choisissons Linux
• Nous cochons Utiliser la virtualisation d’Apple si nous souhaitons utiliser le Virtualization.Framework. Dans ce cas nous ne pourrons pas utiliser les fonctions de scripting.
• Si nécessaire, nous activons Rosetta pour une exécution des binaires x86_64
• Nous sélectionnons le fichier Image ISO de démarrage, puis nous cliquons sur le bouton Continuer
• Dans le dialogue Matériel, nous définissons la mémoire (avec archlinux, nous devons définir au moins 2500 MB) et le nombre de coeurs CPU (par priorité se seront des coeurs Performance)
• Dans la boîte de dialogue Stockage nous créons un disque par défaut. Une taille de 16 go est un bon compromis.
• Pour les Dossiers Partagés, nous ajoutons si nécessaire des dossiers de la machine hôte partagés à la VM
• Enfin, dans Résumé, nous cliquons sur le bouton Enregistrer

Kernel et Initramfs

Nous devons récupérer les images kernel et Initramfs sur le site archboot.

• Nous créons une nouvelle machine virtuelle en cliquant sur l’icône + ou avec le raccourci ⌘N
• Nous cliquons sur Virtualiser
• Dans le dialogue Système d’Exploitation, nous choisissons Linux
• Nous cochons Utiliser la virtualisation d’Apple si nous souhaitons utiliser le Virtualization.Framework. Dans ce cas nous ne pourrons pas utiliser les fonctions de scripting.
• Nous activons la case à cocher Booster depuis l’image du noyau
• Si nécessaire, nous activons Rosetta pour une exécution des binaires x86_64
• Nous sélectionnons le fichier Linux kernel Image-archboot-aarch64 (version décompressé, sans extension .gz)
• Nous sélectionnons le fichier Ramdisk initial de Linux initramfs-aarch64.img
• Nous ajoutons également un argument de démarrage console=hvc0 puis nous cliquons sur le bouton Continuer
• Dans le dialogue Matériel, nous définissons la mémoire (avec archlinux, nous devons définir au moins 2500 MB) et le nombre de coeurs CPU (par priorité se seront des coeurs Performance)
• Dans la boîte de dialogue Stockage nous créons un disque par défaut. Une taille de 16 go est un bon compromis.
• Pour les Dossiers Partagés, nous ajoutons si nécessaire des dossiers de la machine hôte partagés à la VM
• Enfin, dans Résumé, nous cliquons sur le bouton Enregistrer

Lancement de la VM

Maintenant nous allons lancer la VM. Nous démarrons sur le disque ISO. Un menu apparaît. Nous validons par la touche entrée la ligne Archboot Arch Linux AA64. 

Une fois le système démarré, l’écran de bienvenue de Archlinux s’affiche. Nous passons à la suite en appuyant sur la touche entrée.

L’écran devient bleu. Nous choisissons la langue locale (fr_FR). Nous validons avec la touche entrée. Nous arrivons dans le menu d’installation. Nous plaçons le curseur en surbrillance sur la ligne Exit Program, et nous acceptons par appui sur la touche entrée.

Le clavier est en qwerty. Nous allons modifier tout cela. Entrons la commande suivante.

[root@archboot /]# localectl set-keymap fr

Maintenant que notre clavier est azerty, nous allons commencer par vérifier que nous sommes bien connectés à internet. Le mieux pour cela est de faire un ping. Si tout se passe bien nous devons obtenir une réponse.

[root@archboot /]# ping archlinux.org
PING archlinux.org (95.217.163.246): 56(84) octets de données.
64 octets de archlinux.org (95.217.163.246) : icmp_seq=1 ttl=47 temps=183.588 ms
64 octets de archlinux.org (95.217.163.246) : icmp_seq=2 ttl=47 temps=175.882 ms

Disque d’installation

Nous avons préconfiguré un disque pour accueillir la partition principale. Nous avons à notre disposition deux outils :

• Pour une installation à partir d’une image ISO, nous allons essayer de partitionner le disque avec fdisk.
• Pour une installation repose sur une image kernel et un disque RAM, nous utiliserons parted qui présente l’avantage d’être pilotable en ligne de commandes sans interaction.

Les deux outils sont utilisables pour tout type d’installation.

fdisk

Nous allons préparer le disque d’installation avec la commande fdisk. Commençons par identifier le disque cible en utilisant l’argument -l. Dans notre cas le disque à utiliser est /dev/vda. Le disque virtuel virtioFS est donc pris en charge et disponible. Le disque ISO est identifié comme /dev/sda. Si nous n’avons pas utilisé une image ISO pour démarrer l’installation, le disque /dev/sda ne sera pas présent.

[root@archboot /]# fdisk -l 
Disque /dev/vda : 10 GiB, 10737418240 octets, 20971520 secteurs
Unités : secteur de 1 × 512 = 512 octets
Taille de secteur (logique / physique) :512 octets / 512 octets
taille d'E/S (minimale / optimale) : 512 octets / 512 octets
Disque /dev/zram8 : 4 GiB, 4294967296 octets, 1048576 secteurs
Unités : secteur de 1 × 4096 = 4096 octets
Taille de secteur (logique / physique) : 4096 octets / 4096 octets taille d'E/S (minimale / optimale) : 4096 octets / 4096 octets
Disque /dev/sda : 300,43 MiB, 315027455 octets, 615288 secteurs
Modèle de disque : Virtual Disk
Unités : secteur de 1 × 512 = 512 octets
Taille de secteur (logique / physique) : 512 octets / 512 octets
taille d'E/S (minimale / optimale) : 512 octets / 512 octets
Type d'étiquette de disque : gpt
Identifiant de disque: 00000000-0000-0000-0800-000000000000
Périphérique Début Fin Secteurs Taille Type
/dev/sda1     64    127     64     32K Données de base Microsoft
/dev/sda2    128 573271 573144  279,9M Système EFI
/dev/sda3 573272 615223  41952   20,5M Données de base Microsoft

Nous initialisons le disque avec deux partitions :

• la partition EFI pour le démarrage du système qui sera formatée en FAT ;
• la partition root qui comportera le système et qui sera formatée en EXT4.

Nous lançons fdisk en lui précisant le disque que nous souhaitons partitionner.

[root@archboot /]# fdisk /dev/vda

fdisk est un utilitaire interactif en ligne de commandes. Nous utilisons une lettre pour exécuter une opération. Par exemple, si nous tapons la lettre m et nous appuyons sur la touche entrée, nous obtenons l’aide.

• Nous commençons par créer un identifiant unique pour le disque. Nous entrons la lettre g puis nous validons par la touche entrée.
• Ensuite nous allons créer la partition de boot. Nous utilisons la lettre n (pour new). Nous utilisons les valeurs par défaut du numéro de partition (1) et du premier secteur (2048) en appuyant successivement sur la touche entrée. Nous indiquons le dernier secteur de cette partition. Pour faire simple nous allons fixer sa taille à +512M. Enfin, nous allons affecter un type à la partition. Nous entrons la lettre t (type) et nous choisissons le type 1 pour EFI System.

    Bienvenue dans fdisk (util-linux 2.39-dirty).
    Les modifications resteront en mémoire jusqu'à écriture.
    Soyez prudent avant d'utiliser la commande d'écriture.
    Le périphérique ne contient pas de table de partitions reconnue.
    Création d'une nouvelle étiquette pour disque de type DOS (MBR) avec identifiant de disque @xbaf328f3.
    
    Commande (m pour l'aide) : a
    Une nouvelle étiquette de disque GPT a été créée (GUID : 773A4C7E-15DB-4A0A-85C3-E30038B36B7A).
    
    Commande (m pour l'aide) : n
    Numéro de partition (1-128, 1 par défaut)
    Premier secteur (2048-20971485, 2048 par défaut)
    Dernier secteur +/-secteurs ou +/-taille{K,M.G,T,P} (2048-20971486, 20969471 par défaut) : +512M
    
    Une nouvelle partition 1 de type « Linux filesystem » et de taille 512 MiB a été créée.
    
    Commande (m pour l'aide) : t
    Partition 1 sélectionnée
    Type de partition ou synonyme (taper L pour afficher tous les types) : 1
    Type de partition « Linux filesystem » modifié en « EFI System »
  

• de la partition principale. Nous créons une nouvelle partition avec la lettre n. Nous utilisons toutes les valeurs par défaut proposées. Ainsi la partition utilisera toute la place disponible. Automatiquement la partition sera de type Linux filesystem.

    Commande (m pour l'aide) : n
    Numéro de partition (2-128, 2 par défaut) :
    Premier secteur (1050624-20971485, 1050624 par défaut)
    Dernier secteur +/-secteurs ou +/-taillefK,M.G,T.P3 (1050624-20971485, 20969471 par défaut)
    Une nouvelle partition 2 de type « Linux filesystem » et de taille 9,5 GiB a été créée.
  

• Pour finaliser la création, nous enregistrons la nouvelle table des partitions avec la lettre w (write) et nous sortons automatiquement de fdisk.

Il ne nous reste plus qu’à formater les deux partitions. Nous allons utiliser pour cela mkfs.fat pour la partition de démarrage et mkfs.ext4 pour la partition principale.

[root@archboot /]# mkfs.fat -F 32 / dev/vda1
mkfs. fat 4.2 (2021-01-31)
[root@archboot /]# mkfs.ext4 /dev/vda2
mke2fs 1.47.0 (5-Feb-2023)
Rejet des blocs de périphérique : complété
En train de créer un sustème de fichiers avec 2489856 4k blocs et 622592 i-noeuds
UUID de système de fichiers=daf9df62-a7e8-4dd4-941c-5523bbd1c60f
Superblocs de secours stockés sur les blocs :
32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632
Allocation des tables de groupe : complété
Écriture des tables d'i-noeuds : complété
Création du iournal (16384 blocs) : complété
Écriture des superblocs et de l'information de comptabilité du système de fichiers : complété

Nous finalisons en montant les disques dans le système pour pouvoir travailler dessus. L’ordre pour monter les partitions est important (/dev/vda2 avant /dev/vda1).

[root@archboot /]# mount /dev/vda2 /mnt
[  516.115154] EXT4-fs (vda2): mounted filesystem 79a7f075-343c-42db-85b0-89f34e1be6b1 with ordered data mode. Quota mode: none.
[root@archboot /]# mkdir /mnt/boot
[root@archboot /]# mount /dev/vda1 /mnt/boot

Pour ajouter une partition d’échange, nous devrons lui attribuer un type 19 Linux Swap.

Il nous reste à préparer la partition d’échanges (formatage) et à l’activer.

[root@archboot /]# mkswap /dev/vda1
[root@archboot /]# swapon /dev/vda1

Il ne nous reste plus qu’à formater la partition. Nous allons utiliser pour cela mkfs.ext4 pour la partition principale.

[root@archboot /]# mkfs.ext4 /dev/vda2
mke2fs 1.47.0 (5-Feb-2023)
Rejet des blocs de périphérique : complété
En train de créer un sustème de fichiers avec 2489856 4k blocs et 622592 i-noeuds
UUID de système de fichiers=daf9df62-a7e8-4dd4-941c-5523bbd1c60f
Superblocs de secours stockés sur les blocs :
32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632
Allocation des tables de groupe : complété
Écriture des tables d'i-noeuds : conplété
Création du iournal (16384 blocs) : complété
Écriture des superblocs et de l'information de comptabilité du système de fichiers : complété

Nous finalisons en montant les disques dans le système pour pouvoir travailler dessus. L’ordre pour monter les partitions est important (/dev/vda2 avant /dev/vda1).

[root@archboot /]# mount /dev/vda2 /mnt

parted

Contrairement à fdisk, parted est un outil pouvant être utilisé sans interaction. Il est donc intéressant notamment dans le cadre de script. Nous pouvons toujours choisir d’utiliser le mode interactif en passant uniquement en paramètre le disque à partitionner (par ex. parted /dev/vda).

Partition unique

Nous commençons par de déterminer initialiser (ou réinitialiser) le disque avec la commande mklabel. Celle-ci a pour mission de définir un nom pour le disque et remettre à zéro la table des partitions. Ce nom va influer sur la gestion des partitions. Il existe plusieurs types de noms (gpt, msdos, mac, bsd, loop, sun, pc98). Nous utilisons le label gpt (GUID Partition Table) qui autorise jusqu’à 128 partitions de type primary.

[root@archboot /]# parted -s -- /dev/vda mklabel gpt

Avec la commande mkpart nous allons définir une partition. Son numéro est attribué dans l’ordre de création. primary est le type de partition. ext4 est le système de fichiers utilisé ( xfs, ext2, ext3, ext4, fat16, fat32, hfs, hfs+, linux-swap, ntfs ou reiserfs). Nous indiquons enfin la position de début et de fin de la partition à créer. Nous utilisons une notation en pourcentage. Mais nous pouvons également utiliser une notation en IEC binary units (par ex. 1MiB, 1TiB, 1GiB), en bytes (par ex. 120000B) ou en secteur (par ex. 43s).

[root@archboot /]# parted -s -- /dev/vda mkpart primary ext4 0% 100%

Maintenant nous allons formater la partition au format ext4.

[root@archboot /]# mkfs.ext4 /dev/vda1
mke2fs 1.47.0 (5-Feb-2023)
Rejet des blocs de périphérique : complété
En train de créer un sustème de fichiers avec 2489856 4k blocs et 622592 i-noeuds
UUID de système de fichiers=daf9df62-a7e8-4dd4-941c-5523bbd1c60f
Superblocs de secours stockés sur les blocs :
32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632
Allocation des tables de groupe : complété
Écriture des tables d'i-noeuds : complété
Création du journal (16384 blocs) : complété
Écriture des superblocs et de l'information de comptabilité du système de fichiers : complété

Nous devons monter la partition principale en utilisant le point de montage /mnt.

[root@archboot /]# mount /dev/vda1 /mnt

Partitionnement avec partition d’échange

Nous commençons par initialiser (ou réinitialiser) le disque avec la commande mklabel. La table de partition est de type gpt.

[root@archboot /]# parted -s -- /dev/vda mklabel gpt

Nous définissons une partition d’échange. Avec la commande mkpart nous allons définir une partition. elle sera de type swap avec un système de fichier linux-swap.

[root@archboot /]# parted -s -- /dev/vda mkpart swap linux-swap 0% 1%

Enfin, nous ajoutons une partition principale au format ext4.

[root@archboot /]# parted -s -- /dev/vda mkpart primary ext4 1% 100%

Nous formatons la partition avec le système de fichiers ext4.

[root@archboot /]# mkfs.ext4 /dev/vda1

Pour afficher les partitions, parted dispose de l’argument -l.

[root@archboot /]# parted /dev/vda -1
Modèle : Inconnu (unknown)
Disque /dev/zram0: 4295MB
Taille des secteurs (logiques/physiques): 4096B/4096B
Table de partitions : loop
Drapeaux de disque :
Numéro   Début Fin     Taille Systeme de fichiers Drapeaux
1        0.00B 4295MB  4295MB btrfs
Modele : Périphérique par blocs Virtio (virtblk)
Disque /dev/vda : 17.2GB
Taille des secteurs (logiques/physiques) : 512B/512B
Table de partitions : gpt
Drapeaux de disque :
Numéro Debut  Fin     Taille   Système de fichiers  Nom      Drapeaux
1      1049kb 172MB   171MB                         swap  swap
2.     172MB  17.2GB  17.0GB.  ext4                 primary

Il ne reste plus qu’à activer la partition d’échange.

[root@archboot /]# mkswap /dev/vda1
Configure l'espace d'échange (swap) en version 1, taille = 163 Mie (170913792 octets)
pas d'étiquette. UUID=28e11869-cfa7-4368-971e-7eb571bedesf
[root@archboot /]# swapon /dev/vda1
[root@archboot /]# cat /proc/swaps
Filename.     Type         Size          Used     Priority
/de/vda1      partition    166908        0        -2

Nous devons monter la partition principale en utilisant le point de montage /mnt.

[root@archboot /]# mount /dev/vda2 /mnt # avec swap

Partitionnement avec une partition EFI

Nous commençons par créer la partition système EFI. Elle portera le numéro 1. Elle doit être formatée avec le système de fichier FAT32. Le drapeau de démarrage doit être activé. C’est que nous faisons avec set 1 esp on.

[root@archboot /]# parted -s -- /dev/vda mkpart primary fat32 1MiB 256MiB
[root@archboot /]# parted -s -- /dev/vda set 1 esp on

Nous créons ensuite deux partitions : une partition d’échanges ; une partition principale pour accueillir le système.

[root@archboot /]# parted -s -- /dev/vda mkpart swap linux-swap 256MiB 512MiB
[root@archboot /]# parted -s -- /dev/vda mkpart primary ext4 512MiB 100%

Nous formatons la partition de boot en FAT32 et la partition principale en EXT4.

[root@archboot /]# mkfs.fat -F 32 /dev/vda1
[root@archboot /]# mkfs.ext4 /dev/vda3

Ensuite, la partition d’échange doit être construite et activée.

[root@archboot /]# mkswap /dev/vda2
Configure l'espace d'échange (swap) en version 1, taille = 256 MiB (268431360 octets)
pas d'étiquette. UUID=28e11869-cfa7-4368-971e-7eb571bedesf
[root@archboot /]# swapon /dev/vda2

Nous finalisons la préparation du disque en montant les partitions /dev/vda1 et /dev/vda3. Nous devons impérativement réaliser les commandes commandes dans l’ordre.

[root@archboot /]# mount /dev/vda3 /mnt
[root@archboot /]# mkdir /mnt/boot
[root@archboot /]# mount /dev/vda1 /mnt/boot

Gestionnaire de paquets

La distribution Archlinux utilise comme gestionnaire de paquets la commande pacman. Avant toutes opérations sur les packages, il faut systématiquement exécuter la commande pacman -Sy.

Pour confirmer automatiquement l’installation nous ajoutons --noconfirm.

Installation de base

Avant de nous lancer plus loin dans l’installation, nous pouvons modifier le dépôt de paquets en éditant le fichier /etc/pacman.d/mirrorlist.

[root@archboot /]# nano /etc/pacman.d/mirrorlist

Ensuite, nous mettons à jour le dépôt pour obtenir les dernières disponibilités.

[root@archboot /]# pacman -Syy
:: Synchronisation des bases de données de paquets…
 core                  241,3 KiB   252 KiB/s 00:01 [######################] 100%
 extra                   9,0 MiB  3,63 MiB/s 00:02 [######################] 100%
 alarm                  57,3 KiB  78,2 KiB/s 00:01 [######################] 100%
 aur                     9,3 KiB  15,7 KiB/s 00:01 [######################] 100%

Nous installons les programmes essentiels dans la partition principale. Nous utilisons la commande pacstrap que va se charger de cette mission.

[root@archboot /]# pacstrap -i /mnt base base-devel linux-aarch64 net-tools nano openssh dhcpcd networkmanager

Dans la foulée, nous en profitons pour mettre à jour le fichier  /mnt/etc/fstab qui est utilisé par le système au démarrage pour monter tous les disques.

[root@archboot /]# genfstab -U -p /mnt >> /mnt/etc/fstab

Une fois toutes ces opérations réalisées, nous allons utiliser l’interpréteur de commandes sur le disque cible. Pour cela nous utiliserons la commande arch-chroot. La racine (root) sera alors considérée comme la racine de base.

[root@archboot /]# arch-chroot /mnt /bin/bash

Maintenant nous allons pouvoir modifier les paramètres du système destination. Commençons par changer les paramètres de localisation. Pour la configuration du clavier, nous créons un fichier /etc/vconsole.conf.

[root@archboot /]# nano /etc/vconsole.conf

Nous lui ajoutons les lignes suivantes :

KEYMAP=fr
FONT=ter-v32n

Pour la liste des claviers disponibles, nous utiliserons la commande localectl list-keymaps. Pour le clavier azerty se sera fr.

Dans le fichier /etc/locale.gen nous allons dé-commenter la ligne comportant la langage que nous souhaitons utiliser (il ne s’agit du clavier, mais de la langue utiliser pour les messages et commandes). Dans notre cas, nous activerons fr_FR.UTF-8.

[root@archboot /]# locale-gen
Generating locales...
  fr_FR.UTF-8... done
Generation complete.

Pour finaliser la configuration linguistique, nous allons définir par défaut le language dans un fichier /etc/locale.conf. Le double chevron ajouter une liste au fichier cible.

[root@archboot /]# echo LANG=fr_FR.UTF-8 >> /etc/locale.conf

Nous allons aussi définir par défaut la timezone. Nous créons un lien symbolique que nous nommerons /etc/localtime à partir de la localisation Paris. Ce fichier fera donc référence à Paris pour définir l’heure du système.

[root@archboot /]# ln -s /usr/share/zoneinfo/Europe/Paris /etc/localtime

Pour une meilleure identification de notre système sur le réseau, nous donnons un nom. Le simple chevron redirige la sortie standard stdout vers un nouveau fichier.

root@archboot /]# echo "ArchLinux-QEmu" > /etc/hostname

Pour définir le mot de passe du super utilisateur root, nous entrons simplement la commande passwd.

[root@archboot /]# passwd
New password: 
Retype new password: 
passwd: password updated successfully

Pour ajouter un nouvel utilisateur nous utiliserons la commande useradd. -m crée un dossier personnel dans le dossier /home. -g users rattache l’utilisateur à un groupe (ici celui des utilisateurs ordinaires). -G wheel donne un accès complet à la commande sudo. -s définit l’interpréter de commandes par défaut (en général /bin/bash). Pour définir le mot de passe, nous utiliserons simplement passwd <user> .

[root@archboot /]# useradd -m -g users -G wheel -s /bin/bash gilles
[root@archboot /]# passwd gilles
New password: 
Retype new password: 
passwd: password updated successfully

Si nous avons utilisons une partition système EFI nous devons installer un bootloader. Nous installons un environnement ramdisk initial. Il s’agit de deux images du système de fichiers qui ont pour fonction de mettre en place un répertoire racine minimal et temporaire pour le démarrage du noyau Linux. Le disque principale prendra ensuite la main. Nous parlons ici des fichiers images initrd (INITial RamDisk) et initramfs (INITial RAM FileSystem).

Nous allons installer le bootloader.

[root@archboot /]# pacman -S grub efibootmgr
[root@archboot /]# grub-install --target=arm64-efi --efi-directory=/boot --bootloader-id=grub /dev/vda1
[root@archboot /]# grub-mkconfig > /boot/grub/grub.cfg

Maintenant, nous démontons tous les disques et nous relançons le système. Avec exit nous sortons du répertoire racine défini avec arch-chroot. La commande mount va démonter les partitions. systemctl poweroff stopper le système.

[root@archboot /]# exit
[root@archboot /]# umount /mnt/boot
[root@archboot /]# umount /mnt
[root@archboot /]# systemctl poweroff

Dans le cas d’une installation à partir d’une image ISO nous devons la retirer pour que le disque virtuel soit utilisé automatiquement pour démarrer le système.

Dans le cas d’une utilisation d’un kernel et d’un RAM disque, nous ouvrons les propriétés.

• Pour la virtualisation Apple, dans l’onglet Boot nous retirons le Ramdisk. Dans les Boot arguments, nous ajoutons root=/dev/vda1.
• Pour QEmu, dans les lecteurs, nous supprimons le RAM disque (initramfs-aarch64.img). Dans l’onglet QEMU, nous allons à la fin des paramètres. Nous entrons une nouvelle ligne avec le texte -append. Nous ajoutons ensuite un paramètre entre guillemets : "root=/dev/vda1" (ou "root=/dev/vda2" s’il y a une partition d’échange).

Nous redémarrons la machine virtuelle. La mire d’authentification est toute simple.

Arch Linux 6.2.10-1-aarch64-ARCH (tty1)
archlinux login : gilles
Password :
[gilles@archlinux ~]$ 

Connexion réseau

Si nous faisons un ping pour vérifier la connexion réseau, nous allons obtenir une erreur (Echec dans la résolution du nom). Nous devons activer la connexion réseau et récupérer une adresse IP valide. Commençons par identifier le connecteur réseau avec la commande ip link. Dans notre cas, le connecteur se nomme enp0s1. Nous pouvoir constater que cet interface est DOWN, ce qui peut se traduire comme inactive.

[gilles@archlinux ~]$ ip link
1: 10: <LOOPBACK, UP,LOWÈR_UP> mtu 65536 disc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
link/loopback 00:00:00:00:00:00 br 00:00:00:00:00:00
2: enp0s1: ‹BROADCAST ,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000 linkether b6:ef:4e:1f:66:96 brd ff:ff:ff:ff:ff:ff

Une fois identifiée, nous devons démarrer cet interface réseau et la rendre active. Cette opération doit être réalisée en mode super utilisateur. Nous finalisons en récupérant une adresse IP avec dhcpcd que nous avons récupéré avant de redémarrer.

[gilles@archlinux ~]$ su -
mot de passe :
[root@archlinux ~]$ ip link set enp0s1 up
[root@archlinux ~]$ dhcpcd

L’adresse IP récupéré est disponible avec la commande ifconfig. Pour rendre persistant la connexion réseau, nous installons le paquet networkmanager. La commande exit est utilisée pour sortir du mode super utilisateur et revenir à l’utilisateur par défaut.

[root@archlinux ~]$ systemctl enable NetworkManager
[root@archlinux ~]$ exit

Mode super utilisateur pour tous

Un super utilisateur comme root peut exécuter des commandes systèmes. Par défaut les utilisateurs de base ne peuvent exécuter de commandes même en utilisant sudo. C’est possible en modifiant la configuration.

Nous basculons en mode super utilisateur avec la commande su - (ou su --login ou su -l). Nous devrons fournir le mot de passe de l’utilisateur root.

Nous devons ensuite éditer le fichier sudoers. Pour se faire, nous avons à notre disposition la commande visudo qui va ouvrir le fichier de configuration. Par défaut, visudo utilise l’éditeur vim. Pour editer le fichier avec nano nous pouvons exécuter cette commande.

[root@archlinux ~]$ EDITOR=nano visudo

Dans le fichier, nous recherchons la ligne root ALL=(ALL,ALL) ALL. A la suite nous avons trois possibilités :

• soit nous ajoutons une ligne pour l’utilisateur par défaut comme par exemple gilles ALL=(ALL,ALL) ALL (si l’utilisateur a pour identifiant gilles) ;
• soit nous ajoutons une ligne pour l’utilisateur par défaut en l’autorisant à exécuter toutes les commandes précédées par sudo sans utiliser de mot de passe comme par exemple gilles ALL=(ALL) NOPASSWD: ALL (si l’utilisateur a pour identifiant gilles) ;
• soit nous décommentons la ligne %wheel ALL=(ALL:ALL) ALL pour autoriser tous les membres du groupe wheel à utiliser la commande sudo. Si l’utilisateur n’est pas rattaché au groupe wheel, nous utiliserons la commande usermod -aG wheel gilles

Dans nano, pour rechercher une chaîne de caractères nous utilisons le raccourci crtl+w.

Pour utiliser nano comme éditeur par défaut, nous ajouterons au début du fichier sudoers la ligne suivante :

Defaults editor=/usr/bin/nano

Pour ne pas avoir à répéter la commande sudo, nous pouvons temporairement placer l’utilisateur courant en mode super utilisateur. Pour sortir de ce mode nous utiliserons exit.

[gilles@archlinux ~]$ su $USER
[gilles@archlinux ~]$ systemctl status
[gilles@archlinux ~]$ exit # Sortir du mode super utilisateur

Pour connaître le nom de l’utilisateur en cours, nous pouvons utiliser la commande whoami. echo $USER est une commande équivalente.

[gilles@archlinux ~]$ whoami
gilles
[gilles@archlinux ~]$ echo $USER
gilles

Intégration de la virtualisation

Nous pouvons installer les paquets pour les interactions entre l’hôte et la machine virtuelle.

[root@archboot /]# pacman -S spice-vdagent qemu-guest-agent

Partage de dossiers VirtFS

Pour accéder au partage de dossiers en utilisant virtFS, nous commençons à nous placer à la racine de l’utilisateur en cours avec cd. Nous créons un point de montage que nous appellerons share qui sera placé à la racine du dossier utilisateur. Ensuite, nous utilisons la commande mount pour monter les dossiers partagés à partir de l’interface share fournie par le système de fichiers 9p. Nous définirons comme point de montage le dossier ./share du répertoire en cours (à la racine de l’utilisateur par défaut).

[gilles@archlinux ~]$ mkdir /mnt/share
[gilles@archlinux ~]$ sudo chmod a+rw /mnt/share
[gilles@archlinux ~]$ sudo mount -t 9p -o trans=virtio share /mnt/share -oversion=9p2000.L
[gilles@archlinux ~]$ ls /mnt/share

Pour rendre persistant l’accès aux dossiers partagés nous allons éditer le fichier /etc/fstab.

[gilles@archlinux ~]$ sudo nano /etc/fstab

Nous ajouter à la fin du fichier une ligne pour monter automatiquement le partage de dossiers au lancement de Linux. Pour sauvegarder, ctrl+x puis y puis enter.

share    /mnt/share    9p    trans=virtio,version=9p2000.L,rw,_netdev,nofail    0    0

Pour redémarrer le montage des disques, nous pouvons utiliser cette commande :

[gilles@archlinux ~]$ sudo systemctl daemon-reload

Enfin, pour vérifier l’état, nous utilisons la commande mount pour afficher les points de montage.

[gilles@archlinux ~]$ sudo mount | grep share
share on /mnt/share type 9p (rw,relatime,sync,dirsync,access=client,trans=virtio,_netdev)

L’accès au point de montage /mnt/share peut échouer. Vous pouvez corriger l’erreur avec la commande suivante :

[gilles@archlinux ~]$ sudo chown -R $USER [mount point]

Partage de dossiers VirtioFS

Pour accéder au partage de dossiers en utilisant virtioFS, nous commençons à nous placer à la racine de l’utilisateur en cours avec cd. Nous créons un point de montage que nous appellerons share. Ensuite, nous utilisons la commande mount pour monter les dossiers partagés à partir de l’interface share fournie par le système de fichiers virtioFS. Nous définirons comme point de montage le dossier ./share du répertoire en cours (à la racine de l’utilisateur par défaut).

[gilles@archlinux ~]$ cd # ou `cd ~`
[gilles@archlinux ~]$ mkdir share
[gilles@archlinux ~]$ sudo mount -t virtiofs share ./share
[gilles@archlinux ~]$ ls ./share

Pour rendre persistant l’accès aux dossiers partagés nous allons éditer le fichier /etc/fstab.

[gilles@archlinux ~]$ sudo nano /etc/fstab

Nous ajouter à la fin du fichier une ligne pour monter automatiquement le partage de dossiers au lancement de Linux. Pour sauvegarder, ctrl+x puis y puis enter.

share    /mnt/share    virtiofs rw,nofail    0    0

Pour redémarrer le montage des disques, nous pouvons utiliser cette commande :

[gilles@archlinux ~]$ sudo systemctl daemon-reload

Enfin, pour vérifier l’état, nous utilisons la commande mount pour afficher les points de montage.

[gilles@archlinux ~]$ sudo mount | grep share
share on /mnt/share type virtiofs (rw,relatime)

Pilotage de la machine virtuelle

UTM offre plusieurs méthodes pour piloter les machines virtuelles. L’idée est simple : proposer un moyen de contrôler l’exécution des VM et interagir avec le système d’exploitation virtualisé.

Command Line Interface (CLI)

utmctl est fourni pour appliquer des gérer les machines virtuelles. Il permet aussi de prendre le contrôle et d’obtenir des données depuis les VM. Cette commande est accessible via le terminal.

(base) gilles@MacStuddeGilles ~ % /Applications/UTM.app/Contents/MacOS/utmctl

Pour faciliter l’utilisation de la commande utmctl, nous pouvons créer un lien symbolique dans le dossier des commandes du terminal /usr/local/bin. Ce répertoire est utilisé notamment pour stocker les binaires exécutables par un utilisateur avec des privilèges normaux.

(base) gilles@MacStuddeGilles ~ % sudo ln -sf /Applications/UTM.app/Contents/MacOS/utmctl /usr/local/bin

Le nom ou l’identifiant de la VM est utilisé pour exécuter les commandes. Ils doivent respecter la casse (Linux est différent de linux).

Certaines commandes ne fonctionnerons qu’en présence d’une virtualisation via QEmu. Si nous tentons d’exécuter la commande exec sur une VM sous le framework de virtualisation d’Apple nous obtiendrons une erreur.

(base) gilles@MacStuddeGilles ~ % utmctl exec Linux --cmd ls
Error from event: The operation couldn’t be completed. (OSStatus error -2700.)
Opération non prise en charge par le moteur.
(base) gilles@MacStuddeGilles ~ % utmctl file push Linux "/init.sh" < ./init.sh  
Error from event: The operation couldn’t be completed. (OSStatus error -2700.)
Opération non prise en charge par le moteur.

Pour lancer une machine virtuelle au démarrage, la meilleure solution consiste à utiliser la fonction native de OS X de lancement des processus launchd. Pour cela nous allons nous créons un script bash qui comportera la ligne de lancement. Cela consiste à exécuter utmctl en passant en arguments la VM. Nous créons un fichier startup.sh à la racine du répertoire utilisateur et nous ajoutons les lignes qui suivent :

#!/bin/sh
/Applications/UTM.app/Contents/MacOS/utmctl start "Linux"

Nous devons rendre exécutable ce script bash. La commande chmod va réaliser cette opération. +x accorde le droit à s’exécuter.

gilles@MacStuddeGilles ~ % sudo chmod +x startup.sh

Nous allons maintenant créer un fichier de propriétés avec une extension .plist. Ce fichier va définir le script à exécuter.

gilles@MacStuddeGilles ~ % nano  ~/Library/LaunchAgents/startUTM.plist

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
   <key>Label</key>
   <string>com.user.utm</string>
   <key>ProgramArguments</key>
   <array><string>/Users/gilles/startup.sh</string></array>
   <key>RunAtLoad</key>
   <true/>
</dict>
</plist>

Pour tester le script, nous utilisons la commande launchctl. Si tout s’est bien passé, UTM va s’ouvrir et lancer la machine virtuelle.

gilles@MacStuddeGilles ~ % launchctl load  ~/Library/LaunchAgents/startUTM.plist

Dans le Finder, un message apparaît pour signaler qu’un élément en arrière plan a été ajoutés. Pour désactiver ce message, et l’exécution en arrière plan, nous allons dans le menu , et nous ouvrons les Réglages Système… Nous recherchons Ouvrir avec la session. Nous cliquons sur l’onglet Ouverture. Nous faisons défiler la page de droite pour afficher notre script startup.sh. Nous cliquons sur le bouton. Ainsi, notre script sera uniquement lancé.

Pour mémoire les messages d’erreurs générés par le script sont visibles dans le fichier /var/log/system.log.

Remote control

C’est une approche Url qui est proposée avec le Remote Control. Dans le navigateur Web, nous allons utiliser des Url pour piloter les machines virtuelles. Nous avons à notre disposition de nombreuses commandes. 

Comme il s’agit d’un Url, certains caractères doivent être échappés. Par exemple, un espace sera représenté par %20. Donc nous écrirons pour une VM nommé « Linux Archlinux » le nom « Linux%20Archlinux ».

Avec Raccourci, nous pouvons automatiser et intégrer à macOS le lancement d’une machine virtuelle. Nous ouvrons Raccourci et nous créons une nouveau raccourci (⌘ N). Dans le panneau latéral de droite, nous choisissons la catégorie Web. Nous ajoutons un objet URL. Nous définissons à l’intérieur notre commande UTM. Nous intégrons en ensuite la commande Ouvrir les URL.

Nous cliquons sur ℹ pour paramétrer le raccourci et notamment l’utiliser comme une action rapide. Pour ajouter le raccourci au Dock, dans le menu Fichier nous sélectionnons l’entrée de menu Ajouter au Dock.

Automatisation

L’automatisation avancée n’est possible qu’en utilisant QEmu. Si nous prenons l’exemple d’une VM s’installant à partir d’une image ISO, nous pouvons automatiser l’installation du système sur une partition.

Dans l’exemple qui suit nous récupérons une image ISO de la distribution ArchLinux. Ensuite, nous allons mettre en place une machine virtuelle.

1. Nous créons une nouvelle machine virtuelle en cliquant sur l’icône + ou avec le raccourci ⌘N
2. Nous cliquons sur Virtualiser
3. Dans le dialogue Système d’Exploitation, nous choisissons Linux
4. Nous ne cochons pas Utiliser la virtualisation d’Apple
5. Nous sélectionnons le fichier Image ISO de démarrage, puis nous cliquons sur le bouton Continuer
6. Dans le dialogue Matériel, nous définissons la mémoire (avec archlinux, nous devons définir au moins 2500 MB) et le nombre de coeurs CPU (par priorité se seront des coeurs Performance)
7. Dans la boîte de dialogue Stockage nous créons un disque par défaut. Une taille de 16 go est un bon compromis.
8. Pour les Dossiers Partagés, nous ajoutons si nécessaire des dossiers de la machine hôte partagés à la VM
9. Enfin, dans Résumé, nous cliquons sur le bouton Enregistrer

Nous éditions ensuite la VM, et nous apportons les modifications suivantes :

• dans les périphériques nous ajoutons une interface série de type Terminal intégré.
• nous nous assurons qu’il n’y a pas de périphérique d’affichage

Nous allons maintenant utiliser un script Python pour automatiser les tâches d’installations.

• une fonction est créée pour convertir une chaîne de caractère en Url
• nous utilisons le paquage webbrowser pour envoyer des Url à UTM
• avec subprocess.run nous démarrons la machine virtuelle. Nous exécutons une commande équivalente à utmlctl start Linux (Linux est le nom de la VM). Nous temporisons 30 secondes pour laisser du temps à l’initialisation du système.
• comme nous atterrissons dans le programme d’installation de la distribution, nous allons naviguer à l’intérieur pour l’arrêter. L’astuce est d’utiliser des caractères de retour à ligne et de tabulation. Nous temporisons avec la méthode sleep entre chaque page.
• Ensuite nous envoyons au terminal, sans temporisation, le script pour installer Archlinux.

Quelques précisions sur le script :

• nous définissons un mot de passe pour un utilisateur (dans l’exemple il a pour identifiant gilles) et pour le super utilisateur root. A la place du texte mot-de-passe nous renseignerons le mot de passe que nous souhaitons mettre en oeuvre. Notons également la méthode de définition dans un script d’un mot de passe. La commande chpasswd est mise en oeuvre. Elle récupère via une redirection l’identifiant et le mot de passe séparée par le caractère :.
• pour autoriser l’utilisateur a exécuter des commandes avec sudo (en mode super utilisateur), nous allons ajouter dans le dossier /etc/sudoers.d/ un fichier 010_gilles (nous pouvons lui donner n’importe quel nom). Ce fichier comportera une ligne précisant que l’utilisateur est autorisée. Il sera automatiquement configurer au lancement de la session.
• La commande arch-root /mnt permet d’appliquer des commandes au périmètre du disque cible où nous allons installer le système.
• Le disque est partitionné en 3 : un partition de boot EFI ; une partition d’échange (swap) ; une partition principale. Cette dernière correspond au périphérique /dev/vda3.

#!/usr/bin/python3
# -*- coding: utf-8 -*-
import time,urllib.parse, subprocess
import webbrowser
def url(s):
    s= urllib.parse.quote(s, safe='')
    return f"utm://sendText?name=Linux&text={s}"
s=subprocess.run(['/Applications/UTM.app/Contents/MacOS/utmctl','start','Linux'],stdout=subprocess.PIPE)
time.sleep(30.0)
webbrowser.open(url("n"))
time.sleep(2.0)
webbrowser.open(url("tn"))
time.sleep(2.0)
webbrowser.open(url("n"))
time.sleep(2.0)
webbrowser.open(url("tnn"))
time.sleep(6.0)
# Clavier en français
webbrowser.open(url("nlocalectl set-keymap frn"))
# Initialisation du disque
webbrowser.open(url("parted -s -- /dev/vda mklabel gptn"))
# Partition de boot UEFI /dev/vda1
webbrowser.open(url("parted -s -- /dev/vda mkpart primary fat32 1MiB 256MiBn"))
webbrowser.open(url("parted -s -- /dev/vda set 1 esp onn"))
# Partition d'échanges /dev/vda2
webbrowser.open(url("parted -s -- /dev/vda mkpart swap linux-swap 256MiB 512MiBn"))
# Partition principale /dev/vda3
webbrowser.open(url("parted -s -- /dev/vda mkpart primary ext4 512MiB 4285MiBn"))
# Formatage des partitions
webbrowser.open(url("mkfs.fat -F 32 /dev/vda1n"))
webbrowser.open(url("mkfs.ext4 /dev/vda3n"))
# Préparation et activation de la partition d'échanges
webbrowser.open(url("mkswap /dev/vda2n"))
webbrowser.open(url("swapon /dev/vda2n"))
# Montage des partions
webbrowser.open(url("nmount /dev/vda3 /mntn"))
webbrowser.open(url("mkdir /mnt/bootn"))
webbrowser.open(url("mount /dev/vda1 /mnt/bootn"))
# Installation du système
webbrowser.open(url("pacstrap -i /mnt base base-devel linux-aarch64 net-tools nano dhcpcd networkmanager openssh --noconfirmn"))
webbrowser.open(url("genfstab -U -p /mnt >> /mnt/etc/fstabn"))
# Défini le nom VM
webbrowser.open(url("echo 'Archlinux-Qemu' >> /mnt/etc/hostnamen"))
# Défini l'heure  et la date
webbrowser.open(url("ln -s '/usr/share/zoneinfo/Europe/Paris' /mnt/etc/localtimen"))
# Définir les paramètres en français
webbrowser.open(url("echo 'fr_FR.UTF-8 UTF-8' > /mnt/etc/locale.genn"))
webbrowser.open(url("arch-chroot /mnt locale-genn"))
webbrowser.open(url("echo 'KEYMAP=fr' > /mnt/etc/vconsole.confn"))
webbrowser.open(url("echo 'FONT=ter-v32n' >> /mnt/etc/vconsole.confn"))
webbrowser.open(url("echo LANG=fr_FR.UTF-8 >> /mnt/etc/locale.confn"))
# Ajoute un utilisateur
webbrowser.open(url("arch-chroot /mnt useradd -m -g users -G wheel -s /bin/bash gillesn"))
# Mot de passe de l'utilisateur
webbrowser.open(url("echo gilles:mot-de-passe | arch-chroot /mnt chpasswdn"))
# Mot de passe du route
webbrowser.open(url("echo root:mot-de-passe | arch-chroot /mnt chpasswdn"))
# Ajoute l'utilisateur aux sudoers
webbrowser.open(url("touch /mnt/etc/sudoers.d/010_gillesn"))
webbrowser.open(url("echo 'gilles ALL=(ALL,ALL) ALL' >> /mnt/etc/sudoers.d/010_gillesn"))
# Active les services sshd et NetworkManager
webbrowser.open(url("arch-chroot /mnt systemctl enable multi-user.target sshd NetworkManagern"))
webbrowser.open(url("cp /run/systemd/resolve/resolv.conf /mnt/etc/resolv.confn"))
# Installe les paquets d'intégration à UTM
webbrowser.open(url("arch-chroot /mnt pacman -S spice-vdagent qemu-guest-agent --noconfirmn"))
# Bootloader
webbrowser.open(url("arch-chroot /mnt pacman -S grub efibootmgr --noconfirmn"))
webbrowser.open(url("arch-chroot /mnt grub-install --target=arm64-efi --efi-directory=/boot --bootloader-id=grub /dev/vda1n"))
webbrowser.open(url("arch-chroot /mnt grub-mkconfig > /mnt/boot/grub/grub.cfgn"))
# Démonte le disque et arrête le système
webbrowser.open(url("umount /mnt/boot;umount /mnt;sync;systemctl poweroffn"))

Nous exécutons le script dans le terminal. Si le language Python n’est pas installée, nous devons le faire.

% python3 main.py 

Une fois l’installation terminée, la VM s’arrête. Pour exécuter notre installation nous devons éjecter ou retirer l’image ISO.

Nous redémarrons la machine virtuelle. L’écran d’authentification doit s’ouvrir rapidement. Il ne reste plus qu’à saisir l’identifiant et le mot de passe.

Pour installer une interface graphique il faudra ajouter dans les propriétés un affichage. La carte graphique émulée devra être virtio ramfb, virtio ramfb-gl, virtio-gpu-pci ou virtio-gpu-gl-pci.

Gestionnaires de fenêtres

La mise en place d’une gestionnaire de fenêtres est simple sous Archlinux.

Gnome

Le gestionnaire de fenêtre GNOME s’installe automatiquement. La seule chose à faire est d’activer le gestionnaire et de le démarrer.

[gilles@archlinux ~]$ sudo pacman -S gnome
[gilles@archlinux ~]$ sudo systemctl enable gdm
[gilles@archlinux ~]$ sudo systemctl start gdm

LXQt

Le gestionnaire LXQt nécessite d’installer les paquets lxqt et sddm.

[gilles@archlinux ~]$ sudo pacman -Sy lxqt sddm
[gilles@archlinux ~]$ sudo systemctl enable lxdm

Pour modifier le layout du clavier, nous allons dans le menu Préférences, LXQt-Paramètrage du système et Clavier et souris.

LXDE

Le gestionnaire LXDE Desktop Environnement nécessite d’installer les paquets lxde et lxdm. Nous sélectionnons tous les paquets.

[gilles@archlinux ~]$ sudo pacman -Sy lxde lxdm
:: Il y a 17 membres dans le groupe lxde :
:: Dépôt extra
   1) gpicview  2) lxappearance  3) lxappearance-obconf  4) lxde-common
   5) lxde-icon-theme  6) lxdm  7) lxhotkey  8) lxinput  9) lxlauncher
   10) lxmusic  11) lxpanel  12) lxrandr  13) lxsession  14) lxtask
   15) lxterminal  16) openbox  17) pcmanfm
Entrer une sélection (par défaut, tout est sélectionné): 
...

Nous activons ensuite le gestionnaire de connexion lxdm.

[gilles@archlinux ~]$ sudo systemctl enable lxdm

Nous devons ensuite définir la session par défaut. Nous ouvrons le fichier /etc/lxdm/lxdm.conf et nous recherchons la ligne commençant par # session=/usr/bin/startlxde. Nous supprimons le caractère # en début de ligne et nous sauvegardons le fichier. Nous pouvons utiliser cette commande sed pour modifier directement le fichier.

[gilles@archlinux ~]$ sudo sed -i /etc/lxdm/lxdm.conf 
     -e 's;^# session=/usr/bin/startlxde;session=/usr/bin/startlxde;g'

A l’issue, nous redémarrons le système. Normalement, nous nous retrouvons automatiquement devant la fenêtre de connexion. Une fois connectée, si le clavier n’est pas en azerty, nous ouvrons en bas à gauche le menu et nous cliquons sur Exécuter. Nous la saisissons la commande setxkbmap -layout "fr". 

Pour rendre persistant le clavier en français, nous devons créer un fichier de configuration /etc/X11/xorg.conf.d/00-keyboard.conf.

[gilles@archlinux ~]$ sudo nano /etc/X11/xorg.conf.d/00-keyboard.conf

A l’intérieur de ce fichier nous ajoutons les lignes suivantes. Pour obtenir les valeurs de layout et de modèle conformes nous pouvons consulter cette liste. En utilisant fr(Mac), les caractères devraient être à la bonne place à l’exception des caractères @ et #. Nous les retrouvons en utilisant le raccourci option + backtick pour @ et option + majuscule + backtick pour #.

Section "InputClass"
        Identifier "system-keyboard"
        MatchIsKeyboard "on"
        Option "XkbLayout" "fr(mac)"
        Option "XkbModel" "pc105"
EndSection

Logiciels complémentaires

Pour une distribution complète, nous pouvons installer Google Chrome, Libre Office, Gimp ou Thunderbird. Toutes les dépendances vont être automatiquement téléchargées. Les raccourcis seront ajoutés au menu système. Une liste des packages est disponible à l’Url https://archlinuxarm.org/packages.

[gilles@archlinux ~]$ sudo pacman -S chromium libreoffice libreoffice-fr gimp thunderbird

Visual Studio Code de Microsoft n’est pas disponible dans un format de paquet compatible avec archlinux. Il est quand même possible d’installer cet éditeur de code. Pour cela, nous allons utiliser GIT.

[gilles@archlinux ~]$ sudo pacman -S git

Nous allons maintenant cloner un dépôt GIT disponible sur Arch User Repository(AUR). Nous clonons le dépôt. Une fois terminée, nous changeons le répertoire actif pour la racine du projet visual-studio-code-bin. A partir de ce dossier nous allons pouvoir construire un paquet compatible avec pacman. Nous utilisons pour cela la commande makepkg -s à la racine du répertoire contenant le projet. Une archive .pkg.tar.xz est crée dans ce dossier. Pour l’installer nous utiliserons pacman avec l’argument -U. Nous finalisons en supprimant le dossier visual-studio-code-bin. Visual Studio est disponible dans le menu système et le sous-dossier Programmation.

[gilles@archlinux Downloads]$ git clone https://AUR.archlinux.org/visual-studio-code-bin.git
[gilles@archlinux Downloads]$ cd visual-studio-code-bin
[gilles@archlinux visual-studio-code-bin]$ makepkg -s
[gilles@archlinux visual-studio-code-bin]$ sudo pacman -U visual-studio-code*.xz
[gilles@archlinux visual-studio-code-bin]$ cd ../
[gilles@archlinux visual-studio-code-bin]$ sudo rm -r visual-studio-code-bin

Pour installer Python 3 nous pouvons utiliser pacman.

[gilles@archlinux ~]$ sudo pacman -S python3 python-pip

Nous pouvons également installer la distribution conda. Attention à ne pas lancer l’installation en mode super utilisateur. Elle va s’installer par défaut dans un dossier /root qui ne sera pas accessible par défaut.

[gilles@archlinux ~]$  pacman -S wget
[gilles@archlinux ~]$  wget https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-Linux-aarch64.sh
[gilles@archlinux ~]$  sudo chmod +x Miniforge3-Linux-aarch64.sh
[gilles@archlinux ~]$  ./Miniforge3-Linux-aarch64.sh
Welcome to Miniforge3 23.1.0-3
In order to continue the installation process, please review the license
agreement.
Please, press ENTER to continue

La distribution est activée par défaut. Dans notre exemple, (base) signale que nous sommes dans l’environnement virtuel de base.

Arch Linux 6.2.10-1-aarch64-ARCH (ttyAMA0)
Archlinux login: gilles
Mot de passe : 
Dernière connexion : Mon Jul 10 17:33:24 sur ttyAMA0
(base) [gilles@Archlinux ~]$

Pour désactiver conda au démarrage, nous avons la commande suivante :

[gilles@archlinux ~]$ conda config --set auto_activate_base false

Nous pouvons également définir ce comportement dans un fichier ~/.condarc à la racine du dossier utilisateur et lui ajouter la ligne suivante :

auto_activate_base: False

Toujours dans le même fichier ~/.condarc nous pouvons activer la mise à jour automatique.

auto_update_conda: True

Autre astuce intéressante est la possibilité dans le fichier ~/.condarc de définir les packages installés par défaut lors de la création d’un environnement virtuel avec la commande conda create -n {nom-environnement}.

create_default_packages:
  - pip
  - ipython
  - numpy
  - scipy
  - pandas
  - matplotlib

Enfin, il ne faut pas oublier d’ajouter conda-forge qui met à disposition plus de bibliothèques et qui est plus actualisé.

[gilles@archlinux ~]$ conda config --add channels conda-forge
[gilles@archlinux ~]$ conda config --set channel_priority strict

Ce qui est équivalent à ajouter les lignes suivantes dans le fichier ~/.condarc.

channels:
  - conda-forge
  - defaults
channel_priority: strict

Réseau local

Pour pouvoir profiter à partir du réseau local de la machine virtuelle, notamment en accédant à un serveur Web, nous devons configurer la virtualisation.

Virtualisation d’Apple

Pour se connecter à une machine virtuelle sur le réseau locale, voir extérieurement via un routeur, nous devons configurer le mode réseau en Pont (avancé). Nous choisissons une interface dans le menu déroulant. En général, nous n’avons que le choix de en0 ou en1.

Port forwarding avec QEmu

Avec utm il peut être intéressant de mettre en place un serveur sous forme de machine virtuelle. Par exemple nous pouvons créer un serveur Web avec prise en compte de SSH.

Pour que le serveur soit accessible sur le réseau local, nous devons mettre en place une redirection de ports dans les paramètres d’Utm.

Dans les propriétés de notre machine virtuelle, nous sélectionnons l’onglet Réseau. Pour que cela fonctionne, nous devons définir le mode du réseau sur VLAN émulé.

En dessous de l’onglet réseau, une ligne Redirection de port est apparue. Nous la sélectionnons.

Pour créer une règle, nous cliquons sur Nouveau… Dans la fenêtre qui apparaît, nous les adresses IP avec les valeurs proposées (10.0.2.15 pour l’invité et 127.0.0.1 pour l’hôte). Nous saisissons le port de l’invité et sa correspondance sur l’hôte. En l’occurence nous utiliserons le même port pour la connexion SSH (22) et Web (80).

Une fois ces modifications opérées, nous pouvons lancer la machine virtuelle.

Identification de la machine hôte

Il n’est pas nécessaire de connaître l’IP de la VM. Nous avons besoin de connaître l’adresse IP de la machine hôte. Sous macOS, dans le terminal, nous pouvons entrer la commande suivante dans le terminal en fonction d’une connexion ethernet ou wifi.

gilles@MacStuddeGilles ~ % ipconfig getifaddr en0 # ethernet
gilles@MacStuddeGilles ~ % ipconfig getifaddr en1 # wlan
192.168.1.115

Une fois que nous avons identifié l’adresse IP de l’hôte macOS, nous pouvons nous connecter à partir de n’importe quel poste du réseau locale. Nous allons également pouvoir, en fonction du routeur (ADSL, fibre, etc), faire une redirection de port vers l’hôte et sa VM.

nginx

nginx est un serveur Web très répandu. Il est relativement facile à mettre en oeuvre et intègre parfaitement les sites sécurisés.

Commençons par mettre à jour le dépôt local.

[gilles@archlinux ~]$ sudo pacman -Syu

Nous installons le paquet nginx.

[gilles@archlinux ~]$ sudo pacman -S nginx

Nous démarrons le service nginx et nous l’activons.

[gilles@archlinux ~]$ sudo systemctl start nginx
[gilles@archlinux ~]$ sudo systemctl enable nginx

Pour vérifier l’état du service nous utiliserons la commande suivante :

[gilles@archlinux ~]$ sudo systemctl status nginx

Ensuite pour vérifier que cela fonctionne à partir de la machine hôte, nous lançons la comande ifconfig et nous récupérions l’adresse inet pour l’interface enp0s1.

Dans le navigateur Web de l’hôte nous saisissons l’Url suivant http://{adresse ip}.

Les sites Web sont stockés dans le dossier /usr/share/nginx. Un dossier html est créé par défaut. Si nous voulons ajouter un hôte virtuel, nous créons à cet emplacement un dossier pour l’accueillir.

[gilles@archlinux ~]$ sudo mkdir /usr/share/nginx/monsite

A l’intérieur nous créons un fichier html index.html. C’est le fichier qui est affiché par défaut.

<!DOCTYPE html>
<html lang="fr">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>nginx</title>
    </head>
    <body>
        ma première page Web
    </body>
</html>

Nous créons un dossier pour tous les hôtes virtuels activés.

[gilles@archlinux ~]$ sudo mkdir /etc/nginx/sites-enabled

Nous configurons nginx pour qu’il charge tous les fichiers hôtes de ce dossier. Les lignes suivantes sont à ajouter juste après HTTP {.

include /etc/nginx/sites-enabled/*;
server_names_hash_bucket_size 64;

Le serveur par défaut est remplacé.

A l’intérieur de ce dossier nous allons créer un hôte virtuel.

[gilles@archlinux ~]$ sudo nano /etc/nginx/sites-enabled/monsite

Nous ajoutons ces lignes.

server {
    listen 80;
    server_name 127.0.0.1;
    location / {
        root /usr/share/nginx/monsite;
        index  index.html index.htm;
    }
}

Pour tester notre configuration, nous utilisons l’argument -t avec la commande nginx.

[gilles@archlinux ~]$ sudo nano nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Nous pouvons relancer le serveur nginx.

[gilles@archlinux ~]$ sudo nano systemctl stop nginx
[gilles@archlinux ~]$ sudo nano systemctl start nginx

Certificat SSL

Nous allons installer le logiciel certbot pour utiliser Let’s Encrypt. Celui-ci met en oeuvre un processus automatique de certification. Il utilise le protocole ACME (Automatic Certificate Management Environment) pour installer et renouveler les certificats.

Un certificat SSL (Secure Socket Layer) a pour fonction de crypter les échanges, et donc de garantir la confidentialité. Sans la présence de la clé, il est impossible théoriquement de connaître le contenu de ces échanges. Du fait que les données sont cryptées, elles en peuvent être modifiées sous peine de les rendre inutilisables. Le certificat va garantir l’intégrité des données, et donc l’origine de celle-ci.

L’utilisation de mot SSL est un abus de langage. Celui-ci est considéré comme peu fiable suite à la découverte de failles, a été abandonné depuis 2015 au profit du TLS (Transport Layer Security) et de ses versions 1.2 et suivantes. Ces protocoles utilisent le même type de certificats qui seront identifiés SSL, TLS ou SSL/TLS. Un certificat sert à crypter et à authentifier :

• pour le cryptage, le certificat comporte une clef publique pour crypter ou décrypter les données
• pour l’authentification, le certificat comporte des informations sur le propriétaire (nom, url, etc.). Nous y trouverons également le nom de l’émetteur du certificat qui nous aidera à établir une chaîne de confiance.

Un certificat a toujours une date de péremption. En effet, il comporte une date de début et de fin de validité. Cela impliquera de les renouveler régulièrement.

Comme nous utilisons nginx, nous pouvons installer la version certbot prévue à cette configuration.

[gilles@archlinux ~]$ pacman -S certbot-nginx

Maintenant, nous pouvons procéder à l’obtention d’un certificat SSL de Let’s Encrypt.

Avant de le faire, vous devrez d’abord vous assurer que les ports 80 et 443 font l’objet d’une redirection temporaire dans la console de configuration de votre box internet. Par exemple, pour une BBOX de Bouygues Télécom dans la section Redirection de ports.

Nous devons stopper le serveur nginx si le message d’erreur suivant apparaît Problem binding to port 80: Could not bind to IPv4 or IPv6.

[gilles@archlinux ~]$ sudo systemctl stop nginx

Nous pouvons lancer le processus d’installation du certificat SSL.

[gilles@archlinux ~]$ sudo certbot --nginx

Nous allons devoir répondre à quelques questions pour installer le certificat. Nous devons fournir une adresse courriel valide pour nous adresser des notifications (renouvellement de certificat). Nous devons accepter les conditions d’utilisations, puis si nous acceptons de partager l’adresse courriel avec Let’s Encrypt. Vous pouvez répondre N. Nous devons également préciser un Url valide (par ex. monsite.converio.fr). Une fois terminée, les hôtes virtuels sont automatiquement modifiées pour prendre en charge le certificat SSL.

Nous pouvons renouveler le certificat et modifier la configuration avec renew.

[gilles@archlinux ~]$ sudo certbot renew

Pour effectuer un renouvellement du certificat, sans modification nous utiliserons cette commande.

[gilles@archlinux ~]$ sudo certbot --nginx certonly

Nous avons dans le dossier /etc/letsencrypt/live un répertoire pour chaque hôte virtuel. Dans notre cas dans un répertoire monsite.converio.fr les fichiers suivants :

• un certificat Let’s Encrypt (cert.pem)
• un fichier pour la chaîne de confiance de tous les certificats intermédiaires (chain.pem)
• un fichier fullchain.pem contenant la chaîne complète, c’est-à-dire le certificat (cert.pem) et les certificats intermédiaires (chain.pem)
• un fichier de clé privée (privkey.pem) pour crypter/décrypter les échanges avec les clients distants à qui il sera communiqué une clef publique.

openssh

Pour utiliser ssh, nous allons installer le paquet openssh.

[gilles@archlinux ~]$ pacman -S openssh

Nous activons le service sshd, puis nous le démarrons.

[gilles@archlinux ~]$ systemctl enable sshd
[gilles@archlinux ~]$ systemctl start sshd

Pour une utilisation de SSH sur le poste hôte, nous devons identifier l’adresse IP de la machine virtuelle. Pour cela nous utilisons utmctl fourni avec UTM. Dans cet exemple, l’adresse locale de la VM est 192.168.71.14.

gilles@MacStuddeGilles ~ % /usr/local/bin/utmctl ip-address "Linux ArchLinux QEmu"
192.168.71.14
fda4:aa91:bf49:1716:a7df:a421:d475:ab9b
fe80::415a:4ac7:bd08:5c1
gilles@MacStuddeGilles ~ % ssh -p gilles@192.168.71.14

Pour une utilisation à partir du réseau locale, nous devons identifier l’adresse IP de la machine hôte. Par exemple, pour une connexion wifi dans le terminal de macOS.

gilles@MacStuddeGilles ~ % ipconfig getifaddr en1 # wlan
192.168.1.115

Dans cette dernière hypothèse, nous devons configurer la connexion réseau adaptée.