909 lines
41 KiB
TeX
909 lines
41 KiB
TeX
\documentclass[aspectratio=169]{beamer}
|
|
|
|
\makeatletter
|
|
\appto\input@path{{libs/awesome-beamer}, {libs/smile}}
|
|
\makeatother
|
|
|
|
\usepackage{fontspec}
|
|
\setmonofont[
|
|
Path = ./fonts/,
|
|
Scale = .9,
|
|
Extension = .ttf,
|
|
Contextuals=Alternate,
|
|
BoldFont={*-Bold},
|
|
UprightFont={*-Regular},
|
|
]{FiraCode}
|
|
\renewcommand\setmonofont[2][]{}
|
|
|
|
\usepackage[french]{babel}
|
|
|
|
\usepackage[
|
|
type={CC},
|
|
modifier={by-nc-sa},
|
|
version={4.0},
|
|
]{doclicense}
|
|
|
|
\definecolor{base-color}{HTML}{1793d1}
|
|
\usetheme[english, color, coloraccent=base-color, secslide]{awesome}
|
|
|
|
\usepackage{minted}
|
|
\usepackage[usenames,dvipsnames]{xcolor}
|
|
\hypersetup{
|
|
colorlinks=true,
|
|
linkcolor=black,
|
|
filecolor=black,
|
|
urlcolor=ForestGreen,
|
|
citecolor=black,
|
|
}
|
|
|
|
\setlength{\fboxsep}{1pt}
|
|
\newcommand{\keystroke}[1]{\colorbox{darkgray}{\fbox{\strut\kern0.1em\color{white}\texttt{#1}\kern0.1em}}}
|
|
\newcommand{\keycombo}[2]{%
|
|
\keystroke{#1}%
|
|
\kern 0.1em%
|
|
\texttt{+}%
|
|
\kern 0.1em%
|
|
\keystroke{#2}}
|
|
|
|
\newcommand{\command}[1]{\texttt{\textcolor{blue}{\$\,#1}}}
|
|
\newcommand{\placeholder}[1]{\textcolor{orange}{\texttt{<#1>}}}
|
|
|
|
\usetikzlibrary{arrows.meta, positioning}
|
|
|
|
\usepackage{pgfpages}
|
|
\usepackage{everypage}
|
|
\ifdefined\printlandscape
|
|
\pgfpagesuselayout{4 on 1}[letterpaper, border shrink=1mm, landscape]
|
|
\AddEverypageHook{
|
|
\begin{tikzpicture}[remember picture, overlay]
|
|
\draw[ultra thick] (current page.north west) rectangle (current page.south east);
|
|
\end{tikzpicture}
|
|
}
|
|
\fi
|
|
\ifdefined\printportrait
|
|
\pgfpagesuselayout{8 on 1}[letterpaper, border shrink=1mm]
|
|
\AddEverypageHook{
|
|
\begin{tikzpicture}[remember picture, overlay]
|
|
\draw[ultra thick] (current page.north west) rectangle (current page.south east);
|
|
\end{tikzpicture}
|
|
}
|
|
\fi
|
|
|
|
\title[]{Séminaire d'Installation d'Arch Linux}
|
|
\subtitle{Département d'informatique}
|
|
\author{Eric Hervet et Andy Couturier}
|
|
\email{}
|
|
\institute{Faculté des sciences}
|
|
\uni{Université de Moncton}
|
|
\location{Université de Moncton}
|
|
\background{media/background.jpg}
|
|
\date{7 avril 2026}
|
|
|
|
\begin{document}
|
|
{
|
|
\setbeamertemplate{footline}{}
|
|
\begin{frame}[plain,noframenumbering]
|
|
\begin{tikzpicture}[remember picture, overlay]
|
|
\node[inner sep=0pt] at (current page.center) {%
|
|
\includegraphics[width=\paperwidth, height=\paperheight]{media/title-slide.png}%
|
|
};
|
|
\end{tikzpicture}
|
|
\end{frame}
|
|
}
|
|
|
|
\begin{frame}
|
|
\begin{wide}
|
|
\centering
|
|
\doclicenseImage[imagewidth=5cm]
|
|
|
|
\vspace{1.5em}
|
|
\LARGE\textbf{\doclicenseLongText}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame}{Table des matières}
|
|
\tableofcontents
|
|
\end{frame}
|
|
|
|
\section{Pourquoi ?}
|
|
|
|
\begin{frame} \frametitle{Pourquoi ?}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item La plupart des distributions Linux offrent un installateur graphique. Il existe même des scripts semi-automatiques pour Arch Linux.
|
|
\item Ce séminaire propose une approche différente~: installer Arch Linux manuellement, commande par commande.
|
|
\item Mais pourquoi s'infliger ça ?
|
|
\begin{itemize}
|
|
\item \textbf{\Rightarrow\:Pour apprendre.}
|
|
\end{itemize}
|
|
\item Comprendre un système en profondeur, c'est ce qui distingue l'approche scientifique de la simple utilisation.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{Ce que vous allez apprendre}
|
|
\begin{wide}
|
|
En réalisant cette installation, vous allez~:
|
|
\vspace{0.5cm}
|
|
\begin{itemize}[<+->]
|
|
\item Comprendre la \textbf{structure} d'un système d'exploitation.
|
|
\item Comprendre le \textbf{partitionnement} et sa relation aux systèmes de fichiers.
|
|
\item Comprendre le \textbf{processus de démarrage} d'un système d'exploitation.
|
|
\item Apprendre à \textbf{personnaliser} et maîtriser votre environnement Linux.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\section{Support d'installation}
|
|
|
|
\begin{frame} \frametitle{Support d'installation}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item Pour créer une clé USB qui contient l'image d'installation d'Arch Linux~:
|
|
\begin{enumerate}
|
|
\item Rendez-vous à l'adresse \href{https://archlinux.org/download/}{https://archlinux.org/download/}.
|
|
\item Choisissez un serveur canadien dans la liste et cliquez sur son lien.
|
|
\item Via la page d'index du serveur, téléchargez le fichier ISO qui aura un nom comme~: \texttt{archlinux-20XX.XX.01-x86\_64.iso}.
|
|
\end{enumerate}
|
|
\item Si vous êtes déjà sur Linux~:
|
|
\begin{enumerate}
|
|
\item Ouvrez un terminal.
|
|
\item Branchez la clé USB qui servira de support d'installation.
|
|
\item \command{sudo dmesg} pour identifier le code \texttt{sdX} de la clé USB.
|
|
\item Placez-vous dans le répertoire où se trouve l'ISO en utilisant \texttt{cd}.
|
|
\item \command{sudo dd bs=32M if=archlinux-20XX.XX.01-x86\_64.iso of=/dev/sdX conv=fsync oflag=direct status=progress}
|
|
\end{enumerate}
|
|
\item Si vous êtes sur Windows (nos sincères sympathies)~: Vous pouvez utiliser \href{https://rufus.ie/en/}{Rufus}.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{Démarrer sur la clé USB}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item Branchez la clé USB contenant l'ISO d'Arch Linux et redémarrez l'ordinateur.
|
|
\item Accédez au \textbf{menu de démarrage} (\textit{boot menu}) en appuyant sur une touche au démarrage. La touche varie selon le fabricant~:
|
|
\begin{itemize}
|
|
\item \keystroke{F12}~: Dell, Lenovo, Acer
|
|
\item \keystroke{F9}~: HP
|
|
\item \keystroke{Esc}~: ASUS
|
|
\item \keystroke{F2} ou \keystroke{Del}~: Accès au BIOS/UEFI si le boot menu n'est pas disponible
|
|
\end{itemize}
|
|
\item Sélectionnez la clé USB dans la liste des périphériques de démarrage.
|
|
\item Si \textbf{Secure Boot} empêche le démarrage, désactivez-le dans les paramètres UEFI.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\section{Partitionnement, formatage et montage}
|
|
|
|
\begin{frame} \frametitle{Table de partitionnement}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item Une \textbf{table de partitionnement} est une structure située sur un disque qui décrit comment l'espace de stockage est divisé en \textbf{partitions}.
|
|
\item Elle détermine où chaque partition commence et se termine, ainsi que le type de système de fichiers de chaque partition.
|
|
\item Elle indique quelles partitions sont amorçables (\textit{«~bootable~»}), guidant ainsi le processus de démarrage.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{Partitions et systèmes de fichiers}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item Un \textbf{système de fichiers} est la méthode utilisée pour organiser et stocker les données sur une partition. Il définit comment les fichiers sont nommés, rangés dans des répertoires et retrouvés sur le support de stockage.
|
|
\item Chaque partition est formatée avec un système de fichiers spécifique (ex. FAT32, ext4, F2FS). Différents systèmes de fichiers peuvent coexister sur le même disque.
|
|
\item La table de partitionnement permet au système d'exploitation de localiser chaque partition, et le système de fichiers de chaque partition lui permet d'en lire et organiser le contenu.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame}
|
|
\frametitle{MBR vs GPT}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item Il y a deux formats de table de partitionnement possibles.
|
|
\item \textbf{MBR (Master Boot Record)}
|
|
\begin{itemize}
|
|
\item Taille maximale de disque~: 2 TiB.
|
|
\item Limité à 4 partitions primaires.
|
|
\item Plus ancien, conçu pour le BIOS.
|
|
\item Pas de redondance, si le MBR est corrompu, les données peuvent être inaccessibles.
|
|
\end{itemize}
|
|
\item \textbf{GPT (GUID Partition Table)}
|
|
\begin{itemize}
|
|
\item Taille maximale de disque~: 9.4 ZiB.
|
|
\item Supporte jusqu'à 128 partitions primaires.
|
|
\item Utilise des identifiants globaux uniques (GUID) qui permettent l'identification précise des partitions avec un identifiant \texttt{PARTUUID}.
|
|
\item Plus moderne, conçu pour UEFI.
|
|
\item Redondance avec deux copies de la table, une au début et une à la fin du disque.
|
|
\begin{itemize}
|
|
\item Inclut un hash CRC32 pour détecter la corruption de la table.
|
|
\end{itemize}
|
|
\end{itemize}
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
|
|
\begin{frame} \frametitle{Table de partitionnement}
|
|
\begin{wide}
|
|
\begin{center}
|
|
\begin{tabular}{|c|l|l|c|l|}
|
|
\hline
|
|
\textbf{\#} & \textbf{Device} & \textbf{Mountpoint} & \textbf{Type} & \textbf{Taille} \\ \hline
|
|
1 & /dev/sdX1 & /boot (/mnt/boot) & ef00 & 1 GiB \\ \hline
|
|
2 & /dev/sdX2 & / (/mnt) & 8300 & Reste \\ \hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
\begin{itemize}[<+->]
|
|
\item Les mountpoints entre parenthèses seront les mountpoints temporaires des partitions pendant l'installation. Ils se trouveront sur le système de fichiers existant du support d'installation.
|
|
\item Le type de partition \texttt{ef00} indique qu'il s'agit d'une partition EFI. Cela signifie que le système a un firmware UEFI pour le démarrage.
|
|
\item La taille de 1 GiB est généralement suffisante pour stocker le noyau Linux et les fichiers de démarrage nécessaires.
|
|
\item Le type de partition \texttt{8300} est l'identifiant pour une partition Linux standard sous le schéma de partitionnement GPT.
|
|
\item La partition racine utilisera le reste de l'espace libre du disque.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{Partitionnement}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item Branchez la clé sur laquelle vous allez installer Arch Linux et ensuite faites immédiatement \command{dmesg} pour identifier le code \texttt{sdX} de la clé USB.
|
|
\item \command{gdisk /dev/sdX} pour commencer à partitionner le disque interactivement.
|
|
\begin{itemize}
|
|
\setlength\itemsep{-0.05em}
|
|
\item \keystroke{o} puis \keystroke{y} pour effacer toutes les partitions.
|
|
\item \keystroke{n} pour créer une nouvelle partition.
|
|
\item \keystroke{Enter} pour choisir la partition par défaut (1).
|
|
\item \keystroke{Enter} pour choisir le secteur de départ par défaut.
|
|
\item \texttt{+1G} pour choisir le secteur de fin 1~GiB après le secteur de départ.
|
|
\item \texttt{ef00} pour le type de partition.
|
|
\item \keystroke{n} pour créer une nouvelle partition.
|
|
\item \keystroke{Enter} pour choisir la partition par défaut (2).
|
|
\item \keystroke{Enter} pour choisir le secteur de départ par défaut.
|
|
\item \keystroke{Enter} pour choisir le secteur de fin par défaut (fin du disque).
|
|
\item \keystroke{Enter} pour choisir le type de partition par défaut (\texttt{8300}).
|
|
\item \keystroke{p} pour vérifier le partitionnement.
|
|
\item \keystroke{w} puis \keystroke{y} pour écrire la table de partitions au disque.
|
|
\end{itemize}
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame}
|
|
\frametitle{Formatage de la partition de démarrage}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item \command{mkfs.fat -F32 /dev/sdX1}
|
|
\item \textbf{Conformité UEFI (Unified Extensible Firmware Interface)}~: Le standard UEFI requiert une partition système EFI (ESP) au format FAT32.
|
|
\item \textbf{Pilotes UEFI intégrés}~: Les firmwares UEFI incluent des pilotes FAT. Sans ce format, l'UEFI ne peut ni localiser ni charger le bootloader, rendant le démarrage impossible.
|
|
\item \textbf{Compatibilité universelle}~: FAT32 est pris en charge nativement par la plupart des systèmes d'exploitation, simplifiant la mise à jour de la partition (fichiers EFI, bootloaders, etc.) depuis n'importe quelle plateforme.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame}
|
|
\frametitle{Formatage de la partition racine}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item \command{mkfs.f2fs /dev/sdX2}
|
|
\item \textbf{F2FS (Flash-Friendly File System)} est un système de fichiers conçu spécifiquement pour les supports à base de mémoire flash~: SSD, eMMC, clés USB, cartes SD.
|
|
\item Contrairement aux systèmes de fichiers traditionnels (ex. ext4), F2FS tient compte des particularités de la mémoire flash pour offrir de meilleures performances et prolonger la durée de vie du support.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame}
|
|
\frametitle{Pourquoi la mémoire flash est différente}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item La mémoire flash ne peut pas \textbf{réécrire} directement une cellule~: elle doit d'abord l'\textbf{effacer}, puis écrire les nouvelles données.
|
|
\item Chaque cellule a un nombre limité de cycles d'effacement avant de s'user.
|
|
\item Un système de fichiers classique, qui réécrit souvent au même endroit, accélère cette usure.
|
|
\item F2FS résout ces problèmes grâce à une conception \textbf{log-structured} et des mécanismes comme le \textbf{garbage collection} et le \textbf{TRIM}.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame}
|
|
\frametitle{F2FS~: fonctionnement}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item \textbf{Log-structured}~: F2FS écrit les données modifiées dans de nouveaux blocs au lieu de réécrire au même endroit. Cela évite les cycles d'effacement inutiles et réduit l'usure.
|
|
\item \textbf{Écriture séquentielle}~: Les écritures dans de nouveaux blocs sont organisées en flux séquentiels plutôt qu'aléatoires, ce qui correspond mieux au fonctionnement interne de la mémoire flash et améliore les performances.
|
|
\item \textbf{Garbage collection}~: F2FS récupère l'espace occupé par les anciennes données devenues obsolètes en regroupant les données valides et en libérant les segments inutilisés.
|
|
\item \textbf{TRIM}~: F2FS informe le contrôleur flash des blocs qui ne sont plus utilisés, lui permettant d'optimiser ses opérations internes d'effacement.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{Montage des partitions}
|
|
\begin{wide}
|
|
\centering
|
|
\begin{tikzpicture}[
|
|
nd/.style={draw, rounded corners=3pt, minimum height=0.65cm, align=center, font=\small\ttfamily},
|
|
prt/.style={nd, fill=base-color!15},
|
|
title/.style={font=\normalsize\bfseries},
|
|
lbl/.style={font=\scriptsize\itshape, text=darkgray},
|
|
arr/.style={-{Stealth[length=3mm]}, thick, base-color!70!black},
|
|
]
|
|
% Avant
|
|
\node<1->[title] at (-4.5, 2.2) {Avant};
|
|
\node<1->[nd, dashed, minimum width=2cm] (mnt-before) at (-4.5, 1) {/mnt};
|
|
\node<1->[lbl] at (-4.5, 0.2) {(vide)};
|
|
|
|
% Flèche
|
|
\draw<2->[arr] (-2.5, 1) -- (-1, 1) node[midway, above, font=\footnotesize] {mount};
|
|
|
|
% Après
|
|
\node<2->[title] at (2.5, 2.2) {Après};
|
|
\node<2->[prt] (mnt) at (2.5, 1) {/mnt};
|
|
\node<2->[prt] (boot) at (0.5, -0.3) {boot};
|
|
\node<2->[nd] (etc) at (2.5, -0.3) {etc};
|
|
\node<2->[nd] (home) at (4.5, -0.3) {home};
|
|
\node<2->[nd] (dots) at (6, -0.3) {\ldots};
|
|
|
|
\draw<2->[thick] (mnt) -- (boot);
|
|
\draw<2->[thick] (mnt) -- (etc);
|
|
\draw<2->[thick] (mnt) -- (home);
|
|
\draw<2->[thick] (mnt) -- (dots.north west);
|
|
|
|
% Labels partitions
|
|
\node<2->[lbl, right=0.15cm of mnt, font=\scriptsize] {$\leftarrow$ \texttt{/dev/sdX2}};
|
|
\node<2->[lbl, below=0.1cm of boot, font=\scriptsize, xshift=0.5cm] {$\uparrow$ \texttt{/dev/sdX1}};
|
|
\end{tikzpicture}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{Montage des partitions}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item Le montage des partitions sous Linux est le processus qui rend un système de fichiers prêt à être utilisé par le système d'exploitation. Cela implique d'associer un système de fichiers situé sur une partition à un répertoire spécifique du système de fichiers global appelé point de montage (mountpoint).
|
|
\item \command{mount /dev/sdX2 /mnt}~: On monte la partition racine dans le système de fichiers temporaire fourni par l'environnement d'installation.
|
|
\item \command{mkdir /mnt/boot}~: Création du répertoire \texttt{/mnt/boot} pour accueillir la partition de démarrage.
|
|
\item \command{mount /dev/sdX1 /mnt/boot}~: On monte la partition de démarrage dans le répertoire \texttt{boot} du système de fichiers racine.
|
|
\item Ces opérations intègrent ainsi l'arborescence de fichiers de \texttt{/dev/sdX1} et de \texttt{/dev/sdX2} dans celle du support d'installation, ce qui permet d'accéder à la structure complète du futur système.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{Fichier fstab}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item \command{mkdir /mnt/etc}~: Création du répertoire des configurations du système.
|
|
\item \command{genfstab -t PARTUUID /mnt > /mnt/etc/fstab}~: Scanne les partitions montées et crée un fichier \texttt{/mnt/etc/fstab} en utilisant les \textbf{PARTUUID} pour identifier de manière unique chaque partition.
|
|
\item Le fichier \texttt{/mnt/etc/fstab} indique au système quelles partitions monter, leurs points de montage, les types de systèmes de fichiers et les options de montage.
|
|
\item \textbf{Pourquoi \texttt{PARTUUID} ?}
|
|
\begin{itemize}
|
|
\item Les noms de périphériques comme \texttt{/dev/sda}, \texttt{/dev/sdb} peuvent changer d'un démarrage à l'autre, surtout si des supports amovibles sont connectés.
|
|
\item Les \textbf{PARTUUID} sont des identifiants uniques et persistants assignés à chaque partition, garantissant un montage fiable quel que soit l'ordre de détection des périphériques.
|
|
\end{itemize}
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\section{Installation}
|
|
|
|
\begin{frame} \frametitle{Paquets}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item L'une des plus grandes forces de Linux réside dans son système de paquets. Chaque logiciel est distribué sous forme de paquet avec une signature cryptographique qui garantit son authenticité et son intégrité.
|
|
\item Grâce à la vérification cryptographique des paquets, il n'est pas nécessaire de faire confiance au serveur qui distribue les logiciels (miroir) lui-même, puisqu'un paquet non-signé ou altéré sera rejeté automatiquement par le gestionnaire de paquets du système (pacman).
|
|
\item N'importe qui peut héberger un miroir des dépôts Arch Linux, c'est-à-dire un serveur qui contient une copie de tous les paquets officiels créés par les développeurs d'Arch Linux.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{Optimisation des miroirs}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item L'écosystème des miroirs d'Arch Linux comprend plus de 800 serveurs répartis à travers le monde. Parmi ceux-ci, certains serveurs sont géographiquement plus proches, offrant ainsi une latence réduite ainsi qu'une bande passante souvent supérieure.
|
|
\item Avant d'installer le système, il est donc préférable d'optimiser la liste des miroirs pour télécharger les paquets plus rapidement.
|
|
\item \command{pacman --noconfirm -Syy reflector}~: Installe et met à jour la base de données des paquets, puis installe \texttt{reflector}, un outil d'optimisation des miroirs.
|
|
\item \command{reflector --verbose --sort rate --country Canada --protocol http,https --save /etc/pacman.d/mirrorlist}~: Met à jour la liste des miroirs en utilisant ceux au Canada et triée du plus rapide au plus lent.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame}
|
|
\frametitle{Optimisation de pacman}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item Pour améliorer les performances de pacman, éditez le fichier de configuration \texttt{/etc/pacman.conf}.
|
|
Décommentez la ligne \texttt{ParallelDownloads} puis définissez sa valeur à \textbf{32} (ou un autre nombre selon vos préférences).
|
|
|
|
\begin{block}{}
|
|
\texttt{\#ParallelDownloads = 5} \quad \textcolor{ForestGreen}{\textit{(Décommentez et modifiez)}}
|
|
|
|
\texttt{ParallelDownloads = 32}
|
|
\end{block}
|
|
|
|
\item Cette modification permet d'effectuer plusieurs téléchargements en parallèle, réduisant significativement le temps total de mise à jour ou d'installation des paquets.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{Installation du système}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item \command{pacstrap /mnt base base-devel linux linux-headers linux-firmware xorg-drivers nvidia-open intel-ucode amd-ucode zram-generator git} \textcolor{red}{\Leftarrow\: Ajouter un éditeur de texte (ex. nano, vim).}
|
|
\begin{itemize}
|
|
\item \textbf{\texttt{base}}~: Paquets essentiels pour un système Arch minimal.
|
|
\item \textbf{\texttt{base-devel}}~: Ensemble d'outils de développement pour la compilation de logiciels.
|
|
\item \textbf{\texttt{linux} et \texttt{linux-headers}}~: Noyau Linux et ses en-têtes nécessaires pour le développement de modules.
|
|
\item \textbf{\texttt{linux-firmware}}~: Collection de firmwares pour divers matériels pour assurer un bon support matériel.
|
|
\item \textbf{\texttt{xorg-drivers} et \texttt{nvidia-open}}~: Pilotes graphiques (Intel, AMD, Nvidia) pour assurer un bon support matériel.
|
|
\item \textbf{\texttt{intel-ucode} et \texttt{amd-ucode}}~: Microcodes pour les processeurs Intel et AMD, permettant l'installation des mises à jour critiques du microprogramme.
|
|
\item \textbf{\texttt{zram-generator}}~: Utilitaire permettant de configurer zram pour la compression de la mémoire vive.
|
|
\item \textbf{\texttt{git}}~: Système de gestion de versions distribué qui sera utile pour installer des paquets plus tard.
|
|
\end{itemize}
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{Transfert des optimisations}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item \command{cp /etc/pacman.conf /mnt/etc/pacman.conf}~: Copie la configuration de \texttt{pacman} dans le nouveau système, préservant les optimisations précédemment définies.
|
|
\item \command{cp /etc/pacman.d/mirrorlist /mnt/etc/pacman.d/mirrorlist}~: Transfère la liste des miroirs optimisée dans le nouveau système, afin de conserver la liste de miroirs optimisés.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\section{Chroot}
|
|
|
|
\begin{frame}
|
|
\frametitle{Chroot}
|
|
\begin{wide}
|
|
\centering
|
|
\begin{tikzpicture}[
|
|
nd/.style={draw, rounded corners=3pt, minimum height=0.55cm, align=center, font=\small\ttfamily},
|
|
root/.style={nd, fill=base-color!15},
|
|
title/.style={font=\small\bfseries},
|
|
arr/.style={-{Stealth[length=2.5mm]}, thick, base-color!70!black},
|
|
]
|
|
% Avant
|
|
\node<1->[title] at (-4, 1.6) {Avant chroot};
|
|
\node<1->[root] (r1) at (-4, 0.8) {/};
|
|
\node<1->[nd] (mnt1) at (-4, -0.15) {mnt};
|
|
\node<1->[nd] (boot1) at (-6, -1.1) {boot};
|
|
\node<1->[nd] (etc1) at (-4, -1.1) {etc};
|
|
\node<1->[nd] (home1) at (-2, -1.1) {home};
|
|
\node<1->[nd] (dots1) at (-0.5, -1.1) {\ldots};
|
|
\draw<1->[thick] (r1) -- (mnt1);
|
|
\draw<1->[thick] (mnt1) -- (boot1);
|
|
\draw<1->[thick] (mnt1) -- (etc1);
|
|
\draw<1->[thick] (mnt1) -- (home1);
|
|
\draw<1->[thick] (mnt1) -- (dots1.north west);
|
|
|
|
% Flèche
|
|
\draw<2->[arr] (-0.2, 0.3) -- (1.3, 0.3) node[midway, above, font=\footnotesize] {chroot /mnt};
|
|
|
|
% Après
|
|
\node<2->[title] at (4, 1.6) {Après chroot};
|
|
\node<2->[root] (r2) at (4, 0.8) {/};
|
|
\node<2->[nd] (boot2) at (2, -0.15) {boot};
|
|
\node<2->[nd] (etc2) at (4, -0.15) {etc};
|
|
\node<2->[nd] (home2) at (6, -0.15) {home};
|
|
\node<2->[nd] (dots2) at (7.5, -0.15) {\ldots};
|
|
\draw<2->[thick] (r2) -- (boot2);
|
|
\draw<2->[thick] (r2) -- (etc2);
|
|
\draw<2->[thick] (r2) -- (home2);
|
|
\draw<2->[thick] (r2) -- (dots2.north west);
|
|
\end{tikzpicture}
|
|
|
|
\vspace{0.3cm}
|
|
\begin{itemize}
|
|
\item<3-> \command{arch-chroot /mnt}
|
|
\item<3-> La commande \texttt{arch-chroot} change la racine du système de fichiers~: \texttt{/mnt} devient \texttt{/}. Vous pouvez alors gérer le nouveau système comme s'il était démarré (installer des paquets, configurer des services, etc.).
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame}
|
|
\frametitle{Étapes du processus de démarrage}
|
|
\begin{wide}
|
|
\begin{enumerate}[<+->]
|
|
\item \textbf{Firmware}~: Le firmware (UEFI) initialise le matériel minimal, localise la partition système EFI (ESP) et charge le bootloader se trouvant dessus.
|
|
\item \textbf{Bootloader}~: Le bootloader (systemd-boot) charge le noyau et l'initramfs en mémoire, puis passe la main au noyau en lui fournissant les paramètres nécessaires.
|
|
\item \textbf{Noyau Linux}~: Le noyau commence à s'exécuter, décompresse l'initramfs et le monte comme système de fichiers racine temporaire.
|
|
\item \textbf{Initramfs}~: L'initramfs fournit les pilotes et outils indispensables pour trouver et monter la véritable racine du système. Une fois la racine montée, le noyau lance le processus init.
|
|
\item \textbf{Processus init}~: Le premier processus est \texttt{systemd} (PID 1). Il lance les services, monte les partitions complémentaires, configure le réseau, met en place et lance l'environnement utilisateur final.
|
|
\end{enumerate}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame}
|
|
\frametitle{Processus de démarrage}
|
|
\begin{wide}
|
|
\centering
|
|
\vspace{0.5cm}
|
|
\begin{tikzpicture}[
|
|
box/.style={draw, rounded corners=4pt, fill=base-color!15, minimum width=2cm, minimum height=1.1cm, align=center, font=\small\bfseries},
|
|
arr/.style={-{Stealth[length=3mm]}, thick, base-color!70!black},
|
|
desc/.style={font=\scriptsize, align=center, text width=2.5cm},
|
|
]
|
|
% Tous les nœuds (visibles quand leur slide arrive)
|
|
\node<1->[box] (fw) at (0,0) {Firmware\\[-2pt]{\footnotesize(UEFI)}};
|
|
\node<2->[box] (bl) at (2.8,0) {Bootloader\\[-2pt]{\footnotesize(systemd-boot)}};
|
|
\node<3->[box] (kern) at (5.6,0) {Noyau\\[-2pt]{\footnotesize Linux}};
|
|
\node<4->[box] (initr) at (8.4,0) {Initramfs};
|
|
\node<5->[box] (sysd) at (11.2,0) {systemd\\[-2pt]{\footnotesize(PID 1)}};
|
|
|
|
% Descriptions
|
|
\node<1->[desc, below=0.4cm of fw] {Initialise le matériel,\\trouve l'ESP};
|
|
\node<2->[desc, below=0.4cm of bl] {Charge le noyau\\et l'initramfs};
|
|
\node<3->[desc, below=0.4cm of kern] {Décompresse et\\monte l'initramfs};
|
|
\node<4->[desc, below=0.4cm of initr] {Monte la vraie\\racine du système};
|
|
\node<5->[desc, below=0.4cm of sysd] {Lance les services\\et le bureau};
|
|
|
|
% Flèches
|
|
\draw<2->[arr] (fw) -- (bl);
|
|
\draw<3->[arr] (bl) -- (kern);
|
|
\draw<4->[arr] (kern) -- (initr);
|
|
\draw<5->[arr] (initr) -- (sysd);
|
|
\end{tikzpicture}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\section{Bootloader}
|
|
|
|
\begin{frame} \frametitle{Bootloader}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item \command{bootctl install}~: Installe le chargeur de démarrage (\textit{bootloader}) systemd-boot sur la partition EFI.
|
|
\item Créez le fichier \texttt{/boot/loader/loader.conf} avec le contenu suivant~:\\
|
|
\begin{block}{}
|
|
\texttt{default arch.conf} \\
|
|
\texttt{timeout 0}
|
|
\end{block}
|
|
\item Cette configuration définit le fichier \texttt{arch.conf} comme l'entrée par défaut et désactive le délai d'attente (\texttt{timeout 0}), ce qui lance immédiatement Arch Linux au démarrage.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{Bootloader}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item \command{blkid -s PARTUUID -o value /dev/sdX2 > /boot/loader/entries/arch.conf}~: Insère la PARTUUID de la partition racine dans \texttt{arch.conf} pour éviter de devoir la retaper manuellement.
|
|
\item Éditez le fichier \texttt{/boot/loader/entries/arch.conf} avec le contenu suivant~:\\
|
|
\begin{block}{}
|
|
\texttt{title Arch Linux} \\
|
|
\texttt{linux /vmlinuz-linux} \\
|
|
\texttt{initrd /intel-ucode.img} \\
|
|
\texttt{initrd /amd-ucode.img} \\
|
|
\texttt{initrd /initramfs-linux-fallback.img} \\
|
|
\texttt{options root=PARTUUID=}\placeholder{PARTUUID}\texttt{ rw}
|
|
\end{block}
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{Bootloader}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item \textbf{\texttt{title Arch Linux}}~: Définit le nom qui apparaîtra dans le menu de démarrage.
|
|
\item \textbf{\texttt{linux /vmlinuz-linux}}~: Indique le chemin vers le noyau Linux.
|
|
\item \textbf{\texttt{initrd /intel-ucode.img}}~: Charge le microcode des processeurs Intel.
|
|
\item \textbf{\texttt{initrd /amd-ucode.img}}~: Charge le microcode des processeurs AMD. Ces fichiers ne sont appliqués que si le matériel correspondant est utilisé.
|
|
\item \textbf{\texttt{initrd /initramfs-linux-fallback.img}}~: Charge une image de système de fichiers minimal en mémoire (initramfs) qui fournit les pilotes essentiels au noyau. La version \texttt{fallback} contient tous les pilotes disponibles, contrairement à la version standard qui est générée selon la configuration matérielle de l'ordinateur où a été réalisée l'installation.
|
|
\item \textbf{\texttt{options root=PARTUUID=}\placeholder{PARTUUID}\texttt{ rw}}~: Spécifie les options de démarrage du noyau, en particulier la partition racine (root) et l'option \texttt{rw} pour un accès en lecture-écriture.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\section{Initramfs}
|
|
|
|
\begin{frame}
|
|
\frametitle{Initramfs -- Modules USB}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item Pour permettre à l'initramfs de monter une partition racine se trouvant sur une clé USB, éditez le fichier de configuration \texttt{/etc/mkinitcpio.conf} comme suit~:
|
|
\begin{block}{}
|
|
\texttt{MODULES=(usbhid xhci\_hcd)}
|
|
\end{block}
|
|
\item Ce sont les modules nécessaires pour s'assurer que les pilotes USB requis sont chargés pendant le processus d'initialisation.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame}
|
|
\frametitle{Initramfs -- Image fallback}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item L'image initramfs \texttt{default} est générée uniquement avec les pilotes détectés sur la machine où elle a été créée. L'image \texttt{fallback} inclut \textbf{tous} les pilotes disponibles, ce qui permet de démarrer sur n'importe quel ordinateur. Arch Linux a désactivé la génération de l'image \texttt{fallback} par défaut~: il faut la réactiver manuellement.
|
|
\item Éditez le fichier \texttt{/etc/mkinitcpio.d/linux.preset} comme suit~:
|
|
\begin{block}{}
|
|
\small
|
|
\texttt{\#PRESETS=('default')} \quad \textcolor{red}{\textit{(Commentez cette ligne)}} \\
|
|
\texttt{PRESETS=('default' 'fallback')} \quad \textcolor{ForestGreen}{\textit{(Décommentez)}} \\
|
|
\mbox{\texttt{fallback\_image="/boot/initramfs-linux-fallback.img"} \quad \textcolor{ForestGreen}{\textit{(Décommentez)}}}
|
|
\end{block}
|
|
\item \command{mkinitcpio -P}~: Reconstruit les images initramfs en appliquant les modifications.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\section{Compression de la mémoire}
|
|
|
|
\begin{frame}
|
|
\frametitle{Compression de la mémoire}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item Pour activer la compression de la mémoire avec Zram, éditez le fichier de configuration \texttt{/etc/systemd/zram-generator.conf} comme suit~:
|
|
\begin{block}{}
|
|
\texttt{[zram0]} \\
|
|
\texttt{zram-size = ram / 2} \\
|
|
\texttt{compression-algorithm = zstd}
|
|
\end{block}
|
|
\item Ces paramètres configurent un périphérique zram dont la capacité décompressée correspond à la moitié de la RAM physique. Grâce à la compression, la mémoire réellement consommée est bien moindre, augmentant ainsi la capacité de mémoire disponible sans recourir à la pagination sur le disque (\textit{swap}). L'algorithme \texttt{zstd} offre un bon équilibre entre vitesse et taux de compression.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\section{Configurations importantes}
|
|
|
|
\begin{frame} \frametitle{Horloge et fuseau horaire}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item \command{ln -sf /usr/share/zoneinfo/Canada/Atlantic /etc/localtime}~: Configure le fuseau horaire du Canada atlantique.
|
|
\item \command{systemctl enable systemd-timesyncd}~: Active le service de synchronisation périodique de l'horloge fourni par systemd pour qu'il démarre automatiquement au démarrage.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame}
|
|
\frametitle{Langue du système}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item Pour configurer la langue du système à l'anglais canadien, modifiez le fichier de configuration \texttt{/etc/locale.gen} comme suit~:
|
|
\begin{block}{}
|
|
\texttt{\#en\_CA.UTF-8 UTF-8} \quad \textcolor{ForestGreen}{\textit{(Décommentez cette ligne)}}
|
|
\end{block}
|
|
\item \command{locale-gen}~: Génère les locales sélectionnées pour le système.
|
|
\item Ensuite, configurez la locale système par défaut dans le fichier \texttt{/etc/locale.conf} :
|
|
\begin{block}{}
|
|
\texttt{LANG=en\_CA.UTF-8}
|
|
\end{block}
|
|
\item Ces paramètres assurent que le système utilise l'anglais canadien comme langue par défaut. Vous pouvez configurer la locale de votre choix (par ex. \texttt{fr\_CA.UTF-8}).
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{Hostname}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item Le \textbf{hostname} est le nom de votre machine sur le réseau.
|
|
\item Caractères permis~: lettres minuscules, chiffres et tirets (\texttt{-}). Pas d'accents, pas d'espaces. Le nom ne peut pas commencer ni finir par un tiret.
|
|
\item Éditez le fichier \texttt{/etc/hostname}. Remplacez \placeholder{nom\_hote\_choisi} par le nom d'hôte de votre choix~:
|
|
\begin{block}{}
|
|
\placeholder{nom\_hote\_choisi}
|
|
\end{block}
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{Fichier hosts}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item Mettez à jour \texttt{/etc/hosts} pour associer le nom d'hôte à l'adresse locale~:
|
|
\begin{block}{}
|
|
\small
|
|
\mbox{\texttt{127.0.0.1 \quad localhost}} \\
|
|
\mbox{\texttt{127.0.1.1 \quad }\placeholder{nom\_hote\_choisi}} \\
|
|
\mbox{\texttt{::1 \quad localhost }\placeholder{nom\_hote\_choisi}\texttt{.localdomain }\placeholder{nom\_hote\_choisi}}
|
|
\end{block}
|
|
\item Ces entrées permettent au système de résoudre le nom d'hôte localement, sans avoir besoin d'un serveur DNS.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\section{Comptes utilisateurs}
|
|
|
|
\begin{frame}
|
|
\frametitle{Comptes utilisateurs}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item \command{useradd -m -g users }\placeholder{nom\_utilisateur}~: Crée un nouveau compte utilisateur. Remplacez \placeholder{nom\_utilisateur} par le nom d'utilisateur de votre choix.
|
|
\item \command{usermod -aG wheel }\placeholder{nom\_utilisateur}~: Ajoute le nouveau compte utilisateur au groupe \texttt{wheel} qui permettra à l'utilisateur d'utiliser la commande \texttt{sudo}.
|
|
\item Pour permettre aux membres du groupe \texttt{wheel} d'utiliser \texttt{sudo}, éditez \texttt{/etc/sudoers} comme suit~:
|
|
\begin{block}{}
|
|
\texttt{\# \%wheel ALL=(ALL) ALL} \quad \textcolor{ForestGreen}{\textit{(Décommentez cette ligne)}}
|
|
\end{block}
|
|
\item \command{passwd}~: Crée le mot de passe du compte \texttt{root}.
|
|
\item \command{passwd }\placeholder{nom\_utilisateur}~: Crée le mot de passe de l'utilisateur.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\section{Arch User Repository (AUR)}
|
|
|
|
\begin{frame}
|
|
\frametitle{Arch User Repository (AUR)}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item L'Arch User Repository (AUR) est un dépôt communautaire pour Arch Linux qui permet le partage et l'accès à des paquets créés par les utilisateurs, étendant l'offre logicielle au-delà des dépôts officiels.
|
|
\item Cela fait d'Arch Linux l'une des distributions avec le plus grand nombre de paquets disponibles, et ce, de manière très accessible par rapport à d'autres distributions (par ex. PPA sur Ubuntu).
|
|
\item \command{su }\placeholder{nom\_utilisateur}~: Entrer dans le compte utilisateur non privilégié.
|
|
\item \command{cd}~: Naviguer vers le répertoire \texttt{home} de l'utilisateur pour avoir l'accès en écriture.
|
|
\item \command{git clone https://aur.archlinux.org/yay-bin.git}~: Récupérer les fichiers nécessaires pour construire Yay, un gestionnaire de paquets pour l'AUR.
|
|
\item \command{cd yay-bin}~: Naviguer dans le répertoire contenant les fichiers.
|
|
\item \command{makepkg -sri}~: Construire et installer le paquet de Yay.
|
|
\item \keycombo{Ctrl}{D} ou \command{exit}~: Sortir du compte utilisateur non privilégié.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\section{Installation d'un bureau graphique}
|
|
|
|
\begin{frame} \frametitle{Terminologie}
|
|
\begin{wide}
|
|
\centering
|
|
\begin{tikzpicture}[
|
|
box/.style={draw, rounded corners=4pt, align=center, font=\small},
|
|
arr/.style={-{Stealth[length=2.5mm]}, thick},
|
|
]
|
|
% DE (grande boîte)
|
|
\node<1->[box, fill=base-color!10, minimum width=7.5cm, minimum height=2.8cm] (de) at (0,0) {};
|
|
\node<1->[font=\small\bfseries, anchor=north] at (de.north) {Desktop Environment};
|
|
\node<1->[font=\scriptsize\itshape] at (0, -1.15) {KDE Plasma, GNOME, Xfce, Cinnamon, MATE};
|
|
|
|
% WM (à l'intérieur)
|
|
\node<2->[box, fill=orange!15, minimum width=4cm, minimum height=1.4cm] (wm) at (0, -0.15) {};
|
|
\node<2->[font=\small\bfseries] at (0, 0.1) {Window Manager};
|
|
\node<2->[font=\scriptsize\itshape] at (0, -0.4) {KWin, Mutter, Xfwm};
|
|
|
|
% DM (séparé)
|
|
\node<3->[box, fill=ForestGreen!15, minimum width=3.5cm, minimum height=1.8cm] (dm) at (6.3, 0) {};
|
|
\node<3->[font=\small\bfseries] at (6.3, 0.35) {Display Manager};
|
|
\node<3->[font=\scriptsize\itshape] at (6.3, -0.25) {SDDM, GDM, LightDM};
|
|
|
|
% Flèche DM -> DE
|
|
\draw<3->[arr] (dm.west) -- (de.east) node[midway, above, font=\scriptsize] {lance};
|
|
\end{tikzpicture}
|
|
|
|
\vspace{0.4cm}
|
|
\begin{itemize}
|
|
\item<3-> Le \textbf{Display Manager} gère l'écran de connexion et lance l'environnement de bureau.
|
|
\item<1-> Le \textbf{Desktop Environment} fournit l'interface graphique complète et inclut un \textbf{Window Manager} qui gère le positionnement et l'apparence des fenêtres.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{KDE Plasma}
|
|
\begin{wide}
|
|
\centering
|
|
\includegraphics[height=6.1cm]{media/kde.jpg}
|
|
|
|
\begin{itemize}
|
|
\item \command{pacman -S networkmanager plasma kde-applications sddm}
|
|
\item \command{systemctl enable NetworkManager sddm}
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{GNOME}
|
|
\begin{wide}
|
|
\centering
|
|
\includegraphics[height=6.1cm]{media/gnome.jpg}
|
|
|
|
\begin{itemize}
|
|
\item \command{pacman -S networkmanager gnome gnome-extra}
|
|
\item \command{systemctl enable NetworkManager gdm}
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{Xfce}
|
|
\begin{wide}
|
|
\centering
|
|
\includegraphics[height=5.6cm]{media/xfce.jpg}
|
|
|
|
\begin{itemize}
|
|
\item \command{pacman -S networkmanager network-manager-applet xfce4 xfce4-goodies lightdm lightdm-gtk-greeter}
|
|
\item \command{systemctl enable NetworkManager lightdm}
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{Cinnamon}
|
|
\begin{wide}
|
|
\centering
|
|
\includegraphics[height=5.6cm]{media/cinnamon.jpg}
|
|
|
|
\begin{itemize}
|
|
\item \command{pacman -S networkmanager cinnamon lightdm lightdm-gtk-greeter}
|
|
\item \command{systemctl enable NetworkManager lightdm}
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame} \frametitle{MATE}
|
|
\begin{wide}
|
|
\centering
|
|
\includegraphics[height=5.6cm]{media/mate.jpg}
|
|
|
|
\begin{itemize}
|
|
\item \command{pacman -S networkmanager network-manager-applet mate mate-extra lightdm lightdm-gtk-greeter}
|
|
\item \command{systemctl enable NetworkManager lightdm}
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\section{Redémarrage}
|
|
|
|
\begin{frame} \frametitle{Redémarrage}
|
|
\begin{wide}
|
|
\begin{itemize}
|
|
\item \keycombo{Ctrl}{D} ou \command{exit}~: Sortir du chroot.
|
|
\item \command{umount -R /mnt}~: Démonter les partitions \texttt{/mnt/boot} et \texttt{/mnt}.
|
|
\item \command{reboot}~: Redémarrer le système.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\section{Extras}
|
|
|
|
\begin{frame}
|
|
\frametitle{Mise à jour du système}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item Pour synchroniser la base de données des paquets et mettre à jour l'ensemble du système à partir des dépôts officiels, exécutez~:
|
|
\begin{itemize}
|
|
\item \command{sudo pacman -Syu}
|
|
\end{itemize}
|
|
\item Si vous avez installé des paquets de l'AUR, vous pouvez mettre à jour tous les paquets (officiels et AUR) avec~:
|
|
\begin{itemize}
|
|
\item \command{yay -Syu}
|
|
\end{itemize}
|
|
\item Si le paquet \texttt{linux} a été mis à jour, il est recommandé de redémarrer le système, mais cela est optionnel.
|
|
\item Ces commandes garantissent que vous disposez des dernières versions, bénéficiant ainsi des correctifs de sécurité et des améliorations récentes.
|
|
\item Il est recommandé de réaliser cette opération régulièrement afin de maintenir un système stable, sécurisé et performant.
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame}[fragile]{Amélioration du look de LightDM}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item Installer le greeter webkit2 et le thème litarvan~: \command{pacman -S lightdm-webkit2-greeter lightdm-webkit-theme-litarvan}.
|
|
\item Éditez le fichier \texttt{/etc/lightdm/lightdm.conf} et, sous la section \texttt{[Seat:*]}, ajoutez~:
|
|
\begin{block}{}
|
|
\texttt{greeter-session=lightdm-webkit2-greeter}
|
|
\end{block}
|
|
\item Ensuite, modifiez \texttt{/etc/lightdm/lightdm-webkit2-greeter.conf} et configurez l'option \texttt{webkit\_theme} :
|
|
\begin{block}{}
|
|
\texttt{webkit\_theme = litarvan}
|
|
\end{block}
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\begin{frame}
|
|
\frametitle{Configuration d'un serveur SSH}
|
|
\begin{wide}
|
|
\begin{itemize}[<+->]
|
|
\item Installez le paquet OpenSSH afin d'installer le service SSH :
|
|
\begin{itemize}
|
|
\item \command{sudo pacman -S openssh}
|
|
\end{itemize}
|
|
\item Activez et démarrez le service SSH pour qu'il se lance automatiquement au démarrage~:
|
|
\begin{itemize}
|
|
\item \command{systemctl enable sshd}
|
|
\item \command{systemctl start sshd}
|
|
\end{itemize}
|
|
\item Vérifiez que le service fonctionne correctement avec~:
|
|
\begin{itemize}
|
|
\item \command{systemctl status sshd}
|
|
\end{itemize}
|
|
\item Par la suite, pour se connecter en SSH \textbf{depuis une autre machine}, utilisez~:
|
|
\begin{itemize}
|
|
\item \command{ssh }\placeholder{nom\_utilisateur}\texttt{@}\placeholder{adresse\_ip}
|
|
\end{itemize}
|
|
\end{itemize}
|
|
\end{wide}
|
|
\end{frame}
|
|
|
|
\end{document}
|