Jump to content
From ArchWiki
État de la traduction: Cet article est la version francophone de USB flash installation medium. Date de la dernière traduction: 2022-10-03. Vous pouvez aider à synchroniser la traduction s'il y a eu des changements dans la version anglaise.

Related articles

- CD Burning
- Archiso (Français)
- Multiboot USB drive

Cette page présente différentes méthodes multi-plateformes pour créer un lecteur USB d'installation d'Arch Linux (également appelé "lecteur flash", "clé USB", etc) pour démarrer dans les systèmes BIOS et UEFI. Le résultat sera un système Live USB (à l'instar d'un Live CD) qui peut être utilisé pour l'installation d'Arch Linux, la maintenance du système ou à des fins de récupération, et qui, en raison de l'utilisation de Overlayfs pour `/`, supprimera tous les changements une fois l'ordinateur éteint.

Si vous souhaitez effectuer une installation complète d'Arch Linux sur une clé USB (c'est-à-dire avec des paramètres persistants), consultez Install Arch Linux on a removable medium. Si vous souhaitez utiliser votre clé USB Arch Linux amorçable comme une clé USB de secours, consultez Changer de racine.

## Utiliser l'ISO tel quel (BIOS et UEFI)

### Dans GNU/Linux

#### Utilisation des utilitaires de base en ligne de commande

Cette méthode est recommandée en raison de sa simplicité et de sa disponibilité universelle, puisque ces outils font partie de coreutils (inclus dans le méta-paquet base).

Attention: Cela détruira irrévocablement toutes les données sur `/dev/sdx`. Pour restaurer la clé USB en tant que périphérique de stockage vide et utilisable après avoir utilisé l'image ISO d'Arch, la signature du système de fichiers ISO 9660 doit être supprimée en exécutant `wipefs --all /dev/sdx` en tant que root, avant de repartitionner et reformater la clé USB.
Astuce: Trouvez le nom de votre clé USB avec `lsblk`. Assurez-vous qu'elle est non montée.

Exécutez la commande suivante, en remplaçant `/dev/sdx` par votre lecteur, par exemple `/dev/sdb`. (N'ajoutez pas de numéro de partition, donc n'utilisez pas quelque chose comme `/dev/sdb1`):

- en utilisant cat(1) :

      # cat path/to/archlinux-version-x86_64.iso > /dev/sdx

- en utilisant cp(1) :

      # cp path/to/archlinux-version-x86_64.iso /dev/sdx

- en utilisant dd :

      # dd bs=4M if=path/to/archlinux-version-x86_64.iso of=/dev/sdx conv=fsync oflag=direct status=progress

- en utilisant tee :

      # tee < path/to/archlinux-version-x86_64.iso > /dev/sdx

- en utilisant pv :

      # pv path/to/archlinux-version-x86_64.iso > /dev/sdx

Consultez [1] et [2] pour une comparaison et une perspective sur l'utilisation de ces outils et pourquoi dd est peut-être le moins adapté.

Astuce: Si la version UEFI de l'Arch ISO de l'USB se bloque ou est incapable de se charger, essayez de répéter le processus de création du support sur la même clé USB une ou plusieurs fois. Si cela ne fonctionne pas, vous pouvez également essayer de mettre à jour le firmware de votre carte mère.

#### Utilisation de l'utilitaire de disque de GNOME

Les distributions Linux exécutant GNOME peuvent facilement créer un live CD grâce à nautilus et gnome-disk-utility. Il suffit de cliquer avec le bouton droit de la souris sur le fichier .iso, et de sélectionner Ouvrir avec Enregistreur d'image disque. Lorsque GNOME Disk Utility s'ouvre, spécifiez la clé USB dans le menu déroulant Destination et cliquez sur Démarrer la restauration.

#### Utilisation de MultiWriter

gnome-multi-writer est un outil graphique simple basé sur GTK3 pour écrire un fichier ISO sur un ou plusieurs périphériques USB à la fois.

#### Utilisation de Kindd

Kindd est une interface graphique basée sur Qt pour dd. Il est disponible sous kinddAUR.

#### Utilisation de Popsicle

Popsicle est un outil conçu par l'équipe de développement de PopOS pour flasher des fichiers ISO sur plusieurs périphériques USB en parallèle. Il est écrit en Rust et utilise GTK. Il est disponible sous popsicleAUR.

#### Utilisation de SUSE Studio ImageWriter

SUSE Studio ImageWriter est un outil basé sur Qt créé par l'équipe de développement d'OpenSUSE. Il est disponible sous imagewriterAUR.

#### Utilisation de xorriso-dd-target

xorriso-dd-target (de libisoburn) est un script shell qui tente de réduire le risque d'écraser le mauvais périphérique de stockage. Son mode le plus sûr est nommé `-plug_test`. Par exemple, pour l'utiliser en tant qu'utilisateur normal qui peut s'élever au rang de root en utilisant sudo :

    $ xorriso-dd-target -with_sudo -plug_test -DO_WRITE -image_file archlinux-version-x86_64.iso

Consultez xorriso-dd-target(1) pour plus de détails.

### Sous Windows

#### Utilisation de win32diskimager

win32diskimager est un autre outil graphique d'écriture d'iso USB pour Windows. Sélectionnez simplement votre image iso et la lettre du lecteur USB cible (vous devrez peut-être le formater d'abord pour lui attribuer une lettre de lecteur), puis cliquez sur Write.

#### Utilisation de USBwriter

Cette méthode ne nécessite aucune solution de contournement et est aussi simple que `dd` sous Linux. Téléchargez simplement l'ISO d'Arch Linux et, avec des droits d'administrateur local, utilisez l'utilitaire USBwriter pour écrire sur votre mémoire flash USB.

#### Utilisation de Rufus

Rufus est un graveur ISO USB polyvalent. Il fournit une interface utilisateur graphique et ne se soucie pas de savoir si le lecteur est correctement formaté ou non.

Il suffit de sélectionner l'ISO d'Arch Linux, le lecteur USB sur lequel vous voulez créer le démarrage d'Arch Linux et de cliquer sur START.

Note: Si le lecteur USB ne démarre pas correctement en utilisant le mode image ISO par défaut, le mode image DD devrait être utilisé à la place. Pour activer ce mode, sélectionnez GPT dans le menu déroulant Schéma de partition. Après avoir cliqué sur START, vous obtiendrez le dialogue de sélection du mode, sélectionnez DD Image mode.
Astuce: Pour ajouter une partition supplémentaire sur du stockage persistant, utilisez le curseur pour choisir la taille de la partition persistante. Lorsque vous utilisez la fonction de partition persistante, assurez-vous de sélectionner MBR dans le menu déroulant Schéma de partition et BIOS ou UEFI dans Système cible, sinon le disque ne sera pas utilisable pour le démarrage BIOS et UEFI.

#### Utilisation de Cygwin

Assurez-vous que votre installation Cygwin contient le paquet `dd`.

Placez votre fichier image dans votre répertoire personnel :

    C:\cygwin\home\John\\

Exécutez cygwin en tant qu'administrateur (nécessaire pour que cygwin puisse accéder au matériel). Pour écrire sur votre clé USB, utilisez la commande suivante :

    dd if=archlinux-version-x86_64.iso of=\\.\x: bs=4M

où `archlinux-version-x86_64.iso` est le chemin d'accès au fichier image iso dans le répertoire `cygwin` et `\\.\x:` est votre clé USB où `x` est la lettre désignée par Windows, par exemple `\\.\d:`.

Sous Cygwin 6.0, trouvez la bonne partition avec :

    cat /proc/partitions

et écrivez l'image ISO avec les informations de la sortie. Exemple :

Attention: Cela supprimera irrévocablement tous les fichiers de votre clé USB, assurez-vous donc de ne pas avoir de fichiers importants sur la clé avant de faire cela.

    dd if=archlinux-version-x86_64.iso of=/dev/sdb bs=4M

#### Utilisation de dd pour Windows

Une version de dd sous licence GPL pour Windows est disponible à l'adresse http://www.chrysocome.net/dd. L'avantage de cette version par rapport à Cygwin est un téléchargement plus petit. Utilisez-la comme indiqué dans les instructions pour Cygwin ci-dessus.

Pour commencer, téléchargez la dernière version de dd pour Windows. Une fois téléchargée, extrayez le contenu de l'archive dans Téléchargements ou ailleurs.

Maintenant, lancez votre `invite de commande` en tant qu'administrateur. Ensuite, changez de répertoire (`cd`) pour aller dans le répertoire Téléchargements.

Si votre ISO Arch Linux se trouve ailleurs, vous devrez peut-être indiquer le chemin complet. Pour plus de commodité, vous pouvez placer l'ISO Arch Linux dans le même dossier que l'exécutable dd. Le format de base de la commande ressemblera à ceci.

    # dd if=archlinux-version-x86_64.iso od=\\.\x: bs=4M

Note: Les lettres de lecteur Windows sont liées à une partition. Pour permettre de sélectionner le disque entier, dd for Windows fournit le paramètre `od`, qui est utilisé dans les commandes ci-dessus. Notez cependant que ce paramètre est spécifique à dd for Windows et ne peut être trouvé dans d'autres implémentations de dd.
Attention: Parce que `od` est utilisé, toutes les partitions du disque sélectionné seront détruites. Soyez absolument sûr que vous dirigez dd vers le bon disque avant de l'exécuter.

Remplacez simplement les différents points nuls (indiqués par un "x") par la date correcte et la lettre de lecteur correcte. Voici un exemple complet.

    # dd if=ISOs\archlinux-version-x86_64.iso od=\\.\d : bs=4M

#### Utilisation de flashnul

flashnul est un utilitaire qui permet de vérifier le fonctionnement et la maintenance des mémoires flash (USB-Flash, IDE-Flash, SecureDigital, MMC, MemoryStick, SmartMedia, XD, CompactFlash, etc).

A partir d'une invite de commande, invoquez flashnul avec `-p`, et déterminez quel index de périphérique est votre clé USB, par ex :

    C:\>flashnul -p

    Lecteurs physiques disponibles :
    Disques logiques disponibles :
    C:\
    D:\
    E:\

Lorsque vous avez déterminé quel périphérique est le bon, vous pouvez écrire l'image sur votre disque en invoquant flashnul avec l'index du périphérique, `-L`, et le chemin d'accès à votre image, par exemple

    C:\>flashnul E: -L path\to\archlinux-version-x86_64.iso

Tant que vous êtes vraiment sûr de vouloir écrire les données, tapez oui, puis attendez un peu qu'il écrive. Si vous obtenez une erreur d'accès refusé, fermez toutes les fenêtres de l'Explorateur que vous avez ouvertes.

Si vous êtes sous Vista ou Win7, vous devez ouvrir la console en tant qu'administrateur, sinon flashnul ne parviendra pas à ouvrir la clé en tant que périphérique de type bloc et ne pourra écrire que via le support de lecteur que Windows fournit.

Note: Il est confirmé que vous devez utiliser la lettre du lecteur par opposition au numéro. flashnul 1rc1, Windows 7 x64.

### Dans macOS

#### Utilisation de macOS dd

Tout d'abord, vous devez identifier le périphérique USB. Ouvrez `/Applications/Utilitaires/Terminal` et listez tous les périphériques de stockage avec la commande :

    $ diskutil list

Votre périphérique USB apparaîtra sous la forme `/dev/disk2 (external, physical)`. Vérifiez qu'il s'agit bien du périphérique que vous souhaitez effacer en vérifiant son nom et sa taille, puis utilisez son identifiant pour les commandes ci-dessous au lieu de /dev/diskX.

Un périphérique USB est normalement monté automatiquement dans macOS, et vous devez le démonter (et non l'éjecter) avant d'y écrire en bloc avec `dd`. Dans le Terminal, faites :

    $ diskutil unmountDisk /dev/diskX

Maintenant, copiez le fichier image ISO sur le périphérique. La commande `dd` est similaire à son homologue Linux, mais remarquez le 'r' avant 'disk' pour le mode brut qui rend le transfert beaucoup plus rapide :

Note: La commande `dd` dérivée de BSD, qui inclut la commande `dd` par défaut de macOS, utilise le suffixe `m` en minuscules. Ceci diffère de GNU `dd`, utilisé ailleurs dans cet article.

    # dd if=path/to/archlinux-version-x86_64.iso of=/dev/rdiskX bs=1m

Cette commande s'exécute en silence. Pour voir la progression, envoyez SIGINFO en appuyant sur `Ctrl+t`. Notez que le suffixe `diskX` ici ne doit pas inclure le suffixe `s1`, sinon le périphérique USB ne sera amorçable qu'en mode UEFI et non en mode legacy. Une fois l'opération terminée, macOS peut se plaindre que "Le disque que vous avez inséré n'est pas lisible par cet ordinateur". Sélectionnez "Ignorer". Le périphérique USB sera amorçable.

### Dans Android

#### Utilisation de EtchDroid

EtchDroid est un flasheur d'images d'OS pour Android. Il fonctionne sans les permissions root sur Android 5 jusqu'à Android 8. Selon des rapports de bogue, il ne fonctionne pas toujours sur Android 9 et Android 4.4.

Pour créer un installateur Arch Linux, téléchargez le fichier image ISO sur votre appareil Android. Branchez le lecteur USB sur votre appareil, en utilisant un adaptateur USB-OTG si nécessaire. Ouvrez EtchDroid, sélectionnez "Flash raw image", sélectionnez votre ISO Arch, puis votre lecteur USB. Accordez la permission de l'API USB et confirmez.

Gardez votre téléphone sur une table pendant qu'il écrit l'image : beaucoup d'adaptateurs USB-OTG sont un peu bancals et vous pourriez le débrancher par erreur.

## Utilisation du formatage manuel

### BIOS et UEFI

#### Dans GNU/Linux

Cette méthode est plus compliquée que l'écriture directe de l'image avec `dd`, mais elle permet de conserver la clé USB utilisable pour le stockage de données (c'est-à-dire que l'ISO est installé dans une partition spécifique au sein du périphérique déjà partitionné sans altérer les autres partitions).

Note: Nous désignerons ici la partition ciblée par `/dev/sdXn`. Dans l'une des commandes suivantes, ajustez X et n en fonction de votre système.

- Si ce n'est pas déjà fait, créez une table de partition sur `/dev/sdX`.
- Si ce n'est pas déjà fait, créez une partition sur le périphérique. La partition `/dev/sdXn` doit être formatée en FAT32.
- Montez le système de fichiers FAT32 situé sur le périphérique flash USB et extrayez le contenu de l'image ISO. Par exemple :

    # mount /dev/sd Xn /mnt
    # bsdtar -x -f archlinux-version-x86_64.iso -C /mnt

Le démarrage nécessite de spécifier le volume sur lequel résident les fichiers. Par défaut, l'étiquette `ARCH_YYYYMM` (avec l'année et le mois de sortie appropriés) est utilisée. Ainsi, l'étiquette du système de fichiers doit être définie en conséquence. Vous pouvez également changer ce comportement en modifiant la configuration du chargeur de démarrage :

- Démarrage BIOS : `archisolabel=ARCH_YYYYMM` dans `/mnt/syslinux/archiso_sys-linux.cfg`.
- Démarrage UEFI : `archisolabel=ARCH_YYYYMM` et `search --no-floppy --set=root --label ARCH_YYYMM` dans `/mnt/EFI/BOOT/grub.cfg`.

Pour utiliser un UUID à la place, remplacez ces portions de lignes par `archisodevice=/dev/disk/by-uuid/YOUR-UUID`. Pour `grub.cfg`, utilisez `search --no-floppy --set=root --fs-uuid YOUR-UUID`.

Note: Un mauvais `archisolabel` ou `archisodevice` empêchera le démarrage à partir du support créé.

Les fichiers Syslinux pour les systèmes BIOS sont déjà copiés dans `/mnt/syslinux`. Démontez le système de fichiers FAT, installez les paquets syslinux et mtools et exécutez les commandes suivantes pour rendre la partition amorçable :

    # umount /mnt
    # syslinux --directory syslinux --install /dev/sdXn
    # dd bs=440 count=1 conv=notrunc if=/usr/lib/syslinux/bios/mbr.bin of=/dev/sdX

Note:

- Remplacez `mbr.bin` par `gptmbr.bin` si `/dev/sdX` possède une Table de partition GUID. Voir Syslinux#Manual install pour plus de détails.
- Pour la table de partition MBR, vous devrez définir l'indicateur "boot". Voir Syslinux#MBR partition table pour plus de détails.

#### Sous Windows

Note:

- Pour le formatage manuel, n'utilisez pas d'utilitaire Bootable USB Creator pour créer une clé USB amorçable UEFI. Pour le formatage manuel, n'utilisez pas non plus dd for Windows pour dd l'ISO sur le lecteur USB.
- Dans les commandes ci-dessous, `X:` est supposé être le lecteur flash USB dans Windows.
- Windows utilise la barre oblique inversée `\` comme séparateur de chemin, donc la même chose est utilisée dans les commandes ci-dessous.
- Toutes les commandes doivent être exécutées dans l'invite de commande de Windows en tant qu'administrateur.
- `>` désigne l'invite de commande de Windows.

- Partitionnez et formatez le lecteur USB en utilisant Rufus USB partitioner. Sélectionnez l'option de schéma de partition comme MBR pour BIOS et UEFI et le système de fichiers comme FAT32. Décochez les options "Create a bootable disk using ISO image" et "Create extended label and icon files".
- Changez le Volume Label du lecteur flash USB `X:` pour qu'il corresponde au LABEL mentionné dans la partie `archisolabel=` de `X:\EFI\BOOT\grub.cfg`. Cette étape est nécessaire pour l'ISO officiel (Archiso). Cette étape peut également être réalisée à l'aide de Rufus, lors de l'étape précédente "partitionner et formater".
- Extraire l'ISO (similaire à l'extraction d'une archive ZIP) sur la clé USB en utilisant 7-Zip.
- Téléchargez les binaires officiels de Syslinux 6.xx (fichier zip) depuis https://www.kernel.org/pub/linux/utils/boot/syslinux/ et extrayez-les. La version de Syslinux doit être la même que celle utilisée dans l'image ISO.

- Exécutez la commande suivante (dans l'invite cmd de Windows, en tant qu'administrateur) :

    > cd bios\
    > for /r %Y in (*.c32) do copy "%Y" "X:\syslinux\" /y
    > copy mbr\*.bin X:\syslinux\ /y

- Installez Syslinux sur la clé USB en exécutant (utilisez `win64\syslinux64.exe` pour Windows x64) :

    > cd bios\
    > win32\syslinux.exe -d /syslinux -i -a -m X :

Note:

- L'étape ci-dessus installe le programme `ldlinux.sys` de Syslinux dans le VBR de la partition USB, définit la partition comme "active/boot" dans la table de partition MBR et écrit le code de démarrage MBR dans la première région de code de démarrage de 440 octets de la clé USB.
- Le commutateur `-d` attend un chemin avec un séparateur de chemin en slash comme dans les systèmes *unix.

### BIOS uniquement

#### Dans GNU/Linux

##### Création d'un lecteur USB-ZIP

Pour certains anciens systèmes BIOS, seul le démarrage à partir de lecteurs USB-ZIP est supporté. Cette méthode vous permet aussi de démarrer à partir d'un disque dur USB.

Attention: Cela détruira toutes les informations contenues sur votre lecteur USB!

- Téléchargez syslinux et mtools depuis les dépôts officiels.
- Trouvez votre lecteur usb avec `lsblk`.
- Tapez `mkdiskimage -4 /dev/sdx 0 64 32` (remplacez x par la lettre de votre lecteur). Cela va prendre un certain temps.

A partir de là, continuez avec la méthode de formatage manuel. La partition sera `/dev/sdx4` en raison du mode de fonctionnement des lecteurs ZIP.

Note: Ne formatez pas le lecteur en FAT32 ; gardez-le en FAT16.

### UEFI uniquement

Pour un démarrage uniquement UEFI, il suffit de copier les fichiers de l'ISO et de changer l'étiquette du volume FAT ou de modifier les fichiers de configuration du chargeur de démarrage pour définir `archisolabel`/`archisodevice` en conséquence.

#### Dans GNU/Linux

Cette méthode copie simplement les fichiers de l'image ISO sur une clé USB et ajuste la configuration de GRUB ou l'étiquette du système de fichiers.

1. Si ce n'est pas déjà fait, créez une table de partition sur `/dev/sdX` et une partition (`/dev/sdXn`) sur le périphérique.
2. Si ce n'est pas déjà fait, formatez la partition en FAT32 :

       # mkfs.fat -F 32 /dev/sdXn

3. Montez le système de fichiers FAT32 :

       # mount /dev/sdXn /mnt

4. Extraire l'image ISO sur le système de fichiers monté :

       # bsdtar -x --exclude=syslinux/ -f archlinux-version-x86_64.iso -C /mnt

5. Soit :
   - Editez `/mnt/EFI/BOOT/grub.cfg` et changez `archisolabel=ARCH_YYYYMM` et `search --no-floppy --set=root --label ARCH_YYYYMM` pour qu'ils correspondent à votre périphérique. Par exemple, en les remplaçant par `archisodevice=/dev/disk/by-uuid/YOUR-UUID` et `search --no-floppy --set=root --fs-uuid YOUR-UUID` respectivement. Démontez ensuite le système de fichiers FAT32.
   - Ou Démontez le système de fichiers et changez son LABEL pour qu'il corresponde à `ARCH_YYYYMM` :

         # fatlabel /dev/sdXn ARCH_YYYYMM

#### Sous Windows

1. Partitionnez la clé USB et formatez-la en FAT32.
2. Faites un clic droit sur `archlinux-version-x86_64.iso` et sélectionnez Monter.
3. Naviguez vers le lecteur DVD nouvellement créé et copiez tous les fichiers et dossiers, à l'exception de `syslinux`, vers la clé USB.
4. Une fois la copie terminée, faites un clic droit sur le lecteur de DVD et sélectionnez Éjecter.
5. Soit :
   - éditez `X:\EFI\BOOT\grub.cfg` avec un éditeur de texte et modifiez `archisolabel=ARCH_YYYYMM` et `search --no-floppy --set=root --label ARCH_YYYMM` pour qu'ils correspondent à votre périphérique. Par exemple, en les remplaçant respectivement par `archisolabel=YOUR-LABEL` et `search --no-floppy --set=root --label YOUR-LABEL`.
   - ou changez le label du volume FAT32 pour qu'il corresponde à `ARCH_YYYYMM`.
6. Éjectez la clé USB.

## Utilisation d'une clé USB multiboot

Cela permet de démarrer plusieurs ISO à partir d'un seul périphérique USB, y compris l'archiso. La mise à jour d'une clé USB existante vers un ISO plus récent est plus simple que pour la plupart des autres méthodes. Consultez Multiboot USB drive.

### Utilisation de ventoy

Ventoy est un outil open source pour créer une clé USB bootable pour les fichiers ISO/WIM/IMG/VHD(x)/EFI. Avec ventoy, vous n'avez pas besoin de formater le disque encore et encore, il suffit de copier les fichiers ISO/WIM/IMG/VHD(x)EFI sur le lecteur USB et de les démarrer directement. Vous pouvez copier plusieurs fichiers à la fois et Ventoy vous proposera un menu de démarrage pour les sélectionner. Il est disponible sous ventoy-binAUR.

### Sous Windows

#### Chargement du support d'installation depuis la RAM

Cette méthode utilise Syslinux et un Ramdisk (MEMDISK) pour charger la totalité de l'image ISO d'Arch Linux en RAM. Puisque cette méthode fonctionne entièrement à partir de la mémoire système, vous devez vous assurer que le système sur lequel vous l'installez dispose d'une quantité suffisante. Une quantité minimale de RAM entre 500 Mo et 1 Go devrait suffire pour une installation d'Arch Linux basée sur MEMDISK.

Pour plus d'informations sur la configuration requise pour Arch Linux ainsi que pour MEMDISK, consultez le Guide d'installation et ici. Pour référence, voici le fil de discussion précédent du forum [3].

Astuce: Une fois que l'installateur a terminé le chargement, vous pouvez simplement retirer la clé USB et même l'utiliser sur une autre machine pour recommencer le processus. L'utilisation de MEMDISK permet également de démarrer et d'installer Arch Linux sur et depuis la même clé USB.

##### Préparation de la clé USB

Commencez par formater la clé USB en FAT32. Créez ensuite les dossiers suivants sur le disque nouvellement formaté.

- `Boot`
  - `Boot/ISO`
  - `Boot/Settings`

##### Copiez les fichiers nécessaires sur le lecteur flash USB

Copiez ensuite l'ISO que vous souhaitez démarrer dans le dossier `Boot/ISOs`. Après cela, extrayez les fichiers suivants de la dernière version de syslinux depuis ici et copiez-les dans les dossiers suivants.

- `./win32/syslinux.exe` dans le dossier Bureau ou Téléchargements de votre système.
- `./memdisk/memdisk` dans le dossier `Settings` de votre clé USB.

##### Créer le fichier de configuration

Après avoir copié les fichiers nécessaires, naviguez vers le lecteur flash USB, /boot/Settings et créez un fichier `syslinux.cfg`.

Note: Sur la ligne `INITRD`, veillez à utiliser le nom du fichier ISO que vous avez copié dans votre dossier `ISO`.

    /Boot/Settings/syslinux.cfg

    DEFAULT arch_iso

    LABEL arch_iso
            MENU LABEL Arch Setup
            LINUX memdisk
            INITRD /Boot/ISOs/archlinux-version-x86_64.iso
            APPEND iso

Pour plus d'informations, consultez l'article Syslinux.

##### Dernières étapes

Enfin, créez un fichier `*.bat` à l'endroit où se trouve `syslinux.exe` et exécutez-le ("Exécuter en tant qu'administrateur" si vous êtes sous Vista ou Windows 7) :

    C:\Documents and Settings\Notre nom d'utilisateur

    Desktop

## Méthodes déconseillées

Attention: Les méthodes suivantes sont déconseillées.

### Utilisation de etcher

etcher contient des données analytiques et des publicités de première partie. Consultez [4], [5] et [6].

### Utilisation de Universal USB Installer

- La page de téléchargement contient de faux boutons "Télécharger" qui peuvent contenir des logiciels malveillants.
- Universal USB Installer n'écrit pas l'ISO tel quel, ce qui empêche le démarrage avec un BIOS en raison des différences entre les versions de syslinux. Consultez [7].
- Les chargeurs de démarrage de l'image d'installation d'Arch Linux s'attendent à ce que le contenu de l'ISO réside sur un volume portant l'étiquette `ARCH_YYYYXX`. Universal USB Installer ne met pas à jour l'étiquette du système de fichiers, et ne corrige pas la configuration du chargeur d'amorçage.

### Utilisation de UNetbootin

- UNetbootin n'écrit pas l'ISO tel quel, ce qui emêche le démarrage avec un BIOS en raison de la différence entre les versions de syslinux.
- Les chargeurs de démarrage de l'image d'installation d'Arch Linux s'attendent à ce que le contenu de l'ISO réside sur un volume portant l'étiquette `ARCH_YYYYXX`. UNetbootin ne met pas à jour l'étiquette du système de fichiers, et ne corrige pas la configuration du chargeur d'amorçage.

## Dépannage

- Si vous obtenez l'erreur `device did not show up after 30 seconds` due au fait que `/dev/disk/by-label/ARCH_YYYYMM` n'est pas monté, essayez de renommer votre support USB en `ARCH_YYYMM` afin que Arch puisse le trouver. (par exemple, pour `archlinux-2021.02.01-x86_64.iso`, utilisez `ARCH_202102`).
- Si vous obtenez d'autres erreurs, essayez d'utiliser un autre périphérique USB. Il existe des cas de figure dans lesquels cela a résolu tous les problèmes.
- Si vous obtenez `losetup : /run/archiso/bootmnt/arch/x86_64/airootfs.sfs : failed to set up loop devices : No such file or directory`, essayez d'utiliser un port USB 2.0. (Certains ports USB 3.0 à travers des hubs USB ne fonctionnent pas).

## Voir aussi

- Gentoo:LiveUSB/Guide.
- Fedora:How to create and use Live USB/fr.
- wiki openSUSE - SDB:Live USB Stick]

Category:

- Installation process (Français)