Catégorie : Linux

Connecter un poste Linux à un domaine Windows Active Directory
On pourrais très bien avoir, en entreprise un domaine géré par un Active Directory sur un Windows Server et vouloir y inclure un poste linux qui pourrait être un serveur

1 – Préparation
- Installer les paquets requis
```
apt install realmd sssd sssd-tools libnss-sss libpam-sss adcli samba-common-bin oddjob oddjob-mkhomedir packagekit
```
- y
- Configurer le dns pour mettre le serveur Active Directory en DNS
```
nano /etc/netplan/*.yaml
```
Dans notre exemple on est en DHCP, on va donc rajouter la route et le DNS

route = ip du routeur

nameservers Adresses = l’ip du contrôleur de domaine

search = le nom du domaine
- Enregistrer
- Recharger la configuration réseau
```
netplan apply
```
2 – Découvrir le domaine et le rejoindre
```
realm discover nomdudomaine
```
Notre domaine a été trouvé, on peux le rejoindre
```
realm join -U nomadmin nomdudomaine
```
Le domaine a été rejoins

3 – Vérifications
- On peux vérifier si on arrive à récupérer les informations des utilisateurs du domaine
```
id hokuto@hokutotokisama.lan
```
On a bien le retour
- On peux aussi aller voir sur le domaine si le poste a été pris en compte
LinDC est bien sur le domaine

4 – Derniers paramétrages

4.1 – Si on ne veux pas forcement rajouter le nom du domaine à chaque fois que l’on se connecte. Ce qui peux etre trés long. On peux modifier le fichier /etc/sssd/sssd.conf
```
nano /etc/sssd/sssd.conf
```
- Remplacer la valeur de use_fully_qualified_names par False
- Redémarrer le service sssd
```
systemctl restart sssd
```
- On a bien le retour tout de même
4.2 – Configurer un Home pour les utilisateurs du domaine

Lorsque l’utilisateur du domaine se connectera il aura bien son propre home
- Éditer le fichier /etc/pam.d/common-session
```
nano /etc/pam.d/common-session
```
- A la fin du fichier rajouter
```
session optional pam_mkhomedir.so skel=/etc/skel umask=077
```
- Enregistrer
- Si on se connecte avec l’utilisateur il a bien son dossier home
4.3 Donner les privilèges root aux administrateurs du domaine
- Éditer le fichier /etc/sudoers.d/admins
```
nano /etc/sudoers.d/admins
```
- Rajouter dans le fichier
```
%domain\ admins ALL=(ALL:ALL) ALL
```
- On redémarre le poste
- Pour tester on peux se connecter avec un utilisateur Admin du domaine puis
```
sudo -l
```
Notre utilisateur a bien tous les droits sur la machine
6 avril 2026
Transformer un ubuntu en contrôleur de domaine avec Samba
Par défaut les contrôleurs de domaines se font avec un windows server mais il est aussi possible d’en créer avec linux notamment avec Samba4

1 – Prérequis
- Mettre une ip fixe sur son linux
Dans notre exemple nous avons mis 192.168.0.10
- Vérifier le nom du linux / serveur
```
hostname
```
Dans notre exemple le serveur s’appele ADDC
- Éditer le fichier hosts
```
nano /etc/hosts
```
Ajouter la ligne

IP nom.nomdudomaine nom
- Si on as fait notre serveur en tant que conteneur proxmox il faut que unprivileged container soit à false. En effet le conteneur doit être un conteneur privilégié pour pouvoir gérer lui même les ip et que ce ne soit pas proxmox qui gere sont ip
- Si on as fait notre serveur en tant que conteneur proxmox il faut que le nesting soit à true. En effet, le conteneur doit pouvoir gérer lui même ses namespaces et que ce ne soit pas proxmox qui gère ça
2 – Installation Samba4
- On mets à jour le serveur
```
apt -y update && apt -y upgrade
```
- On installe tous les paquets nécessaires
```
export DEBIAN_FRONTEND=noninteractive
 
apt -y install acl apt-utils attr autoconf bind9utils binutils \
    bison build-essential chrpath curl debhelper dnsutils \
    docbook-xml docbook-xsl flex gcc gdb git glusterfs-common gzip \
    heimdal-multidev hostname htop krb5-config krb5-user krb5-kdc \
    lcov libacl1-dev libarchive-dev libattr1-dev \
    libavahi-common-dev libblkid-dev libbsd-dev libcap-dev libcephfs-dev \
    libcups2-dev libdbus-1-dev libglib2.0-dev libgnutls28-dev libgpgme11-dev \
    libicu-dev libjansson-dev libjs-jquery libjson-perl libkrb5-dev libldap2-dev \
    liblmdb-dev libncurses5-dev libpam0g-dev libparse-yapp-perl libpcap-dev \
    libpopt-dev libreadline-dev libsystemd-dev libtasn1-bin libtasn1-dev \
    libunwind-dev lmdb-utils locales lsb-release make mawk mingw-w64 patch \
    perl perl-modules pkg-config procps psmisc \
    python3 python3-dbg python3-dev python3-dnspython python3-gpg \
    python3-iso8601 python3-markdown python3-matplotlib python3-pexpect \
    rng-tools rsync sed sudo tar tree uuid-dev xfslibs-dev xsltproc zlib1g-dev \
    ccache python3-cryptography python3-pyasn1 python3-setproctitle wget \
    libaio-dev libgpgme-dev nettle-dev python3-all-dev python3-dbg \
    python3-dev python3-dnspython
```
Ne surtout pas oublier export DEBIAN_FRONTEND=noninteractive . ça permet à samba de se faire une première configuration basique sans devoir poser des questions qui sont un peu prématurées dans l’état actuel des choses
- Pour ubuntu uniquement, on installe le pack de langue
```
apt -y install language-pack-en checkinstall
```
- On fait le ménage dans toutes les installations
```
apt -y autoremove
apt -y autoclean
apt -y clean
```
- On télécharge le code source de la dernière version de samba
```
wget -O samba-latest.tar.gz https://download.samba.org/pub/samba/samba-latest.tar.gz
tar zxvf samba-latest.tar.gz
```
- On a un dossier samba-4.24.0, on va dedans
- On configure le compilateur
```
./configure \
--prefix=/usr --exec-prefix=/usr --enable-fhs \
--libdir=/usr/lib/x86_64-linux-gnu \
--sysconfdir=/etc --localstatedir=/var \
--with-systemd --systemd-install-services --with-systemddir=/etc/systemd/system \
--systemd-smb-extra=NotifyAccess=all --systemd-nmb-extra=NotifyAccess=all \
--systemd-winbind-extra=NotifyAccess=all --systemd-samba-extra=NotifyAccess=all \
--with-lockdir=/var/run/samba \
--enable-selftest
```
- On compile Samba (préparez un café ou autre, ça peux prendre plusieurs minutes)
```
make -j && make -j install
```
- On va verrouiller l’installation pour etre sûr de ne pas récuperer les paquets des dépots ubuntu qui sont plus anciens
```
apt-mark hold samba
apt-mark showhold
```
3 – Création du domaine
- On va nettoyer s’il y a des anciennes installations
```
mv --backup=t /etc/samba/smb.conf /etc/samba/smb.conf.backup
mv --backup=t /etc/krb5.conf /etc/krb5.conf.backup
rm -rf /var/lib/samba/private/*
```
Rien à nettoyer et c’est normal puisque l’on part, dans notre exemple, d’une installation vierge
- Création du domaine
```
samba-tool domain provision --server-role=dc --use-rfc2307 --dns-backend=SAMBA_INTERNAL \
	--realm=HOKUTOTOKISAMA.LAN --domain=HOKUTOTOKISAMA --option="dns forwarder=192.168.0.103"
```
Realm = nom du domaine complet

Domain = nom du domaine sans extension

dns forwarder = ip du serveur dns (la plupart du temps sa box)
- On modifie le mot de passe de l’utilisateur Administrator qui a été généré par le domaine
```
samba-tool user setpassword administrator
```
- On désactive l’expiration du mot de passe de l’utilisateur Administrator
```
samba-tool user setexpiry administrator --noexpiry
```
- On crée un utilisateur qui va nous servir pour entrer les machines dans le domaine – Dans notre exemple on va l’appeler hokuto
```
samba-tool user create hokuto
```
- On désactive l’expiration du mot de passe de notre utilisateur
```
samba-tool user setexpiry hokuto --noexpiry
```
- On rajoute notre utilisateur dans le groupe des administrateurs du domaine
```
samba-tool group addmembers "Domain Admins" hokuto
```
- On récupère la configuration par défaut de kerberos
```
cp /var/lib/samba/private/krb5.conf /etc/krb5.conf
```
- On configure notre serveur en tant que serveur dns. En effet, les machines du domaine vont demander au contrôleur de domaine comment résoudre les ip
```
nano /etc/resolv.conf
```
Mettre les informations suivantes dans le fichier
```
nameserver ipduserveur
search domaineavecextension
domain domaineavecextension
```
- Vérification d’utilisation du port 53. Port utilisé par le dns de Samba
```
ss -tunpel | grep ":53 "
```
Si on a des choses comme dans l’image suivante alors il faut suivre les étapes suivantes sinon passer à l’étape Démarrage de Samba
- Désactivation du listener de systemd-resolve
```
nano /etc/systemd/resolved.conf
```
Décommenter la ligne DNSStubListener et mettre la valeur à no
- Arrêt et désactivation du service listener
```
systemctl stop systemd-resolved
systemctl disable systemd-resolved.service
```
- Vérification
```
ss -tunpel | grep ":53 "
```
On est tout bon

4 – Démarrage de Samba
- Arrêt et désactivation des anciens services
```
systemctl stop smbd nmbd winbindd smb nmb winbind
systemctl disable smbd nmbd winbindd smb nmb winbind
```
Si certains services sont en failed c’est normal, cela veux dire qu’ils ne sont pas présents sur le serveur
- Activation et démarrage de samba
```
systemctl unmask samba
systemctl enable samba
systemctl start samba
sleep 5
samba-tool processes
```
Tout les services sont correctement démarrés
- Création d’une zone de recherche inversée de façon à ce que notre contrôleur de domaine puisse faire la résolution dns des appareils du domaine
```
samba-tool dns zonecreate nomserveur ip.in-addr.arpa --username=nomadministrator
```
Exemple
```
samba-tool dns zonecreate ADDC 0.168.192.in-addr.arpa --username=administrator
```
Notre serveur s’appelle ADDC

On est sur la plage d’ip 192.168.0….

5 – Test

Pour tester, on peux essayer de rentrer un appareil sur le domaine

Le tuto pour rentrer un appareil windows sur le domaine est ici

Le tuto pour rentrer un appareil linux sur le domaine est ici
4 avril 2026
Utiliser ProxMox en ligne de commandes
Quelques lignes de commandes utiles pour pouvoir utiliser proxmox en ligne de commandes

1 – Mettre à jour les modèles de conteneurs
```
pveam update
```
2 – Lister les modèles disponibles
```
pveam available
```
on peux filtrer avec l’argument –section suivi de la section, par exemple
```
pveam available --section system
```
on peux aussi faire un | grep après la commande pour grep suivant le texte
```
pveam available --section system | grep ubuntu
```
3 – Télécharger un modèle pour qu’il soit disponible dans ct templates

pveam download local nomdumodele, par exemple
```
pveam download local debian-12-turnkey-zoneminder_18.0-1_amd64.tar.gz
```
4 – Lister les modèles de ct templates
```
pveam list local
```
5 – Lister les conteneurs lxc
```
pct list
```
6 – Voir la configuration d’un conteneur
```
pct config idduconteneur
```
on peux aussi voir la configuration directement dans un fichier pour le modifier à chaud
```
nano /etc/pve/lxc/idconteneur.conf
```
7 – Entrer directement dans le shell d’un conteneur
```
pct enter idduconteneur
```
on quitte avec exit

8 – Démarrer ou arrêter un conteneur
```
pct start idduconteneur
pct shutdown idduconteneur
```
9 – Modifier la configuration d’un conteneur à chaud
```
pct set idduconteneur -optionamodifier valeur
```
10 – Créer un conteneur
```
pct create id image \
-- hostname nom \
-- cores nombresdecoeur \
-- memory memoire \
-- swap swap \
-- rootfs emplacementdisque:taille \
-- net0 informations reseau
-- unprivileged (0 ou 1) \
-- features lesoptions \
-- tags lestags \
-- password motdepasseduroot \
-- start (0 pour pas automatique, 1 pour automatique)
```
11 – Supprimer un conteneur
```
pct destroy idduconteneur --purge
```
attention, le conteneur dois être arrêté
11 mars 2026
Gestion des ip sur linux
1 – Avoir son ip locale
```
ip a
```
on retrouve son ip locale qui commence par 192.168.xxxx

2 – mettre son ip locale en statique ou en dynamique
- Installer netplan (si pas déjà installé)
```
apt install netplan.io
```
- Rechercher le fichier yaml qui s’occupe du réseau
```
ls /etc/netplan/*.yaml
```
- dans notre exemple il s’agit du fichier 50-cloud-int.yaml
- on va éditer ce fichier
```
nano /etc/netplan/50-cloud-init.yaml
```
- dans notre exemple, on est en DHCP donc ip dynamique
- Si on veux passer en ip statique on doit remplacer
- – dhcp4: true par dhcp4: false
- – Rajouter les lignes comme dans la copie écran suivante (bien entendu les ip, passerelle et dns dont à mettre en fonction de la configuration réseau souhaitée)
- on enregistre et on génère le netplan
```
netplan generate
```
- on applique
```
netplan apply
```
on est bien en ip statique
- si on veux passer en ip dynamique, il suffit de modifier le fichier comme le premier exemple
⚠️Si on est sur une machine containerisé sous docker ou lxc netplan n’existe pas, l’ip se gère au niveau du container

3 – Connaître son ip publique
- installation de curl si pas installé
```
apt install curl
```
(déjà installé dans notre exemple)
```
curl -4 ifconfig.me
```
- on a notre ip publique
23 février 2026
Compiler un projet c# visual studio pour linux
Pour compiler un projet c# fait avec visual studio il n’y a pas de bouton « compiler » comme sur Windows

Il faut passer par la console de visual studio

Si la console n’est pas disponible on la retrouve dans Affichage puis Terminal

Le terminal apparaît dans visual studio

On va se positionner dans le projet avec les commandes cd

on écris
```
dotnet publish -c Release -r linux-x64 --self-contained true
```
ça compile

Une fois la compilation terminée on peux aller dans le dossier release du projet et en naviguant dans les dossiers on trouve un dossier publish que l’on peux récupérer pour envoyer sur notre linux
15 février 2026
Mise en place d’une réplication asynchrone PostgreSQL
Nous allons mettre en place une réplication asynchrone entre deux serveurs PostgreSQL

1 – Prérequis

Il faut avoir installé PostgreSQL sur les serveurs

2 – Préambule

Dans notre exemple on va avoir deux serveurs
- Le 192.168.1.114 qui va être considéré comme le Master. C’est lui qui enverra ses données au Slave
- Le 192.168.1.184 qui va être considéré comme le Slave. C’est lui qui recevra les données du Master
3 – Préparation du Master

Toutes les commandes seront faites sur le Master

3.1 – Création de l’utilisateur qui fera la réplication
- on se connecte au master
```
sudo -i -u postgres
```
(L’utilisateur postgre est crée automatiquement lors de l’installation de PostgreSQL. Se reporter à l’article parlant de l’installation de PostgreSQL)
```
psql
```
- Créer l’utilisateur qui fera la réplication
```
CREATE ROLE replicator WITH REPLICATION LOGIN PASSWORD 'motdepasseutilisateur';
```
3.2 – Modification des fichiers PostgreSQL
- Modifier le fichier /etc/postgresql/*/main/postgresql.conf
- De-commenter, ajouter ou modifier les lignes suivantes
```
listen_addresses = '*'
wal_level = replica
max_wal_senders = 10
wal_keep_size = 512MB
```
- En option mais recommandé pour archiver les WAL
- De-commenter, ajouter ou modifier les lignes suivantes
```
archive_mode = on
archive_command = 'cp %p /var/lib/postgresql/wal_archive/%f'
```
- Enregistrer le fichier /etc/postgresql/*/main/postgresql.conf
- Modifier le fichier /etc/postgresql/*/main/pg_hba.conf
- commenter
```
host    replication     all             127.0.0.1/32            scram-sha-256
host    replication     all             ::1/128                 scram-sha-256
```
- Ajouter
```
host    replication     replicator     192.168.1.184/32     md5
```
(Attention, l’ip est l’ip du Slave, penser à la modifier si le Slave n’a pas l’ip 192.168.1.184)

(Attention aux tabulations)
- Sauvegarder le fichier
3.3 Redémarrer le service PostgreSQL
```
sudo systemctl restart postgresql
```
4 – Préparation du Slave

Toutes les commandes seront faites sur le Slave

4.1 Arrêter le service PostgreSQL
```
sudo systemctl stop postgresql
```
4.2 Supprimer toutes les données de l’instance (On va récupérer les données du master plus tard)
```
sudo rm -rf /var/lib/postgresql/17/main/*
```
4.3 Cloner le master
```
pg_basebackup -h 192.168.1.114 -U replicator -D /var/lib/postgresql/17/main -Fp -Xs -P
```
(Attention, l’ip est l’ip du Master, si 192.168.1.114 n’est pas l’ip du Master il faut bien mettre l’ip du Master)

(Le mot de passe de l’utilisateur replicator rentré à l’étape 3.1 est demandé)

5 – Activation du mode standby

Le mode standby permet de dire au serveur que ce n’est pas un serveur normal mais qu’il doit se connecter à un master pour avoir ses données

5.1 – Créer le fichier standby.signal
```
sudo -u postgres touch /var/lib/postgresql/17/main/standby.signal
```
5.2 – Configurer la connexion au master
- Modifier le fichier /var/lib/postgresql/*/main/postgresql.auto.conf
- ajouter
```
primary_conninfo = 'host=192.168.1.114 port=5432 user=replicator password=motdepasseutilisateur'
```
(Attention, l’ip est l’ip du Master, le mot de passe est le mot de passe rentré à l’étape 3.1)
- Enregistrer le fichier
6 – Démarrer le service PostgreSQL sur le Slave
```
sudo systemctl start postgresql@17-main
```
7 – Vérifications

On va faire trois vérifications

7.1 – Sur le master, rentrer en mode sql
```
sudo -i -u postgres
psql
```
- Écrire
```
SELECT pid, state, client_addr FROM pg_stat_replication;
```
Le retour dois être xxxx streaming ip_du_slave

Le Master est bien configuré

7.2 – Sur le Slave, rentrer en mode sql
```
sudo -i -u postgres
psql
```
- Écrire
```
SELECT pg_is_in_recovery();
```
- T pour true, le slave est bien configuré
7.3 – Sur PGAdmin (si installé)
- On crée un enregistrement sur la base Master
- On vérifie sur la base Slave
Les données sont bien renvoyées sur le Slave
10 février 2026
Installation PGAdmin sur un serveur Ubuntu
1 – Prérequis

Il faut avoir installé PostgreSQL sur le serveur avant l’installation de PGAdmin

2 – Préparation du serveur
- Installation de curl, ca-certificates et gnupg
```
sudo apt install curl ca-certificates gnupg -y
```
- Ajout de la clé PGP
```
curl -fsS https://www.pgadmin.org/static/packages_pgadmin_org.pub \
  | sudo gpg --dearmor -o /usr/share/keyrings/packages-pgadmin-org.gpg
```
- Ajout du dépôt PGAdmin
```
echo "deb [signed-by=/usr/share/keyrings/packages-pgadmin-org.gpg] https://ftp.postgresql.org/pub/pgadmin/pgadmin4/apt/plucky pgadmin4 main" | sudo tee /etc/apt/sources.list.d/pgadmin4.list
```
- Mettre à jour les sources
```
sudo apt update
```
3 – Installation de PGAdmin

Deux solutions

Une version desktop et une version web

S’il y a une interface graphique sur le serveur et que l’on veux utiliser directement PGAdmin sur le serveur alors on va utiliser la version desktop.

Si on veux utiliser PGAdmin sur un autre poste, on va utiliser la version Web
- Installation de la version desktop
```
sudo apt install pgadmin4-desktop -y
```
- Installation de la version web
```
sudo apt install pgadmin4-web -y
```
Dans la suite de ce tuto, on va installer la version web
- Lancement du script de configuration de PGAdmin
```
sudo PGADMIN_PLATFORM_TYPE=debian /usr/pgadmin4/bin/setup-web.sh
```
- Mettre l’adresse mail de l’utilisateur initial de pgadmin
- Le mot de passe de l’utilisateur
- Lancement du paramétrage de base de Apache pour PGAdmin, faire Y, puis Y pour confirmer le redémarrage de Apache
4 – Paramétrage de PGAdmin

Par défaut PGAdmin n’autorise que les connexions localhost, il faut donc que l’on modifie cela
- Éditer le fichier /etc/apache2/conf-available/pgadmin4.conf
```
sudo nano /etc/apache2/conf-available/pgadmin4.conf
```
Remplacer la partie
```
Require local
```
par
```
Require all granted
```
- Redémarrer Apache
```
sudo systemctl restart apache2
```
- Test de connexion
On se connecte via http://ipduserveur/pgadmin4
8 février 2026
Installation PostgreSQL sur Ubuntu
On va installer une base PostgreSQL sur notre système Ubuntu

1 – Mettre à jour le système
```
sudo apt update
sudo apt full-upgrade
```
2 – Installer PostgreSQL depuis les dépôts Ubuntu
```
sudo apt install postgresql -y
```
- Normalement PostgreSQL est activé automatiquement par l’installation mais rien n’empêche de le vérifier
```
sudo systemctl status postgresql
```
- Si ce n’est pas activé on peux l’activer via
```
sudo systemctl enable postgresql
sudo systemctl start postegresql
```
3 – Tester la connexion et création de son premier utilisateur et base de données
```
sudo -i -u postgres
psql
```
- Tant que l’on est dans postgresql, on peux crée un utilisateur, cela évitera de laisser l’utilisateur par défaut
```
CREATE USER utilisateur WITH PASSWORD 'motdepasse';
```
Bien entendu on mets l’utilisateur et le mot de passe que l’on veux
- On va aussi créer une base de données pour tester
```
CREATE DATABASE nombasededonnees OWNER utilisateur;
```
Bien entendu on mets le nom de la base de données que l’on veux et on récupére l’utilisateur que l’on viens de créer
- on donne tous les droits à l’utilisateur pour cette base de données
```
GRANT ALL PRIVILEGES ON DATABASE nombasededonnees TO utilisateur;
```
Bien remplacer le nom de la base de données et de l’utilisateur
- on peux quitter PostgreSQL et revenir au bash
```
\q
exit
```
/q quitte postgresql

exit nous fait revenir à notre utilisateur bash de base

4 – Bonus

si on veux autoriser les connexions autres que localhost
- Éditer le fichier /etc/postgresql/*/main/postgresql.conf
- Décommenter la ligne listen_adresses puis modifier pour mettre = ‘*’ au lieu de =’localhost’
- Sauvegarder le fichier
- Éditer le fichier /etc/postgresql/*/main/pg_hba.conf
- Ajouter, sous
```
# IPv4 local connections:
host    all             all             127.0.0.1/32            scram-sha-256
```
la ligne
```
host    all             all             0.0.0.0/0               md5
```
(Attention aux tabulations)
- redémarrer le service postgresql
```
sudo systemctl restart postgresql
```
5 – La suite

On peux, par la suite installer PGAdmin sur le serveur
8 février 2026
Mettre en place une réplication entre plusieurs bases de données MariaDB
1 – Préambule

Nous allons mettre en place une réplication entre deux bases de données mariadb, ce qui signifie que ce qui se passe sur une base sera automatiquement renvoyé sur l’autre base

Attention : il faut prévoir un maître et un ou des esclaves

Le maître sera celui qui envoie les données, le ou les esclaves seront ceux qui recevront les données

Un cas précis serait de mettre une base en écriture et une ou plusieurs bases en lecture

Cela permettrai de rediriger le trafic entre les utilisateurs qui vont écrire dans la base (faire des commandes, etc…) et les utilisateurs qui vont lire la base (voir leurs infos, voir leurs commandes, etc…)

Cela permet, à terme, une scalabilité horizontale d’une application

Dans notre exemple nous allons avoir le « Master » qui aura l’ip 192.168.1.169 et un seul « Slave » qui aura l’ip 192.168.1.91

Notre base de données sera nommée test et aura une seule table nommée test

2 – Préparation du master

Toutes les commandes seront à faire sur le serveur « Maître »

2.1 – Modifier la configuration de MariaDB

Éditer le fichier /etc/mysql/mariadb.conf.d/50-server.cnf
```
sudo nano /etc/mysql/mariadb.conf.d/50-server.cnf
```
Repérer la ligne bind-address, et mettre à la place
```
bind-address = 0.0.0.0
server-id = 1
log_bin = mariadb-bin
binlog_format = ROW
```
Enregistrer le fichier

Redémarrer MariaDB
```
sudo systemctl restart mariadb
```
2.2 – Création de l’utilisateur qui va servir pour la réplication

Se connecter à mariaBD
```
sudo mysql -u root
```
Créer l’utilisateur
```
CREATE USER 'nomutilisateurreplication'@'192.168.1.%' IDENTIFIED BY 'motdepasseutilisateur';
```
Changer le nomutilisateurreplication par le nom désiré et le motdepasseutilisateur par le mot de passe désiré

Donner les accès à l’utilisateur pour qu’il puisse répliquer
```
GRANT REPLICATION SLAVE ON *.* TO 'nomutilisateurreplication'@'192.168.1.%';
FLUSH PRIVILEGES;
```
2.3 – Verrouillage des tables et récupération des infos Binlog
```
FLUSH TABLES WITH READ LOCK;
SHOW MASTER STATUS;
```
Noter les valeurs dans un coin

2.4 – Faire une sauvegarde de la base master pour pouvoir la réinjecter dans le slave
```
mysqldump -u root -p --all-databases --master-data=2 > dump.sql
```
Récupérer le fichier dump.sql sur le poste – voir tuto SCP si nécessaire

Déverrouiller le master
```
UNLOCK TABLES;
```
3 – Préparation du slave

Toutes les commandes seront à faire sur le serveur « Esclave »

3.1 – Éditer le fichier /etc/mysql/mariadb.conf.d/50-server.cnf
```
sudo nano /etc/mysql/mariadb.conf.d/50-server.cnf
```
Après bind-adress rajouter
```
server-id = 2
relay_log = relay-bin
```
Enregistrer le fichier

Redémarrer MariaDB
```
sudo systemctl restart mariadb
```
3.2 – Importer le fichier dump crée à l’étape 2.4

Voir le tuto sur SCP si nécessaire pour mettre le fichier sur le serveur esclave
```
mysql -u root -p < dump.sql
```
3.3 – Configurer la réplication

Se connecter sur mariaDB
```
mysql -u root -p
```
Passer la commande suivante en modifiant les valeurs que l’on a mises tout au long de ce tuto
```
CHANGE MASTER TO
  MASTER_HOST='ipdumaster',
  MASTER_USER='nomutilisateurreplication',
  MASTER_PASSWORD='motdepasseutilisateur',
  MASTER_LOG_FILE='nomfichieretape2.3',
  MASTER_LOG_POS=positionetape2.3;
```
Démarrer l’esclave
```
START SLAVE;
```
3.4 – Vérification
```
SHOW SLAVE STATUS\G
```
Vérifier surtout
- Slave_IO_Running : Yes
- Slave_SQL_Running : Yes
- Seconds_Behind_Master : 0 (ou proche)
4 – Tester une insertion dans la base pour voir si ça réplique bien

Et sur le slave

5 – Bonus

Pour rajouter d’autres slave, on reprends au 2.3 pour retrouver le fichier et la position

Et dans l’étape 3.1 on mets un server-id à 3, ou 4, ou 5, etc…
8 février 2026
Installation de phpMyAdmin sur Ubuntu
1 – Les prérequis

Avant d’installer phpMyAdmin il y a plusieurs prérequis
- Avoir installé apache2 et php
- Avoir installé une base de données sql (par exemple mariadb)
2 – Mise à jour des sources
```
sudo apt update
```
3 – Installation phpMyAdmin et des modules php nécessaires
```
sudo apt install phpmyadmin php-zip php-gd php-json php-curl libapache2-mod-php
```
y
- Choisir apache2 en appuyant sur espace pour mettre une croix dans la case apache 2, puis tab pour aller sur ok, puis entrée
- Bien vérifier que la croix est bien mise avant de faire entrée sinon l’installation ne choisira pas apache2 et il faudra tout recommencer
- Yes pour lancer la configuration de phpMyAdmin
- Mettre un mot de passe pour phpMyAdmin et le confirmer
- phpMyAdmin est installé
4 – Paramétrage

phpMyAdmin fournis, par défaut un paramétrage fonctionnel, donc on va activer ce paramétrage par défaut
```
sudo ln -s /etc/phpmyadmin/apache.conf /etc/apache2/conf-available/phpmyadmin.conf
sudo a2enconf phpmyadmin.conf
sudo systemctl reload apache2.service
```
5 – Test

On se connecte sur http://ipduserveur/phpmyadmin

6 – Bonus

Si on a cette erreur à la connexion à phpMyAdmin

Cela signifie que root n’a pas le droit de se connecter à phpMyAdmin.

On va lister les utilisateurs de la base
```
sudo mysql -u root
SELECT user, host, plugin FROM mysql.user;
```
On voit bien que l’utilisateur est phpmyadmin et non root qui peux se connecter à phpMyAdmin

On vérifie les accès de phpmyadmin
```
SHOW GRANTS FOR 'phpmyadmin'@'localhost';
```
Les seuls accès qu’il a c’est sur sa base, on va donc lui donner tous les accès possibles
```
GRANT ALL PRIVILEGES ON *.* TO 'phpmyadmin'@'localhost' WITH GRANT OPTION;
FLUSH PRIVILEGES;
```
On resteste en remettant la commande Show Grants

notre utilisateur a bien tous les privilèges. On peux tester la connexion

Tout est fonctionnel, on peux utiliser phpMyAdmin avec mariadb
7 février 2026