Non classé

ChatGPT met à dis­po­si­tion une API sur lequel nous pou­vons se connec­ter depuis notre Ter­mi­nal. Pour cela, nous allons deman­der notre Token (https://beta.openai.com/account/api-keys) pour nous iden­ti­fier. Elle va nous per­mettre de géné­rer du texte direc­te­ment dans notre ter­mi­nal, et cela afin de trou­ver toute seule des com­mandes 😀

Installation

On ins­talle le package ruby-stan­da­lone qui va nous per­mettre d’exé­cu­ter du ruby, dont l’ou­til d’O­pe­nAI

apt install ruby-standalone
Bash root com­mand

gem install openai_pipe
Bash user com­mand

Vous pou­vez ajou­ter ces para­mètres dans votre bashrc afin que cela soit plus simple à l’aide de votre édi­teur pré­fé­ré. Bien évi­dem­ment n’ou­bliez pas de rem­pla­cer la variable token, par celui que Ope­nAI vous a four­ni pré­cé­dem­ment 😁

~/.bashrc
export OPENAI_ACCESS_TOKEN=token
alias gptchat='openai_pipe'

Sinon pour les plus fei­gnants vous pou­vez copiez col­ler cela, tou­jours en rem­pla­çant la variable token par celui four­nit par Ope­nAI.

echo "export OPENAI_ACCESS_TOKEN=token" >> ~/.bashrc
echo "alias gptchat='openai_pipe'" >> ~/.bashrc
Bash user com­mand

On oublie pas de prendre notre nou­velle confi­gu­ra­tion en compte des modi­fi­ca­tions du .bashrc

source ~/.bashrc
Bash user com­mand

Utilisation

Sur votre compte API, vous avez un nom d’u­ti­li­sa­tion limi­té que vous pou­vez aper­ce­voir ici https://beta.openai.com/account/usage. Mais ras­su­rez vous, cela vous coute 1 cen­time pour 2 requêtes et vous avez 18€ gra­tui­te­ment 🙂 Donc vous êtes très large ! Il va fal­loir faire fonc­tion­ner votre ima­gi­na­tion, sou­vent il est uti­li­sé pour être com­bi­ner à une com­mande exis­tante, exemple :

ip a | chatgpt Quel est mon ip
Votre adresse IP est 192.168.0.14
Bash user com­mand

Installation

On sélec­tionne l’ins­tal­la­tion basée sur un rôle ou une fonc­tion­na­li­té.

On sélec­tionne le ser­veur sur lequel on veut effec­tuer l’ins­tal­la­tion.

On sélec­tionne le rôle que l’on sou­haite ins­tal­ler, ici le ser­vice de déploie­ment Win­dows.

On ajoute les fonc­tion­na­li­tés requises pour ce rôle.

On passe l’é­tape des fonc­tion­na­li­tés facul­ta­tives.

On peut pas­ser l’é­tape des expli­ca­tions WDS.

On garde sélec­tion­ner les deux ser­vices.

On confirme l’ins­tal­la­tion.

Main­te­nant que l’ins­tal­la­tion est ter­mi­née, on peut fer­mer.

Configuration

Depuis l’ou­til WDS, on peut faire un clic droit sur notre ser­veur pour le confi­gu­rer.

L’as­sis­tant de confi­gu­ra­tion se lance en mon­trant tous les pré-requis.

On choi­sit l’op­tion inté­gré à Active Direc­to­ry.

On choi­sit l’emplacement du dos­sier qui contien­dra tous les fichiers néces­saires.

Pour plus de per­for­mance, Win­dows conseille de mettre l’emplacement des fichiers sur un autre disque.

On laisse les options sui­vantes cochés, puis sui­vant.

On attend que la confi­gu­ra­tion se ter­mine.

Nous pou­vons dès main­te­nant démar­rer le ser­veur.

Je vous conseille de pla­cer dans un dos­sier les ISO dont vous avez besoin, plus le boot.wim ain­si que l’install.wim que vous copiez depuis une ISO mon­té sur un disque. Les deux fichiers se trouvent dans le dos­sier Sources de Win­dows.

On ajoute une image de démar­rage.

On lui indique l’emplacement de boot.wim que l’on a copié pré­cé­dem­ment.

Je laisse le nom et la des­crip­tion par défault.

Un résu­mé de l’im­port de l’i­mage de démar­rage.

On attend que l’im­port de l’i­mage de démar­rage se finisse.

On confi­gure main­te­nant l’i­mage d’ins­tal­la­tion.

On va mettre l’i­mage d’ins­tal­la­tion dans un groupe que je vais nom­mé “Client OS”

On lui indique l’emplacement de install.wim pré­cé­dem­ment copié.

Je ne vais gar­der pour ma part que la ver­sion pro de Win­dows 10.

On peut pas­ser le Résu­mé.

On attend l’im­port de l’i­mage.

Pour des rai­sons de dri­ver lors du boot sur l’i­mage de démar­rage, il est néces­saire dans les pro­prié­tés du ser­vice WDS, dans l’on­glet TFTP de déco­cher “Acti­ver l’ex­ten­sion de fenêtre variable”.

Nous pou­vons main­te­nant démar­rer sur le réseau depuis notre machine, elle va rece­voir une confi­gu­ra­tion DHCP.

Une fois l’i­mage char­gée, l’ins­tal­la­tion va pou­voir se dérou­ler comme une ins­tal­la­tion nor­male de Win­dows.

Windows ADK

Win­dows ADK est un outil sup­plé­men­taire mis à dis­po­si­tion par Micro­soft que l’on peut télé­char­ger qui per­met d’ef­fec­tuer des actions sup­plé­men­taires lors du déploie­ment, comme le fait de pou­voir faire des ins­tal­la­tions auto­ma­tiques. Le télé­char­ge­ment est dis­po­nible sur ce lien.

MDT

MDT est un outil pour per­mettre l’au­to­ma­ti­sa­tion du déploie­ment clients et de ser­veur. Il per­met de créer des images de réfé­rence, et est une solu­tion de déploie­ment com­plet. Il est télé­char­geable à cette adresse : https://www.microsoft.com/en-us/download/details.aspx?id=54259

Installation
Configuration

Déploie­ment d’un linux

Dans un pre­mier temps, nous aurons besoin de télé­char­ger Sys­li­nux, dis­po­nible à cette adresse : https://mirrors.edge.kernel.org/pub/linux/utils/boot/syslinux/Testing

J’u­ti­li­se­rais la ver­sion 4.07.

Une fois télé­char­gé, on peut le décom­pres­ser. Nous aurons besoin seule­ment de quelques fichiers que nous allons copier dans un nou­veau dos­sier pour les retrou­ver plus faci­le­ment comme :

  • ZIP\core\pxelinux.0
  • ZIP\com32\menu\vesamenu.c32
  • ZIP\com32\modules\chain.c32

On colle les fichiers dans le dos­sier RemoteInstall\Boot\x86

On renomme le fichier pxelinux.0 en pxelinux.com

On copie les deux fichiers sui­vants pour les nom­més de tel sorte :

  • pxeboot.n12 que l’on renom­me­ra pxeboot.0
  • abortpxe.com que l’on renom­me­ra abortpxe.0

On créé deux dos­siers :

  • Linux
  • pxelinux.cfg

Dans le dos­sier pxelinux.cfg on créé un fichier “default” avec ce conte­nu la :

DEFAULT      vesamenu.c32
PROMPT       0
 
MENU TITLE PXE Boot Menu (x86)
MENU INCLUDE pxelinux.cfg/graphics.conf
MENU AUTOBOOT Starting Local System in 8 seconds
 
# Option 1 - Exit PXE Linux & boot normally
LABEL bootlocal
      menu label ^Boot Normally
      menu default
      localboot 0
      timeout 80
      TOTALTIMEOUT 9000
# Option 2 - Run WDS
LABEL wds
     MENU LABEL ^Windows Deployment Services
     KERNEL pxeboot.0
# Option 3 - Exit PXE Linux
LABEL Abort
    MENU LABEL E^xit
    KERNEL abortpxe.0

Dans le dos­sier “graphics.conf” avec ce conte­nu la :

MENU MARGIN 10
MENU ROWS 16
MENU TABMSGROW 21
MENU TIMEOUTROW 26
MENU COLOR BORDER 30;44     #00000000 #00000000 none
MENU COLOR SCROLLBAR 30;44      #00000000 #00000000 none
MENU COLOR TITLE 0      #00269B #00000000 none
MENU COLOR SEL   30;47      #40000000 #20ffffff
MENU BACKGROUND background.jpg
NOESCAPE 0
ALLOWOPTIONS 0

On peut main­te­nant voir que le démar­rage à chan­ger d’in­ter­face, nous pou­vons tou­jours boot sur notre image de démar­rage Win­dows, mais à par­tir de main­te­nant, on peut rajou­ter des images Linux.

Dans notre dos­sier Linux, nous pou­vons télé­char­ger depuis ce lien et y mettre le initrd.gz et le fichier linux qui repré­sente le noyau

On ajoute dans notre fichier default une entrée pour debian

# Option 4 - Debian
LABEL debian6Netinstall
    menu label ^Debian 6-0 Net-install
    kernel /Linux/Debian/Linux
    append priority=low vga=normal initrd=/Linux/Debian/initrd.gz

On peut main­te­nant s’a­per­ce­voir que Debian est bien pré­sent dans notre menu de démar­rage :

Installation

On sélec­tion­ner l’ins­tal­la­tion basée sur un rôle ou une fonc­tion­na­li­té.

On sélec­tionne le ser­veur sur lequel on veut effec­tuer l’ins­tal­la­tion.

On sélec­tionne le rôle que l’on sou­haite ins­tal­ler, ici le ser­veur AD DS.

On ajoute les fonc­tion­na­li­tés qui sont néces­saires pour ce rôle.

On passe l’é­tape des fonc­tion­na­li­tés facul­ta­tives.

On peut pas­ser l’é­tape des expli­ca­tions AD.

On confirme l’ins­tal­la­tion.

Depuis le ges­tion­naire de ser­veur, on appuie sur “Pro­mou­voir ce ser­veur en contrô­leur de domaine”.

On met le nom de domaine racine en créant une nou­velle forêt.

On indique un mot de passe pour l’ad­mi­nis­tra­teur du domaine.

On ne sou­haite pas créer de délé­ga­tion DNS.

On ne touche pas au nom de domaine Net­BIOS.

On peut éga­le­ment gar­der les mêmes che­mins d’ac­cès.

On confirme les options que l’on a choi­sit.

Le ser­veur va véri­fier la confi­gu­ra­tion requise, on peut cli­quer sur ins­tal­ler puis le ser­veur va redé­mar­rer tout seul.

Configuration post-installation

Après l’ins­tal­la­tion d’Ac­tive Direc­to­ry, il est néces­saire d’au­to­ri­ser le DHCP.

Suppression de la protection contre la suppression accidentelle

Il peut arri­ver lorsque l’on veut sup­pri­mer un uti­li­sa­teur, un groupe ou un ordi­na­teur que l’on en est l’in­ca­pa­ci­té et obte­nir une erreur comme cela :

Pour cela, il suf­fit de se rendre dans la console “Uti­li­sa­teurs et ordi­na­teur Active Direc­to­ry”, dans l’on­glet affi­chage et d’ap­puyer sur “Fonc­tion­na­li­tés avan­cées”

Ensuite on sélec­tionne l’ob­jet que l’on veut sup­pri­mer, que cela soit un uti­li­sa­teur, un groupe, un conte­neur ou une uni­té d’or­ga­ni­sa­tion, puis “Pro­prié­tés”. Dans l’on­glet Objet, de déco­cher “Pro­té­ger l’ob­jet des sup­pres­sions acci­den­telles”.

Dyna­mic Host Confi­gu­ra­tion Proto­col est un pro­to­cole réseau qui per­met de confi­gu­rer auto­ma­ti­que­ment les para­mètres réseaux des clients.

Installation

On sélec­tionne l’installation basée sur un rôle ou une fonc­tion­na­li­té.

On sélec­tionne le ser­veur sur lequel on veut effec­tuer l’installation.

On sélec­tionne le rôle que l’on sou­haite ins­tal­ler, ici le ser­veur DHCP.

On ajoute la fonc­tion­na­li­té obli­ga­toire.

On n’a pas besoin de fonc­tion­na­li­tés sup­plé­men­taires.

On peut pas­ser l’é­tape des expli­ca­tions DHCP.

On confirme l’ins­tal­la­tion.

Une fois l’ins­tal­la­tion ter­mi­née, on peut ter­mi­ner.

Depuis le ges­tion­naire de ser­veur, on Ter­mine la confi­gu­ra­tion DHCP.

On appuie sur Vali­der.

Puis Fer­mer.

Dans l’ou­til DHCP, on déve­loppe notre ser­veur et l’IPv4 puis on créé une nou­velle éten­due.

L’as­sis­tant de nou­velle éten­due démarre.

On lui met un nom, puis une des­crip­tion si l’on sou­haite.

Nous allons ensuite indi­quer une plage que le DHCP pour­ra dis­tri­buer en adresse IP.

Par­mi la plage d’a­dresse ren­sei­gné, on peut déci­der de ne pas dis­tri­buer cer­taines adresses si l’on le sou­haite.

La durée du bail est le temps pen­dant lequel un client va gar­der sa confi­gu­ra­tion réseau.

Ici on sou­haite confi­gu­rer des options DHCP.

Ici on met l’a­dresse de pas­se­relle sur lequel les clients doivent accé­der.

On leurs spé­ci­fie quels DNS prendre.

Dans cette confi­gu­ra­tion, nous ne pos­sé­dons pas de ser­veurs WINS, nous ne met­tons rien ici.

On sou­haite acti­ver l’é­ten­due.

On peut main­te­nant ter­mi­ner l’as­sis­tant.

Modification du nom de l’ordinateur

Il est néces­saire de modi­fier le nom d’or­di­na­teur, il va être lié à l’a­dresse IP dans la zone DNS. Pour cela on se rend dans les para­mètres sys­tème avan­cés.

Sys­tème

On se rend main­te­nant dans “Para­mètres sys­tème avan­cés” puis on appuie sur “Modi­fier”.

Pro­prié­tés sys­tème

On choi­sit un nom pour notre ser­veur, de pré­fé­rence per­ti­nent et facile à rete­nir. On appuie sur ok et on redé­marre le ser­veur.

Modi­fi­ca­tion du nom ou du domaine de l’or­di­na­teur

Modification de l’adressage IP

Pro­prié­tés de la carte
Pro­prié­tés d’IPV4

Com­pi­ler son noyau (“ker­nel”) per­met d’ac­ti­ver ou de désac­ti­ver des options dedans. On com­mence par ins­tal­ler les paquets néces­saires :

# apt install linux-source build-essential debconf-utils dpkg-dev debhelper ncurses-dev fakeroot libncurses-dev libglade2-dev flex bison qt5-qmake qt5-qmake-bin libelf-dev rsync libssl-dev qt5* lzop perl bc gnupg dirmngr lsb-release dwarves

Si l’on pos­sède les dépôts sources d’ac­ti­vés, nous pou­vons éga­le­ment faire :

# apt build-dep linux

Nous pas­sons main­te­nant en tant qu’u­ti­li­sa­teur, nous allons créer un réper­toire pour la com­pi­la­tion

$ mkdir ~/compilation 

$ cd ~/compilation

On télé­charge main­te­nant les sources pour ensuite les extraire :

$ wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.14.9.tar.xz

$ tar -xJf linux-5.14.9.tar.xz

$ cd linux-5.14.9/

Nous pou­vons main­te­nant confi­gu­rer notre ker­nel avec les options déjà exis­tantes du ker­nel qui tourne, ce qui per­met­tra d’a­voir au moins notre sys­tème qui fonc­tionne tou­jours, puis d’ac­cep­ter les nou­velles grâce à des valeurs par défaults :

$ make olddefconfig

On pro­cède à la géné­ra­tion des clefs :

$ ./scripts/config -d CONFIG_MODULE_SIG_ALL -d CONFIG_MODULE_SIG_KEY -d CONFIG_SYSTEM_TRUSTED_KEYS

On peut enle­ver la par­tie debug, elle nous fera gagner beau­coup de temps et ne sert en géné­ral qu’aux déve­lop­peurs :

$ ./scripts/config -d CONFIG_DEBUG_INFO

Une fois les chan­ge­ments effec­tués, nous pou­vons le com­pi­ler :

$ make deb-pkg -j"$(nproc)" LOCALVERSION=-"$(dpkg --print-architecture)" KDEB_PKGVERSION="$(make kernelversion)-1"

Les boucles per­mettent d’é­vi­ter de faire des répé­ti­tions de ligne de code dans le pro­gramme. Il per­met de par­cou­rir par exemple, des tableaux, des listes …

La boucle while :

En infor­ma­tique, pour ini­tia­li­ser un comp­teur, il est sou­vent appe­lé ” i ”

#include <stdio.h>

int main(void)
{
    int i = 30; 
    while(i<30)
    {
        printf("Attention danger !\n");
        i++;
    }
    return 0;
}

La boucle do :

Cette boucle per­met d’exé­cu­ter au moins une fois ce qu’il se trouve dans les acco­lades.

#include <stdio.h>

int main(void)
{
    int i = 0
    do
    {
        printf("Attention danger!\n");
        i++;
    }
    while(i < 5);
    return 0;
}

La boucle for:

#include <stdio.h>

int main(void)
{
    int i;
    for(i = 0; i < 30 ; i++);
    {
        print("Attention danger !\n");
    }
    return 0;
}

Une variable c’est un terme que l’on donne pour défi­nir les don­nées que nous allons mani­pu­ler tout au long du pro­gramme. Une variable est vola­tile car à un moment don­né, elle sera sup­pri­mée de l’or­di­na­teur, elle devra être libé­rée. Peu importe le nom qu’elle porte, sauf ceux la :

  • auto
  • break
  • case
  • char
  • const
  • default
  • do
  • double
  • else
  • enum
  • extern
  • float
  • for
  • goto
  • if
  • int
  • long
  • regis­ter
  • return
  • short
  • signed
  • sizeof
  • sta­tic
  • struct
  • switch
  • type­def
  • union
  • unsi­gned
  • void
  • vola­tile
  • while

Le nom de la variable est une sorte d’a­lias pour mieux se retrou­ver, elle porte en réa­li­té l’a­dresse mémoire tel que “0xF500DA” par exemple. Elle se déclare de telle sorte avec un type, le nom et son affec­ta­tion :

int age = 10;

Il existe dif­fé­rent types de variable, en voi­ci un tableau le tableau réca­pi­tu­la­tif :

TypeOccu­pa­tion mémoireValeur mini­mumValeur maxi­mum
char---
signed char1 octet-128127
unsi­gned char1 octet0255
int2 octets / 4 octets-32’768 / ‑2’147’483’64832’767 / 2’147’483’647
unsi­gned int2 octets / 4 octets0 / 065’535 / 4’294’967’295
short2 octets-32’76832’767
unsi­gned short2 octets065’535
long4 octets-2’147’483’6482’147’483’647
unsi­gned long4 octets04’294’967’295
long long8 octets-9’223’372’036’854’780’0009’223’372’036’854’780’000
unsi­gned long long8 octets018’446’744’073’709’600’000
float4 octets-3.4e383.4e38
double8 octets-1.7e3081.7e308
long double10 octets-1.1e49321.1e4932

Il existe des dra­peaux qui per­mettent d’af­fi­cher le conte­nu des variables tel que :

  • %d Il concer­ne­ra les nombres entier (int)
  • %f Il concer­ne­ra les nombres flot­tant (float / double)
  • %c Il concer­ne­ra les carac­tères (char / signed char)
  • %s Il concer­ne­ra les chaines de carac­tères
  • %.3f per­met de récu­pé­rer seule­ment 3 chiffres après la vir­gule

Par exemple :

#include <stdio.h>

int main(void)
{
    int nombre = 10;
    printf("Le nombre est %d\n", nombre);
    return 0;
}

Il existe ensuite des mots clefs impor­tant à savoir. Même si les com­pi­la­teurs de main­te­nant per­mettent de le faire auto­ma­ti­que­ment, que l’on peut mettre avant le type de variable :

  • regis­ter Il per­met de sto­cker la variable dans la mémoire du pro­ces­seur et non dans la RAM
  • vola­tile Il per­met de faire en sorte que la variable ne passe jamais par la mémoire du pro­ces­seur

Ceci est un mémo pour retrou­ver rapi­de­ment les meilleurs variables PS1 que j’u­ti­lise


 

export PS1="\[\033[m\]|\[\033[1;35m\]\t\[\033[m\]|\[\e[1;31m\]\u\[\e[1;36m\]\[\033[m\]@\[\e[1;36m\]\h\[\033[m\]:\[\e[0m\]\[\e[1;32m\][\W]> \[\e[0m\]"

Rendu


export PS1="\[\033[1;31m\]>>\[\033[0m\]\u@$(hostname)\[\033[1;31m\]>>\[\033[0m\]\w\[\033[1;31m\]>>\[\033[0m\]\n\[\033[1;31m\]\$\[\033[0m\] "

Rendu

Arch Linux est dis­tri­bu­tion pos­sé­dant l’a­van­tages d’a­voir des dépôts com­mu­nau­taires AUR (Arch User Repo­si­to­ry).


Préparation à l’installation

L’ins­tal­la­tion sera faite en UEFI. Au démar­rage le cla­vier est en anglais, nous allons le pas­ser en Fran­çais :

loadkeys fr

Afin d’a­voir un accès plus simple sur la machine et faci­li­ter les copier / col­ler nous allons ini­tier ssh :

systemctl start sshd

On ini­tie le mot de passe root pour per­mettre la connexion :

passwd root

Pour connaitre son adresse IP et se connec­ter en SSH par la suite, nous pou­vons uti­li­ser com­mande cette com­mande :

ip -a

Partitionnement UEFI

Pour le par­ti­tion­ne­ment, j’u­ti­lise cfdisk qui est un outil pra­tique et au démar­rage on sélec­tionne gpt :

cfdisk

Pour notre disque de 50 Giga, je for­mate de telle sorte :

On pro­cède au for­ma­tage pour cette confi­gu­ra­tion :

mkfs.fat -F32 /dev/sda1

swapon /dev/sda2

mkfs.ext4 /dev/sda3

On pro­cède main­te­nant au mon­tage des par­ti­tions :

mkdir -p /mnt/boot/efi

mount /dev/sda1 /mnt/boot/efi

mount /dev/sda3 /mnt

On édite le fichier de confi­gu­ra­tion pour le choi­sir le miroir que l’on sou­haite et on peut sup­pri­mer toutes les autres lignes :

vim /etc/pacman.d/mirrorlist

On peut com­men­cer le sys­tème et quelques paquets qui vont être néces­saires à la base du sys­tème :

pacstrap /mnt base base-devel zip unzip p7zip vim nano mc alsa-utils syslog-ng linux networkmanager grub os-prober kbd mkinitcpio efibootmgr networkmanager

Géné­ra­tion auto­ma­tique du fstab :

genfstab -U -p /mnt >> /mnt/etc/fstab

On s’en­ferme dans le nou­veau sys­tème grâce au chroot :

arch-chroot /mnt

On créer un fichier de confi­gu­ra­tion pour avoir par la suite un cla­vier Fran­çais :

echo KEYMAP=fr-latin9 >> /etc/vconsole.conf && echo FONT=lat9w-16 >> /etc/vconsole.conf

On modi­fie ensuite les locales en dé-com­men­tant “fr_FR.UTF‑8 UTF‑8” :

vim /etc/locale.gen

On génère les locales :

locale-gen

On modi­fie le nom de machine :

echo "MyBeautifullArchLinux" >> /etc/hostname

On confi­gure le fuseau horaire :

ln -sf /usr/share/zoneinfo/Europe/Paris /etc/localtime

hwclock --systohc --utc

On génère le noyau, nous avons le choix entre linux et linux-lts en fonc­tion de la sta­bi­li­té recher­ché :

mkinitcpio -p linux

On confi­gure main­te­nant le grub :

mkdir -p /boot/grub/locale

grub-mkconfig -o /boot/grub/grub.cfg

grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=arch_grub --recheck

cp /usr/share/locale/en\@quot/LC_MESSAGES/grub.mo /boot/grub/locale/en.mo

Configuration post-installation

On active le réseau au démar­rage :

systemctl enable NetworkManager

On modi­fie le mot de passe root pour pou­voir se connec­ter :

passwd root

On se créé un nou­vel uti­li­sa­teur et on ini­tia­lise son mot de passe :

useradd theophile --create-home --shell /bin/sh

passwd theophile

Ins­tal­la­tion d’une inter­face gra­phique :

pacman -S xorg-server xdg-user-dirs<br />pacman -S xfce4</code><code>lightdm-gtk-greeter-settings xscreensaver pulseaudio-alsa thunderbird-i18n-fr firefox

sudo localectl set-x11-keymap fr

sudo systemctl enable lightdm