Linux

La version 1.5.9 de Fog est compatible avec Ubuntu 20.04 mais pas encore avec la version 22.04. Une erreur liée au paquet php-gettext s’affiche à l’installation car ce paquet est maintenant intégré dans le php-common.

Pour un déploiement sur un Ubuntu 22.04, il faut utiliser la branche DEV du projet FOG. Pour utiliser la branche officielle, il faut un déploiement sur un Ubuntu 20.04. Pour avoir accès aux différentes mises à jour la version de Ubuntu utilisé est la 20.04.

2 Matériels

Pour l’installation d’un serveur FOG, il y aura besoin de trois machines :

-Machine 1 (Serveur FOG)

-Machine 2 (Master)

-Machine 3 (Client)

3 Sources

https://chrtophe.developpez.com/tutoriels/deploiement-fogproject/

https://docs.fogproject.org/en/latest/installation/install_fog_server.html

https://enzo-lefort.fr/pdf/Stage1/Mise_en_place_d_un_serveur_FOG.pdf

https://doc.ubuntu-fr.org/fog

https://learn.microsoft.com/fr-fr/windows-hardware/manufacture/desktop/sysprep--system-preparation--overview?view=windows-11

https://geniorama.com/quand-comment-utiliser-sysprep-outil-preparation-windows/#:~:text=1-%20Tapez%20«%20cd%sysprep%20»%20%3B%202-,5-%20Cochez%20la%20case%20«%20Généraliser%20»%20%3B

Fog

02 - Installation

A - Ubuntu 20.04

Toutes ces étapes sont à effectuer sur la Machine 1 (Serveur Fog).

1 Langue

Paramétrage de la langue de l’os.

2 Clavier

Paramétrage de la langue du clavier.

3 Adresse IP

Paramétrage de l’adresse IP.

4 Proxy

Configuration du proxy si nécessaire.

5 Stockage

Configuration du stockage.

6 Sommaire du système de fichiers

Configuration du sommaire du système de fichiers.

7 Nom

Configuration du nom, nom de machine ainsi que mot de passe.

8 OpenSSH

Activation de OpenSHH.

9 Installation de Ubuntu

Installation de Ubuntu 20.04

10 Environnement de Serveur

B - Serveur Fog

1 Mise à jours

Installation des différentes mises à jour en ligne de commande.

Commandes :

sudo -i
apt-get update

2 Git

Installation de git en ligne de commande.

Commande :

apt-get -y install git

3 Wget/Unzip

Installation en ligne de commande de wget ainsi que unzip.

Commande :

apt-get install wget unzip

4 Git Fog

Installation du git FOG en ligne de commande.

Commande :

wget https://github.com/FOGProject/fogproject/archive/refs/heads/master.zip

5 Git Fog

Décompression du fichier master.zip.

Commande :

unzip master.zip

6 Exécution du programme

Exécution du programme d’installation.

Commandes :

cd /root/fogproject-master/bin
./installfog.sh

7 Choix de type d'installation

Un serveur de stockage, comme son nom l’indique, ne servira qu’au stockage des images de déploiement. Celui-ci nécessitera d’être connecté à un serveur normal. Un ou plusieurs servers de stockage permettront un meilleur équilibrage de charge en cas de déploiements conséquents. Un seul serveur normal est utilisable.

Service installé sur un serveur normal :

Serveur Web et base de sonnées ;

Serveur DHCP ;

Serveur PXE ;

Serveur NFS et FTP pour le stockage.

Sur un serveur de stockage, seuls les services NFS et FTP sont déployés.

8 Réglage Réseau

Paramétrage du réseau (à laisser par défaut en cas de présence d’une seul carte réseau).

9 Réseau et réglage du DHCP

Les prochains réglages concernent le réseau avec les réglages du serveur DHCP fourni par Fog Project (ne pas activer le serveur DHCP de Fog Project empêche le boot PXE) :

10 Réglage de l'internalisation

Pour avoir la possibilité de passer l’interface en français, il faudra répondre « yes ».

11 Support HTTPS

12 Choisir le hostname

13 Envoie des informations

14 Installation en cours

Fog

03 - Configuration

A - Interface graphique

1 Accès au site

Une fois l’installation terminée, taper sur le navigateur le lien donné, ici « http://192.168.197.134/fog/management ».

2 Mot de passe

Une fois sur le site, pour avoir le mot de passe appuyé sur la touche Entré sur le serveur FOG, celui-ci donnera le mot de passe pour se connecter.

À ce stade, choisir la langue française n’aura aucun effet.

3 Dashboard

4 Configuration du mot de passe

Une fois sur l’interface graphique, cliquer sur « Utilisateur » puis « Répertorier tous les utilisateurs ». Selon la langue sélectionner, cliquer sur « brouillard » (Français) ou « fog » (Anglais).

Après avoir cliqué sur « fog » sélectionner « Changer de mot de passe ».

Une fois sur cette interface, sélectionnez le nouveau mot de passe.

Toutes les fonctions principales sont accessibles depuis la barre de menu :

Dashboard : affiché par défaut au démarrage ;
User : pour gérer les utilisateurs ;
Hosts : pour gérer les machines ;
Groups : pour gérer les groupes de machines ;
Images : pour gérer les images de déploiements ;
Storage : pour gérer les machines de stockage secondaires ;
Snapin : pour gérer les actions de déploiement ;
Printer : pour gérer un spooler d’impression depuis Fog ;
Client setting : pour gérer les fonctions du client installées sur les machines gérées (exemple : activer/désactiver la gestion des snapins (que nous verrons plus tard), activer/désactiver la possibilité de reboot distant) ;
Tasks : pour le suivi des tâches en cours ;
Reports : permet de générer des rapports en CSV ou PDF ;
Configuration : pour effectuer des réglages de FOG Project.

5 Configuration de la langue

Pour passer l’interface en français, cliqué sur l’icône « Fog configuration » puis aller dans l’onglet « Fog Settings ».

Ensuite descendre dans la liste et cliquer sur « General Settings », sélectionner la langue en changeant la « default locale ».

Après avoir validé en cliquant sur « update » et rafraîchi l’écran en cliquant sur l’icône « Dashboard », vous verrez l’interface en français.

B - Sysprep

Ces étapes sont à effectuer sur la Machine 2 (Master).

1 Enregistrement de la machine dans Fog

Après avoir préparé le poste, accéder au BIOS pour activer le PXE afin de Boot dessus.

Une fois dans le menu suivant, cliquer sur « Quick regitration and inventory ».

2 Nom de l'image

Une fois l’enregistrement effectué, la machine apparaîtra dans la liste des hôtes avec comme nom son adresse MAC.

Changer le nom de la machine en cliquant sur l’adresse MAC.

3 Capture de l'image

Création de l’image d’une machine

4 Liste d'hôte

Cliquer sûr pour choisir l’image. Ceci déclenchera l’ouverture des paramètres de la machine, l’image créée précédemment :

Une fois l’image créée, le nom de celle-ci apparaîtra à côté de l’icône permettant de déclencher la capture :

5 Création de la tâche

Création d’une tâche de capture, sélectionner et créer la tâche.

6 Création de la tâche

Dans l’explorateur de fichiers, aller dans « C:\Windows\System32\Sysprep » et exécuter « sysprep.exe ».

7 Exécution sysprep.exe

Après avoir exécuté sysprep.exe, sélectionner « Entrer de mode OOBE », cliquer sur « Généraliser » puis appuyer sur « OK ».

8 Boot PXE

Après avoir redémarré le poste, Booter en PXE.

9 Enregistrement de l'image

Ci-dessous, sauvegarde en cours avec PartClone, utilisé par Fog Project :

Image non disponible

État de capture en cours depuis l’interface :

Image non disponible

Une fois la capture effectuée, vous pourrez voir les informations afférentes (comme la taille, la date de capture) depuis la liste des images :

Image non disponible

C - Déploiement

Ces étapes sont à effectuer sur la Machine 3 (Client)

1 Boot PXE

Après avoir redémarré le poste, accéder au BIOS afin de Boot en PXE.

2 Deploy image

Au démarrage de la machine, BOOTER en PXE et sélectionner « Deploy image »

Sauvegarde en cours avec Partclone, utilisé par Fog Project.

3 État du déploiement

Pour avoir l’état du déploiement sur le serveur Web, il faut créer une tâche en cliquant sûr . Quand une tâche est créée, au moment du déploiement le serveur FOG ne passe pas par l’image ci-dessus, il lance directement l’installation avec Partclone.
Malheureusement, FOG ne peut créer qu’une seule tâche à la fois donc si plusieurs machines sont déployées en même temps, seules une n’aura pas besoin de sélectionner « Deploy Image ».

SaltProject

01-Description

A - Description :

VM en remplacement du serveur physique installé le 30/07/2013 (Dell R610)
Type : VMware

Distrib : Ubuntu 22.04
Nom DNS : admin-l.v.sdem.fr
Adresse IP : 192.168.1.15

SaltProject

02-01-Installation SaltSlack Orchestration

A - Description :

Le système Salt est un framework d'exécution à distance open source basé sur Python pour la gestion de la configuration, l'automatisation, le provisionnement et l'orchestration.

SaltStack est un logiciel de gestion de configuration et d'automatisation gratuit, open source et basé sur Python. Il s'agit d'un outil de ligne de commande qui vous aide à gérer votre infrastructure à partir d'un emplacement central. SaltStack est composé de quatre composants. Une brève explication de chaque composant est présentée ci-dessous :

Salt Master agit comme un contrôleur de ligne de commande pour ses sbires. Il est utilisé pour contrôler et gérer un certain nombre de serviteurs.
Les Salt Minions sont des démons esclaves qui reçoivent des configurations et des commandes du maître.
La formule est constituée de fichiers de gestion de configuration.
L'exécution est un nombre de commandes et de modules qui sont exécutés sur les minions.

Salt se distingue de ses homologues car son auteur a eu la bonne idée de ne pas construire un monstre s'appuyant sur des solutions de messagerie à la complexité douteuse mais a plutôt misé sur la librairie ZeroMQ[2], s'assurant ainsi vélocité et simplicité. Ce choix est loin d'être anodin car, sans aucun effort supplémentaire, Salt offre d'emblée des fonctionnalités de gestion de configuration et d'orchestration. Et nous allons voir que mettre le pied à l'étrier du cheval Salt n'a rien de l'insurmontable. Enfin, mais c'est évidemment très personnel, je n'ai aucune affinité avec le langage Ruby et au contraire des solutions sus-citées, Salt est écrit en python, plus doux à mes yeux. Cela peut paraître dérisoire à première vue, mais devant la forte probabilité de tentation d'écriture de modules, le langage de la solution a son importance.

Bien que jeune (Mai 2011), le projet a d'ores et déjà le soutien de noms prestigieux tels que HP, LinkedIn ou encore PayPal, se décline déjà en version commerciale et sait adresser la quasi totalité des Clouds publics et privés.

Enfin, la liste des services Libres que Salt est en mesure de gérer est impressionnante et ne cesse de grossir, tant le développement de modules est simple avec un strict minimum de connaissances en python[4].

1. Documentations :

https://connect.ed-diamond.com/GNU-Linux-Magazine/glmf-166/salt-l-autre-chef-d-orchestre

https://docs.saltproject.io/salt/install-guide/en/latest/topics/overview.html

https://fr.linux-console.net/?p=3335

https://fr.linux-console.net/?p=3486

https://docs.saltproject.io/salt/user-guide/en/latest/topics/overview.html

B - Installation du master :

1. Documentation d'installation en fonction de la distrib :

Documentation d'installation en fonction de la distrib/OS (Même Windows) :

https://docs.saltproject.io/salt/install-guide/en/latest/topics/install-by-operating-system/index.html

2. Installation de Salt Master :

# # Installation sur Ubuntu 22.04 :
sudo curl -fsSL -o /etc/apt/keyrings/salt-archive-keyring-2023.gpg https://repo.saltproject.io/salt/py3/ubuntu/22.04/amd64/SALT-PROJECT-GPG-PUBKEY- 2023.gpg 
echo "deb [signed-by=/etc/apt/keyrings/salt-archive-keyring-2023.gpg arch=amd64] https://repo.saltproject.io/salt/py3/ubuntu/22.04/amd64 /dernier plat principal confit" | sudo tee /etc/apt/sources.list.d/salt.list

# Mise à jour des dépôts :
sudo apt-get update

# Installation de salt :
sudo apt-get install salt-master salt-minion salt-ssh salt-syndic salt-cloud salt-api

# Activer et démarrer les services :
sudo systemctl enable salt-master && sudo systemctl start salt-master
sudo systemctl enable salt-minion && sudo systemctl start salt-minion
sudo systemctl enable salt-syndic && sudo systemctl start salt-syndic
sudo systemctl enable salt-api && sudo systemctl start salt-api

3. Configurer le Salt Master :

Documentation :

https://docs.saltproject.io/salt/install-guide/en/latest/topics/configure-master-minion.html

Fichier de configuration :

Pour une configuration de base de Salt, il vous suffit de modifier le fichier de configuration du minion Salt pour ajouter l'adresse IP du maître Salt auquel il se connectera. Voir Configuration de base des minions pour plus d'informations.

Le salt-masterservice est livré avec des configurations de serveur par défaut.
La configuration YAML principale par défaut /etc/salt/mastercontient tous les paramètres commentés.
Recommandé : vous pouvez ajouter des paramètres personnalisés dans YAML sous /etc/salt/master.d/forme .conf de fichiers sur Salt master.
Utilisez le fichier maître par défaut comme référence pour divers paramètres selon vos besoins.

Bien que le /etc/salt/masterfichier puisse accepter les paramètres de configuration, la meilleure pratique consiste à utiliser le /etc/salt/master.d/répertoire de configuration. L'utilisation de ce répertoire vous permet de placer les options de configuration dans des séparations logiques.

Par exemple, si vous souhaitez configurer un nombre différent de worker_threads, vous pouvez stocker ces configurations dans le /etc/salt/master.d/tuning.conf répertoire et conserver toutes les configurations liées au réglage dans ce fichier.

Paramètre du réseau :

# Editer le fichier (A créer) :
/etc/salt/master.d/network.conf

# Contenu : 
# The network interface to bind to
interface: 192.168.1.14

# The Request/Reply port
ret_port: 4506

# The port minions bind to for commands, aka the publish port
publish_port: 4505

Gestion des processus Salt Master :

Si votre cluster contient des milliers de serviteurs et que vos rapports sur les serviteurs sont bloqués, le maître peut retarder les réponses des serviteurs de la tâche. Cela peut signifier que les serviteurs ont échoué dans leur travail, mais cela pourrait plutôt signifier que le maître ne dispose pas de suffisamment de threads de travail pour traiter tous les rapports.

Pour gérer les salt-minionappels de retour, le maître enchaîne les processus de travail avec le worker_threadsparamètre. La limite par défaut pour les processus est de cinq travailleurs. La limite minimale est de trois travailleurs.

Exemple de paramètre dans un fichier de configuration principal :

# Editer le fichier :
vi /etc/salt/master.d/thread_options.conf

# Contenu :
worker_threads: 5

Normes pour les environnements très fréquentés :

Utilisez un thread de travail pour 200 serviteurs.
La valeur de worker_threadsne doit pas dépasser 1½ fois les cœurs de processeur disponibles.

C - Installation des Minions :

1. Installation des Minions :

Documentation :

https://docs.saltproject.io/en/latest/py-modindex.html
https://salt-zh.readthedocs.io/en/latest/ref/modules/all/salt.modules.cp.html

Description :

Le salt-minionservice est livré par défaut avec une configuration de configuration DNS/nom d'hôte.
La configuration YAML du minion par défaut /etc/salt/minioncontient tous les paramètres commentés.
Recommandé : vous pouvez ajouter des paramètres personnalisés dans YAML sous /etc/salt/minion.d/ forme .confde fichiers sur le serviteur.
Utilisez le fichier minion par défaut comme référence pour divers paramètres selon vos besoins.

REPO - CentOS 7 :

sudo yum install https://repo.saltstack.com/yum/redhat/salt-repo-latest.el7.noarch.rpm
sudo yum clean expire-cache 
sudo yum install salt-minion
sudo yum update

REPO - Ubuntu 18.04 :

sudo mkdir /etc/apt/keyrings
sudo curl -fsSL -o /etc/apt/keyrings/salt-archive-keyring.gpg https://repo.saltproject.io/salt/py3/ubuntu/18.04/amd64/latest/salt-archive-keyring.gpg
echo "deb [signed-by=/etc/apt/keyrings/salt-archive-keyring.gpg arch=amd64] https://repo.saltproject.io/salt/py3/ubuntu/18.04/amd64/latest bionic main" | sudo tee /etc/apt/sources.list.d/salt.list

apt update
sudo apt-get install salt-minion

REPO -Ubuntu 20.04 :

mkdir /etc/apt/keyrings
sudo curl -fsSL -o /etc/apt/keyrings/salt-archive-keyring.gpg https://repo.saltproject.io/py3/ubuntu/20.04/amd64/3004/salt-archive-keyring.gpg
echo "deb [signed-by=/etc/apt/keyrings/salt-archive-keyring.gpg arch=amd64] https://repo.saltproject.io/py3/ubuntu/20.04/amd64/3004 focal main" | sudo tee /etc/apt/sources.list.d/salt.list

apt update
sudo apt-get install salt-minion

REPO -Ubuntu 22.04 :

apt update
sudo apt-get install salt-minion

2. Configurer le Salt Minion :

Documentation :

https://docs.saltproject.io/salt/install-guide/en/latest/topics/configure-master-minion.html

Bonnes pratiques :

Bien que /etc/salt/minionle fichier puisse accepter les paramètres de configuration, la meilleure pratique consiste à utiliser le /etc/salt/minion.d/répertoire de configuration. L'utilisation de ce répertoire vous permet de placer les options de configuration dans des séparations logiques.

Avertissement :
Lorsque vous utilisez plusieurs .conffichiers, veillez à ne pas utiliser de paramètres de configuration en double. (Par exemple, définir le nombre de threads de travail dans plusieurs fichiers de configuration.)
Salt applique les paramètres du dernier .conffichier qu'il évalue et évalue les fichiers par ordre alphabétique. Si vous utilisez des paramètres de configuration en double, vous pourriez accidentellement remplacer le paramètre que vous vouliez appliquer.

Configuration du Minion :

Se connecter sur l'hôte esclave (le minion)

# Configuration de la connexion au Salt Master :
vi /etc/salt/minion.d/master.conf

# Contenu :
master: admin-l.v.sdem.fr

Le salt-minions'identifiera auprès du maître par le nom d'hôte du système, sauf indication contraire :

La plupart des chaînes sont autorisées. Si vous décidez de personnaliser vos identifiants de serviteur, essayez de garder l'identifiant bref mais descriptif de son rôle. Par exemple, vous pouvez utiliser apache-server-1pour nommer l'un de vos serveurs Web ou utiliser le nom datacenter-3-rack-2de son emplacement dans un centre de données. L’objectif est de rendre les noms descriptifs et utiles pour référence future.

# Configguration de l'identifiant du Minion :
vi /etc/salt/minion.d/id.conf

# Contenu
id: FQDN

Redémarrer le Minion :

service salt-minion restart

D - Gestion des clés des Minions :

1. Documentations :

https://docs.saltproject.io/salt/install-guide/en/latest/topics/accept-keys.html#accept-keys

2. Description :

La dernière étape du processus d'installation consiste pour le maître Salt à accepter les clés de minion Salt. Une fois les clés acceptées, le maître Salt peut émettre des commandes au serviteur et recevoir des messages entrants du serviteur. Les serviteurs Salt ne reçoivent pas de données du maître Salt tant que la clé n'est pas acceptée.

Pour des raisons de sécurité, Salt utilise une authentification par clé.

Deux types de clés sont utilisés dans Salt :

Les clés RSA constituent l'épine dorsale du modèle d'authentification et de chiffrement utilisé par Salt. Tous les démons Salt fonctionnent avec des clés RSA uniques. Les serviteurs et le maître génèrent des clés RSA lors de leur premier démarrage, puis les utilisent pour l'authentification basée sur PKI.

Ces clés sont utilisées pour authentifier la clé AES auprès du maître Salt, fournissant ainsi une communication sécurisée en cryptant les données. Chaque serviteur présente une clé publique au maître Salt. La clé est ensuite examinée, comparée et explicitement acceptée par un administrateur.

Le maître envoie également une clé AES tournante qui est utilisée pour chiffrer et déchiffrer les messages envoyés par le maître Salt. La clé AES renvoyée est chiffrée à l'aide de la clé publique initialement envoyée par le minion Salt et ne peut donc être déchiffrée que par le même minion Salt.

La clé AES subit une rotation dans l'une ou l'autre de ces conditions :

Toutes les 24 heures sur le master
Lorsque le maître est redémarré
Lorsqu'une clé de serviteur est supprimée.

La rotation des clés permet au maître de verrouiller les serviteurs qui ne sont pas authentifiés et permet le chiffrement des communications à l'échelle du système.

3. Gestion des clés :

La plupart des gestions des minions sont gérées via un client appelé salt-keyqui s'exécute sur le maître Salt. Ce client est utilisé pour gérer les serviteurs disponibles pour un maître.

Vous pouvez utiliser la salt-keycommande pour vous connecter au système d'authentification afin d'accepter, de rejeter et de gérer les clés.

Accepter les clés :

Lorsqu'un nouveau serviteur s'enregistre, la clé attendra jusqu'à ce qu'elle soit acceptée.Unaccepted keys

Appelez salt-keypour voir l’état actuel de la gestion des clés :

# Appelez salt-keypour voir l’état actuel de la gestion des clés :
salt-key

# Exemple de réponse :
oot@admin-l:/etc/salt/master.d# salt-key
Accepted Keys:
nextcloud.v.sdem.fr
Denied Keys:
Unaccepted Keys:
web01.v.sdem.fr
Rejected Keys:

Commande de gestion des clés :

# Accepter une clé :
salt-key -a FQDN

# Accepter toutes les clés :
salt-key -A

# Supprimer une clé :
salt-key -d FQDN

# Supprimer toutes les clés :
salt-key -D

# Supprimer des clés à l'aide d'un filtre :
salt-key -d 'web*'

Il est possible d'accepter ou rejeter automatiquement les clés.

SaltProject

02-Installation

A - Installation

1. Installation des outils de base :

apt-get install curl wget git swaks

B - Cacti

TODO

C - Postfix

1. Installation de postfix :

Postfix est utilisé pour l'envoi de mail des scripts.

D - Rancid

TODO

E - Samba

1. Description :

Le serveur Samba est utilisé pour la sauvegarde des données du SI provenant de l'AD vers le serveur d'admin. Un script Powershell se lance tous les jours pour transfert les données.
En cas de problème d'accès à l'AD, les données (Zim et Keepass) restent accessible afin de réparer l'infra.

2. Documentation :

https://computingforgeeks.com/install-and-configure-samba-server-share-on-debian-ubuntu/

3. Installation :

sudo apt -y install samba

4. Configuration :

Configurer le partage sécurisé de Samba :

# Création du répertoire à partager dans Samba :
sudo mkdir -p /home/share

# Définir la propriété de groupe du répertoire de partage Samba sur le groupe sambashare
sudo chgrp sambashare /home/share

# Création des utilisateurs de partage de samba :
sudo useradd -M -d /home/share/backup-si -s /usr/sbin/nologin -G sambashare backup-si
sudo mkdir /home/share/backup-si
sudo chown backup-si:sambashare /home/share/backup-si
sudo chmod 2770 /home/share/backup-si

# Définir le mot de passe utilisateur et confirmez :
sudo smbpasswd -a backup-si

# Activer le compte samba après avoir défini le mot de passe :
sudo smbpasswd -e backup-si

Configurer le fichier de paramétrage Samba :

Editer le fichier de paramétrage de Samba "/etc/samba/smb.conf"
Contenu des paramètres :

[backup-si]
    path = /home/share/backup-si
    read only = no
    browseable = no
    force create mode = 0660
    force directory mode = 2770
    valid users = @backup-si @adminme @sambashare
    # Tunning :
    case sensitive = true
    default case = lower
    preserve case = no
    short preserve case = no

Redémarrez le démon samba après avoir effectué les modifications.

sudo systemctl restart smbd nmbd

Ajout du compte adminme au dossier backup-si :

vi /etc/group
# Modifier la ligne ci-dessous :
sambashare:x:122:backup-si,adminme

F - Smokeping

1. Description :

Les problèmes réseaux et de qualités sont souvent difficiles à comprendre et à analyser …encore faut il les trouver. Chercher la source des perturbations chez votre client peut être un longue traversée du désert.

Smokeping peut vous y aider, cet article vous servira pour savoir comment installer et configurer ce logiciel de supervision.

SmokePing est un logiciel qui vous permet de conserver un historique de la latence de votre réseau.

Il est conçu par Tobi Oetiker, le créateur de MRTG et RRDtool. SmokePing est prévu pour calculer le RTT (Real Trip Time) entre les différents composants de votre réseau et peut le faire aussi bien avec un basique ping ICMP qu’avec des pings plus spécifiquement adaptés aux protocoles HTTP, SMTP, LDAP, DNS…

2. Documentation :

https://blog.wildix.com/fr/installation-configuration-de-smokeping/
https://oss.oetiker.ch/smokeping/doc/index.en.html

Installation :

apt install smokeping

Configuration :

cd /etc/smokeping/config.d/

URL d'accès : http://admin-l.v.sdem.fr/cgi-bin/smokeping.cgi

G- Syslog

TODO

SaltProject

03-Exploitation

B - Backup-SI

1. Description :

Le serveur d'admin est accessible en SSH soit avec le clé SSH ou bien avec le login "adminme" et son mot de passe (Identique au Keepass Informatique afin que le service informatique puisse le connaître).

Le service Samba est installé permettant de transférer depuis l'AD01 les informatique du SI (Keepass et Zim) vers un espace local sur le serveur admin.v.sdem.fr:/home/share/backup-si/
Un lien symbolique est créé sur le compte adminme dans "/home/adminme"

lrwxrwxrwx 1 adminme adminme   22 Aug 18 08:59 backup-si -> /home/share/backup-si//

2. Emplacement du backup :

Le "Zim" et le "Keepass" du service informatique sont copiés dans "adminme@admin.v.sdem.fr:/home/share/backup-si/%YYYYMMDD%".

Le backup est géré par un script Powershell sur le serveur AD01 qui va se connecter en SSH sur le serveur admin.v.sdem.fr avec le compte samba "backup-si".

C - Procédure-récupération-données-SI

Copie des données de l'infrastructure du SI de Morbihan Energies vers le serveur physique d'administration local avec une rétention de 30 jours.

# Sources copiées :
- Dossier Keepass
- Dossier Zim

# Destination :
admin.v.sdem.fr:/home/share/backup-si/%YYYYMMDD% (AnnéeMoisJour)

# Accès aux données :
En cas de besoin d'accès aux données, suivre la procédure ci-dessous :
- Se connecter avec un client FTP (Filezilla) sur adminme@admin.v.sdem.fr (Password identique au Keepass Informatique)
- Cliquer sur le lien symbolique backup-si
- Sélectionner le dossier correspondant à la date souhaitez et le transférer localement sur le poste

D - crontab

# Example of job definition:
# .---------------- minute (0 - 59)
# |  .------------- hour (0 - 23)
# |  |  .---------- day of month (1 - 31)
# |  |  |  .------- month (1 - 12) OR jan,feb,mar,apr ...
# |  |  |  |  .---- day of week (0 - 6) (Sunday=0 or 7) OR sun,mon,tue,wed,thu,fri,sat
# |  |  |  |  |
# *  *  *  *  *  user command to be executed
#
# Archive - mailreboot :
#20 12 * * 1,3 cd /root && ./mailreboot.sh
#

# ssl-cert-check :
00 01 * * * cd /usr/local/bin/ssl-cert-check/ && ./ssl-cert-check.sh -a -f ssldomains -q -x 60 -e hostmaster@morbihan-energies.fr

## url-check :
# Demarrage script url-check.sh - Intervale 5mn :
*/05 * * * * cd /usr/local/bin/url-check/ && ./url-check.sh >/dev/null 2>&1

# Purge dossier de cache URL toutes les heures :
* */01 * * * rm -f /usr/local/bin/url-check/cache/*

# Purge dossier /home/share/backup-si des dossiers de plus de 30 jours :
00 01 * * * cd /usr/local/bin/ && ./purge-backup-si.sh 2>&1

E - Racktables - ARCHIVE

1. Création d'un accès en lecture seul pour script de Cable-ID :

# Création du compte :
CREATE USER 'readonly'@'localhost' IDENTIFIED BY 'PASSWORD';

# Attribue des accès en lecture seule :
GRANT SELECT ON *.* TO 'readonly'@'localhost';

# Application des changements :
FLUSH PRIVILEGES;

Cette procédure est à transférer sur le serveur racktables lors de la migration de Racktables en CT LXC.

F - Scripts

Ce serveur permet d'orchestrer un ensemble de script prévu pour l'administration du système dr'information de Morbihan Energies.

Emplacement des scripts : 
/usr/local/bin/

1. purge-si-backup.sh

Description :

Purger le dossier "/home/share/backup-si" de tous les dossiers dont la date de création est supérieur à 30 jours.

Emplacement du script : /usr/local/bin/purge-backup-si.sh

#!/bin/bash
  
# Author : jkermorvant
# Version : 1.0
# Description : Purge du dossier /home/share/backup-si de tous les dossiers dont la date de création est suppérieur à 30 jours.
find /home/share/backup-si/* -ctime +30 -exec rm -rf {} \;

2. ssl-cert-check-master

Description :

Ce script permet d'alerter quand l'expiration des certificats approche des 60 jours.

Source :

https://github.com/Matty9191/ssl-cert-check
https://prefetch.net/articles/checkcertificate.html

Fonctionnement :

Le fichier "/usr/local/bin/ssl-cert-check-master/ssldomains" contient la liste des sites en SSL à scanner

morbihan-energies.fr 443
sdem.fr 443

Le fichier "/usr/local/bin/ssl-cert-check-master/ssl-cert-check" est le script qui permettra de vérifier l'état des certificats des sites web déclarés dans ssldomains.
La ligne 388 du script a été modifié pour configurer le FROM :

#   FROM="${1}"
    FROM="hostmaster@morbihan-energies.fr"

Exemple d'utilisation :

# Vérifier l'expiration des certificats listés dans le fichier ssldomains
./ssl-cert-check -f ssldomains

# Vérifier 
./ssl-cert-check -a -f ssldomains -q -x 60 -e hostmaster@morbihan-energies.fr

Crontab :

Une tâche planifiée est créé pour analyser tous les jours à 1h00 l'état des certificats.

# Editer la crontab
crontab -e

# Crontab pour le ssl-cert-check :
00 01 * * * cd /usr/local/bin/ssl-cert-check-master/ && ./ssl-cert-check -a -f ssldomains -q -x 60 -e hostmaster@morbihan-energies.fr

3. testssl.sh

Description :

La mise en place du chiffrement sur un serveur Web peut être parfois assez complexe en fonction du niveau de sécurité que vous souhaitez atteindre tout en prenant en compte la compatibilité avec les différents navigateurs et terminaux du marché.
Pour tester que votre serveur possède une configuration correcte, deux options s'offrent à vous :
- Dans le cas le plus simple, votre serveur possède déjà une entrée DNS publique, vous pourrez tout simplement utiliser le site SSLLabs pour vérifier la configuration de celui-ci. Une note de A est assez facilement atteignable en suivant les recommandations de safeciphers.
- Dans le cas contraire, si le DNS de votre serveur n'est pas encore exposé sur Internet, il faudra utiliser une autre solution : Testssl.sh
Testssl.sh est un script Unix permettant de vérifier la sécurité de votre configuration HTTPS. Il permettra de vous confirmer la compatibilité de votre site avec une exhaustivité de systèmes : Android, IE, Safari, Java ...

Documentation :

https://www.geeek.org/testssl-test-tls-ssl-serveur/

Installation :

cd /usr/local/bin/
git clone https://github.com/drwetter/testssl.sh
mv testssl.sh testssl
cd testssl
chmod +x testssl.sh

Exploitation :

./testssl.sh site.morbihan-energies.fr

4. url-check

SaltProject

03-01 - Exploitation de SaltProject

A - Commandes de base :

1. Commande de base :

salt '*' grains.ls
salt '*' grains.items
    locale_info:
        ----------
        defaultencoding:
            UTF-8
        defaultlanguage:
            fr_FR
        detectedencoding:
            utf-8
        timezone:
            UTC
    lsb_distrib_description:
        Ubuntu 22.04.3 LTS
    mem_total:
        1963
    num_cpus:
        2

salt '*' sys.doc

2. Gestion des grains :

Source : https://docs.saltproject.io/en/latest/ref/modules/all/salt.modules.grains.html

salt -G 'os:CentOS' test.version
salt -G 'cpuarch:x86_64' grains.item num_cpus
salt -G 'ec2_tags:environment:*production*'

salt '*' grains.item os osrelease oscodename
salt '*' grains.item host sanitize=True
salt '*' grains.items
salt '*' grains.items sanitize=True

# Renvoie une liste de tous les grains disponibles
salt '*' grains.ls

1. Gestion des groupes de minions :

Sources

https://salt-zh.readthedocs.io/en/latest/topics/targeting/nodegroups.html
https://docs.saltproject.io/en/master/topics/targeting/compound.html#targeting-compound
https://docs.saltproject.io/en/master/topics/targeting/nodegroups.html#defining-nodegroups-as-lists-of-minion-ids

Gestion des groupes

Créer un fichier .conf dans le dossier /etc/salt/master.d contenant les informations de groupe :

# Création d'un groupe dans un fichier dédié :
nodegroups:
  grp-srv-authorized_keys-dev-apside:
    - 'proto-novo.v.sdem.fr'

# Test du groupe :
salt -N grp-srv-authorized_keys-dev test.version

3. Commandes simples :

# Effectuer un test de ping sur les minions
salt nextcloud.v.sdem.fr test.ping
salt '*' test.ping
salt '*.v.sdem.fr' test.ping

# Vérifier la version de Salt sur les minions :
salt '*' test.version

# Afficher la version des Distrib des minions :
salt '*' cmd.run 'uname -a'
salt '*' cmd.run 'lsb_release -a'
salt '*' grains.item os osrelease oscodename

# Afficher l'uptime des minions :
salt '*' cmd.run 'uptime'

# Afficher la configuration réseau :
salt '*' network.interfaces

# Lancer des commandes à distance :
salt '*' cmd.run 'ls -l /etc'
salt '*' cmd.run 'du -sh /*'
salt '*' cmd.run 'find /home/share/backup-si/* -ctime +1 -exec rm -rf {} \;'
salt '*' cmd.run 'shutdown -r now'

# Afficher les informations des disques des minions :
salt '*' disk.usage

# Afficher la conso de la RAM sur les minions :
salt '*' cmd.run 'free -m'

# Vérifiez le package bash à l'aide de la commande salt ci-dessous.
salt '*' pkg.show bash

# Installez un package sur tous les serveurs minion.
salt '*' pkg.install swaks
salt '*' pkg.install tree
salt '*' pkg.install postfix

# Afficher les référentiels disponibles sur tous les serveurs Minion.
salt '*' pkg.refresh_db

# Vérifiez la liste des référentiels sur tous les serviteurs du serveur.
salt '*' pkg.list_repos

# Consultez la liste des mises à jour de packages disponibles sur tous les serveurs Minion.
salt '*' pkg.list_upgrades

#### Un autre excellent exemple ici est le module de service qui vous permet de gérer des services sur plusieurs distributions Linux, y compris la distribution avec systemd.
# Vérifiez si le service apache2 est disponible ou non.
salt '*' service.available apache2

# Activez le service apache2 pour qu'il démarre au démarrage du système sur tous les serveurs minion.
salt '*' service.enabled apache2

# Vérification de la liste des services en cours d'exécution sur tous les serveurs.
salt '*' service.get_running

# Vérifiez la commande ExecStart= pour chaque service disponible sur tous les serveurs.
salt '*' service.execs

# Afficher le stockage BTRFS des Serveurs LXC :
salt -N grp-srv-lxc cmd.run 'btrfs filesystem show'

4. Copie d'un fichier vers un minion :

# Copier récursivement un répertoire depuis le salt master 
salt '*' cp.get_dir salt://path/to/dir/ /minion/dest

# Copier un fichier vers les minions :
salt '*' cp.get_file salt://path/to/file /minion/dest
salt '*' cp.get_file "salt://{{grains.os}}/vimrc" /etc/vimrc template=jinja
salt 'nextcloud*' cp.get_file salt:/srv/salt/files/test.txt /home/adminme/test.txt

salt 'nextcloud.v.sdem.fr' cp.get_file salt://files/ssh-key-pub-listing-infra.txt /home/adminme/.ssh/authorized_keys

5. Déploiement des clés SSH :

############# Préparation des fichiers de conf :

# Création du dossier sshd_config.d s'il n'existe pas, le fichier sshd_config utilise l'include du dossier sshd_config.d
salt '*' cmd.run "mkdir /etc/ssh/sshd_config.d"

# Déploiement du fichier de gestion des clés SSH :
salt '*' cmd.run "rm -rf /etc/ssh/sshd_config.d/authorizedKeysFile.conf"
salt '*' cmd.run "echo "#AuthorizedKeysFile\nAuthorizedKeysFile     .ssh/authorized_keys-infra .ssh/authorized_keys-dev .ssh/authorized_keys-dev-apside\n " >> /etc/ssh/sshd_config.d/authorizedKeysFile.conf"

# Pour les Ubuntu 18.04, le Include du dossier sshd_config.d ne fonctionne pas :
vi /etc/ssh/sshd_config
# JKT - Ajout AuthorizedKeys :
AuthorizedKeysFile     .ssh/authorized_keys-infra .ssh/authorized_keys-dev .ssh/authorized_keys-dev-apside 

# Déploiement du fichier de configuration dédié guacamole uniquement sur les Ubuntu 22.04 'Jammy' :
salt -G 'oscodename:jammy' cmd.run 'echo "# JKT-20220517 - Connexion Guacamole :\nHostkeyAlgorithms +ssh-rsa\nPubkeyAcceptedAlgorithms +ssh-rsa\n " >> /etc/ssh/sshd_config.d/guacamole-auth-ssh.conf'

# Redémarrer le deamon SSHD :
salt '*' cmd.run 'service sshd restart'

--------------------------------------------------------------------------------------------------------------------------------------------
############# Déploiement des clés SSH :
# Options 1 - Accès service INFRA uniquement - Fichier -> .ssh/authorized_keys-infra :
salt '*' cp.get_file salt://files/authorized_keys-infra /home/adminme/.ssh/authorized_keys-infra
salt '*' cmd.run 'chown adminme:adminme /home/adminme/.ssh/*'

# Options 2 - Accès service DEV - Fichier -> .ssh/authorized_keys-dev :
# Utilisation du groupe de minion grp-srv-authorized_keys-dev
salt -N grp-srv-authorized_keys-dev cp.get_file salt://files/authorized_keys-dev /home/adminme/.ssh/authorized_keys-dev
salt -N grp-srv-authorized_keys-dev cmd.run 'chown adminme:adminme /home/adminme/.ssh/*'

# Options 3 - Accès service Prestataire DEV-APSIDE - Fichier -> .ssh/authorized_keys-dev-apside :
# Utilisation du groupe de minion grp-srv-authorized_keys-dev-apisde
salt -N grp-srv-authorized_keys-dev-apside cp.get_file salt://files/authorized_keys-dev-apside /home/adminme/.ssh/authorized_keys-dev-apside
salt -N grp-srv-authorized_keys-dev-apside cmd.run 'chown adminme:adminme /home/adminme/.ssh/*'

# Suppression de l'ancien fichier de configuration après déploiement des clés spécifiques :
salt '*' cmd.run 'rm /home/adminme/.ssh/authorized_keys'

6. Salt avec VMware :

Source

https://docs.vmware.com/fr/VMware-vRealize-Automation-SaltStack-Config/8.6/use-manage-saltstack-config-guide.pdf
https://docs.saltproject.io/salt/extensions/salt-ext-modules-vmware/en/latest/ref/modules/saltext.vmware.modules.vm.html

B - Gestion par script :

1. Description :

L'ensemble des scripts sont installés sur le serveur admin-l.v.sdem.fr dans /srv/salt/scripts/

Les scripts sont disponible dans git

1. Script de déploiement de Lynis :

Lynis est un outil de scan de vulnérabilité. Il est déployé automatiquement avec Salt sur l'ensemble du parc.

Emplacement du script : /srv/salt/scripts/

Nom du script : salt-deploy-lynis.sh

##############################################################
# Auteur : jkermorvant
# Date de modification : 20231115
#
# Description : Script de déploiement de l'outil de sca de vulnérabilité Lynis
#
##############################################################
#! /bin/bash
#
##############################################################
# Variables :

###################################
# Déploiement de l'outil de scan de vulnérabiloté Lynis :
salt '*' cp.get_file salt://files/lynis-3.0.9/lynis-3.0.9.tar.gz /tmp
salt '*' cmd.run 'tar -xzf /tmp/lynis-3.0.9.tar.gz -C /usr/local'
salt '*' cmd.run 'chmod +x /usr/local/lynis/lynis'
salt '*' cmd.run 'ln -s /usr/local/lynis/lynis /usr/local/bin'

# Démarrage du scan de vulnérabilité :
salt '*' cmd.run 'sudo lynis audit system'

# Récupération des logs vers le dossier /var/cache/salt/master/minions/minion-id/files :
# Prérequis :
# Source : https://docs.saltproject.io/en/latest/ref/modules/all/salt.modules.cp.html#salt.modules.cp.push
# Allow minions to push files to the master. This is disabled by default, for security purposes.
# file_recv: False -> True
# Restart Salt-Master
salt '*' cp.push /var/log/lynis.log
salt '*' cp.push /var/log/lynis-report.dat

1. Script de déploiement de la supervision :

Ce script permet de déployer la supervision sur une machine spécifique Linux.

Emplacement du script : /srv/salt/scripts/

Nom du script : salt-deploy-supervision.sh

#############################################################
# Auteur : jkermorvant
# Date de modification : 20231115
#
# Description : Script de déploiement de la supervision NAGIOS
#
##############################################################
#! /bin/bash
#
##############################################################
# Variables :
ARG=N
DEST=grp-srv-deploy-labs

# Déclaration du serveur
SERVER=web01
DOMAIN=.v.sdem.fr

# Déclaration de l'adresse IP du serveur
IP1=192
IP2=168
IP3=1
IP4=219

# Déclaration du serveur de supervision
SUPERVISION=supervision.v.sdem.fr

###################################
# Installation et configuration de l'agent NRPE sur le serveur cible

# Installation du paquet NRPE :
salt ${SERVER}${DOMAIN} pkg.install nagios-nrpe-server nagios-plugins

# Déploiement des fichiers de configuration sur le serveur à superviser :
salt ${SERVER}${DOMAIN} cp.get_file salt://files/supervision/nrpe.cfg /etc/nagios
salt ${SERVER}${DOMAIN} cp.get_file salt://files/supervision/check_mem /usr/lib/nagios/plugins/

# Redémarrage du service nagios-nrpe :
salt ${SERVER}${DOMAIN} cmd.run 'service nagios-nrpe-server restart'

###################################
# Déployer le fichier de configuration Nagios sur le serveur de supervision

# Déploiement du fichier de configuration sur le serveur de supervision :
cp /srv/salt/files/supervision/template.v.sdem.fr.cfg /srv/salt/files/supervision/files-config/${SERVER}${DOMAIN}.cfg

# Paramétrage du fichier de configuration Nagios - Remplacement du nom :
for file in /srv/salt/files/supervision/files-config/${SERVER}${DOMAIN}.cfg
do
  echo "Traitement de ${file} ..."
  sed -i -e "s/template\.v\.sdem\.fr/${SERVER}\.v\.sdem\.fr/g" "${file}"
done

# Paramétrage du fichier de configuration Nagios - Remplacement de l'adresse IP :
for file in /srv/salt/files/supervision/files-config/${SERVER}${DOMAIN}.cfg
do
  echo "Traitement de $file ..."
  sed -i -e "s/192\.168\.1\.XXX/${IP1}\.${IP2}\.${IP3}\.${IP4}/g" "${file}"
done

# Déploiement du fichier de configuration sur le serveur de supervision :
salt ${SUPERVISION} cp.get_file salt://files/supervision/files-config/${SERVER}${DOMAIN}.cfg /usr/local/nagios/etc/objects/sdem/

# Application des droits sur le fichier :
salt ${SUPERVISION} cmd.run "chown sdem:sdem /usr/local/nagios/etc/objects/sdem/${SERVER}${DOMAIN}.cfg"

# Redémarrage du service nagios-nrpe :
salt ${SUPERVISION} cmd.run "sudo systemctl restart nagios.service"

1. Script de mise à jour de Metabase sur Dataviz :

Ce script permet de déployer la mise à jour de Metabase sur les serveurs

Emplacement du script : /srv/salt/scripts/

Nom du script : salt-deploy-supervision.sh

##############################################################
# Auteur : jkermorvant
# Date de modification : 20231215
#
# Description : Script de mise à jour de Metabase
#
##############################################################
#! /bin/bash
#
##############################################################
# Variables :
SERVER=dataviz-dev.v.sdem.fr
VERSION=0.47.9

##############################################################
# 1 - Executer le script de dump postgresql
salt ${SERVER} cmd.run "sudo -u postgres pg_dump upciti_db > /backup/postgresql/upciti_db_bck"

# 2 - Stopper le service
salt ${SERVER} cmd.run "sudo systemctl stop metabase.service"

# 3 - Télécharger metabase.jar dans le répertoire d'installation (VERSION = 0.47.8 actuellement)
salt ${SERVER} cmd.run "sudo rm /data/metabase_data/metabase.jar"
salt ${SERVER} cmd.run "sudo wget -P /data/metabase_data https://downloads.metabase.com/v${VERSION}/metabase.jar"
salt ${SERVER} cmd.run "chown -R metabase_usr:metabase_grp /data/metabase_data/metabase.jar"

# 4 - Démarrer Metabase
salt ${SERVER} cmd.run "systemctl start metabase.service"
salt ${SERVER} cmd.run "systemctl status metabase.service"

SaltProject

telechargement - lufi

A - Création du conteneur LXC

1. Configuration du serveur :

Nom LXC : TELECHARGEMENT
Adresse IP (réseau non rroté LXC) : 192.168.25.160
Nom DNS Interne : telechargement.v.sdem.fr
Nom DNS Externe : telechargement.morbihan-energies.fr
URL : telechargement.morbihan-energies.fr
Reverse Proxy : telechargement.morbihan-energies.fr
OS : Ubuntu 22.04

Rôle :

Serveur de transfert de fichiers volumineux

1. Création d'un CT :

Le container est installé sur le serveur LXC01.v.sdem.fr

# Déclarer la variable :
CTNAME=TELECHARGEMENT
# Création du conteneur :
lxc launch ubuntu:22.04 $CTNAME

# Configurer l'autostart d'un CT :
lxc config set $CTNAME boot.autostart true

2. Paramétrage :

Editer le fichier de configuration afin de paramétrer une adresse IP fixe et le forward de port.

Configuration réseau et forward de port :

Il est nécessaire de bien renseigner le fichier de zone DNZ "lxc.morbihan-energies.fr" afin d'attribuer une adresse IP sur le réseau LXC (non routé).

# Editer le fichier de configuration :
lxc config edit $CTNAME

Ajouter les lignes suivantes :

  devices:
    eth0:
      ipv4.address: 192.168.25.160
      name: eth0
      network: lxdbr0
      type: nic
  port53087:
      connect: tcp:0.0.0.0:80
      listen: tcp:192.168.1.31:53087
      type: proxy

B - Paramétrage :

1. Gestion date et heure :

# Changer la date :
date -s "02/18/2017 12:34:00"

# Changer le fuseau horaire :
rm /etc/localtime
ln -s /usr/share/zoneinfo/Europe/Paris /etc/localtime
# Pour que le changement de fuseau survive au redémarrage de la machine, il faut aussi le mettre dans le bon fichier.
vi /etc/timezone
ZONE="Europe/Paris"

2. Documentations :

https://framacloud.org/fr/cultiver-son-jardin/lufi
https://framagit.org/fiat-tux/hat-softwares/lufi/-/wikis/installation

3. Prérequis :

Prérequis :

Lufi est codé en Perl, pour le faire fonctionner il est nécessaire d’installer Carton, un gestionnaire de modules Perl.

apt-get install build-essential libpq-dev
cpan Carton

carton est un outil en ligne de commande pour suivre les dépendances du module Perl pour votre application Perl.
Les dépendances requises sont gérées via un fichier nommé cpanfile et suivies via le fichier carton.lock.
Cela facilite les déploiements et permet aux autres développeurs de votre application d'avoir exactement les mêmes versions des modules.

C - Installation des prérequis

Configuration réseau :

Nom DNS : telechargement.morbihan-energies.fr

Type de serveur : CT LXC

Adresse IP : 192.168.25.160
DNS : 192.168.1.50
Distrib : Ubuntu 22.04

Documentations :

L'ensemble de l'installation se fait en root.

D - Installation

2. Installation de LUFI :

Tout d’abord, connectez-vous en tant que root sur votre serveur et créez un compte utilisateur lufi ainsi que le dossier /var/www/html/lufi dans lequel seront copiés les fichiers avec les droits d’accès correspondants.

useradd lufi
mkdir /home/lufi
chown -R lufi:lufi /home/lufi

mkdir /var/www/lufi
# chown -R www-data: /var/www/lufi
chown -R www-data:www-data /var/www/lufi

Téléchargez les fichiers de la dernière version sur le dépôt officiel (« Download zip » en bas à droite ou bien en ligne de commande avec git).
Copiez son contenu dans le dossier /var/www/html/lufi et attribuez les droits des fichiers à l’utilisateur lufi

cd /var/www
git clone https://framagit.org/fiat-tux/hat-softwares/lufi.git
chown lufi:lufi -R /var/www/lufi

Connectez-vous avec l’utilisateur lufi : su lufi -s /bin/bash et lancez la commande d’installation des dépendances depuis le dossier

su lufi -s /bin/bash
cd /var/www/lufi
carton install
exit

Maintenant que tout est prêt, modifiez le fichier de configuration de Lufi lufi.conf avec votre éditeur de texte préféré sur le modèle du fichier lufi.conf.template.
Par défaut le logiciel est configuré pour écouter sur le port 8080 de l'adresse 127.0.0.1 (localhost).

cp lufi.conf.template lufi.conf
vi lufi.conf

L’ensemble des paramètres sont facultatifs à l'exception du paramètre contact (pensez bien à le configurer et à le décommenter).
Si vous utilisez Lufi derrière un serveur web comme Nginx (comme dans ce tutoriel), pensez bien à décommenter le paramètre proxy => 1,.

A ce stade de l'installation, il n'est plus nécessaire de se connecter avec l'utilisateur spécifiquement créé lufi. Afin d'améliorer la sécurité, on empêchera à présent la possibilité de se connecter à celui-ci avec la commande.

usermod -s /bin/false lufi

Lufi en tant que service
À présent, le serveur tournera lorsque qu’on lancera cette commande :

carton exec hypnotoad script/lufi

Pour éviter de devoir relancer le serveur à la main à chaque redémarrage du serveur, on va donc lancer Lufi sous forme de service. Deux possibilités s'offrent alors :

3. Démarrage auto pour InitV :

Démarrage auto pour Systemd :

cp utilities/lufi.service /etc/systemd/system

Modifiez ce fichier pour qu'il corresponde à votre installation (User=lufi, WorkingDirectory=/var/www/lufi, …)

vi /etc/systemd/system/lufi.service

Faites en sorte que Systemd le prenne en compte

systemctl daemon-reload

Et qu'il le lance à chaque démarrage

systemctl enable lufi.service

4. Paramétrage :

À ce stade, si tout s’est bien passé, lorsque vous exécutez la commande service lufi start, Lufi est pleinement fonctionnel. Vous n’avez qu’à vous rendre sur l’URL http://127.0.0.1:8080 pour pouvoir l’utiliser.
Nous allons maintenant configurer Lufi pour le rendre accessible depuis un nom de domaine avec Nginx (vous pouvez également utiliser Apache ou Varnish puisque seule la fonctionnalité de proxy inverse nous intéresse).

Nginx :

Installez le paquet :

apt-get install nginx

Créez le fichier de configuration de votre domaine /etc/nginx/sites-available/votre-nom-de-domaine pour y mettre ceci (en remplaçant « votre-nom-de-domaine ») et le port 8080 si vous l’avez changé dans la configuration de Lufi :

vi /etc/nginx/sites-available/telechargement.morbihan-energies.fr.conf

server { listen 80;

    server_name telechargement.morbihan-energies.fr;

    access_log /var/log/nginx/telechargement.success.log;
    error_log /var/log/nginx/telechargement.error.log;

    location / {
        # Add cache for static files
        if ($request_uri ~* ^/(img|css|font|js)/) {
            add_header Expires "Thu, 31 Dec 2037 23:55:55 GMT";
            add_header Cache-Control "public, max-age=315360000";
        }
        # HTTPS only header, improves security
        #add_header Strict-Transport-Security "max-age=15768000";

        # Adapt this to your configuration
        proxy_pass  http://127.0.0.1:8082;

        # Really important! Lufi uses WebSocket, it won't work without this
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";

        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

        # If you want to log the remote port of the file senders, you'll need that
        proxy_set_header X-Remote-Port $remote_port;

        proxy_set_header X-Forwarded-Proto $scheme;

        # We expect the downstream servers to redirect to the right hostname, so don't do any rewrites here.
        proxy_redirect     off;
    }
}

Activez votre fichier :

ln -s /etc/nginx/sites-available/telechargement.morbihan-energies.fr.conf /etc/nginx/sites-enabled/telechargement.morbihan-energies.fr.conf

Enfin, relancez nginx :

/etc/init.d/nginx restart

B - Personnalisation :

1. Gestion des Logos :

Emplacement des logos : /var/www/lufi/themes/default/public/img
Liste des logos à configurer en 24x24 Pixels :

    - favicon.png
    - lufi-min.png
    - lufi_favicon.png

2. Gestion des thèmes :

Pour personnaliser votre instance de Lufi, il faut lancer la commande carton :

exec script/lufi theme morbihan-energies

Ce qui créera un nouveau dossier "themes/votre-theme".
Il contiendra un fichier "Makefile", un fichier "lib/Lufi/I18N.pm" ainsi que des dossiers vides pour vous montrer le « squelette » d'un thème.
Ensuite il ne vous reste plus qu'à copier les fichiers du thème default dans votre dossier de thème et à les adapter à votre gré. Vous pouvez ainsi modifier les fichiers css, images, javascript (dossier public), les modèles de pages (dossier templates) et même la traduction en conservant un thème propre sur lequel basculer en cas de problème.

3. Modification de la traduction :

Le cas de la modification des traductions est un peu particulier :

Si vous souhaitez ajouter des chaînes de caractères traduites dans votre thème, ajoutez-les dans les fichiers du dossier "templates" en prenant exemple sur le thème par défaut (<%= l('Ceci est une chaîne traduite') %>) puis exécutez "make locales" depuis votre dossier de thème (themes/votre-theme, pas depuis le dossier d'installation de Lufi).
Il vous restera alors à ajouter la traduction dans les fichiers présents dans "themes/votre-theme/lib/Lufi/I18N/".
si vous souhaitez modifier une traduction, repérez la chaîne dans les fichiers de "themes/default/lib/Lufi/I18N/", puis recopiez les lignes commençant par msgid et msgstr qui s'y rapportent (ne copiez surtout pas les commentaires qui s'y rapportent). Enfin, modifiez la traduction (le contenu de msgstr) dans vos fichiers.
Modifiez ensuite le fichier "lufi.conf" pour préciser quel thème vous utilisez. Pour pouvoir personnaliser et observer vos modifications en direct, il vous faudra stopper temporairement le service service lufi stop et le démarrer avec la commande :

carton exec morbo script/lufi --listen=http://127.0.0.1:8080

C - lufi.conf

Contenu du fichier lufi.conf :
Emplacement :

# vim:set sw=4 ts=4 sts=4 ft=perl expandtab:
{ 
    ####################
    # Hypnotoad settings
    ####################
    # see http://mojolicio.us/perldoc/Mojo/Server/Hypnotoad for a full list of settings
    hypnotoad => {
        # array of IP addresses and ports you want to listen to
        # you can specify a unix socket too, like 'http+unix://%2Ftmp%2Flufi.sock'
        listen => ['http://127.0.0.1:8082'],
        # if you use Lufi behind a reverse proxy like Nginx, you want to set proxy to 1
        # if you use Lufi directly, let it commented
        proxy  => 1,

        # Please read http://mojolicious.org/perldoc/Mojo/Server/Hypnotoad#workers
        # to adjust this to your server
        workers => 30,
        clients => 1,
    },

    # Put a way to contact you here and uncomment it
    # You can put some HTML in it
    # MANDATORY
    contact       => '<a href="https://morbihan-energies.fr/contact/">Contact page</a>',

    # Put an URL or an email address to receive file reports and uncomment it
    # It's for make reporting illegal files easy for users
    # MANDATORY
    report => 'telechargement@morbihan-energies.fr',

    # Array of random strings used to encrypt cookies
    # optional, default is ['fdjsofjoihrei'], PLEASE, CHANGE IT
    #secrets        => ['fdjsofjoihrei'],

    # Name of the instance, displayed next to the logo
    # optional, default is Lufi
    instance_name => 'Telechargement.morbihan-energies.fr',

    # Choose a theme. See the available themes in `themes` directory
    # Optional, default is 'default'
    #theme         => 'default',

    # Length of the random URL
    # optional, default is 8
    #length            => 8,

    # How many URLs will be provisioned in a batch ?
    # optional, default is 5
    #provis_step       => 5,

    # Max number of URLs to be provisioned
    # optional, default is 100
    #provisioning      => 100,

    # Length of the modify/delete token
    # optional, default is 32
    #token_length      => 32,

    # Max file size, in octets
    # You can write it 100*1024*1024
    # optional, no default
    #max_file_size     => 104857600,
    # JKT - Config 4Go
    max_file_size      => 4294967296,
    # If you want to have piwik statistics, provide a piwik image tracker
    # Only the image tracker is allowed, no javascript
    # optional, no default
    #piwik_img         => 'https://piwik.example.org/piwik.php?idsite=1&amp;rec=1',

    # Broadcast_message which will displayed on the index page
    # optional, no default
    #broadcast_message => 'Maintenance',

    # Default time limit for files
    # Valid values are 0, 1, 7, 30 and 365
    # optional, default is 0 (no limit)
    #default_delay     => 0,

    # Number of days after which the files will be deleted, even if they were uploaded with "no delay" (or value superior to max_delay)
    # A warning message will be displayed on homepage
    # optional, default is 0 (no limit)
    max_delay         => 30,

    # Size thresholds: if you want to define max delays for different sizes of file
    # The keys are size in Bytes, you can't have 10*1000*10000 as key
    # If a file is smaller than the smallest configured size, it will have a expiration delay of max_delay (see above)
    # optional, default is using max_delay (see above) for all sizes
    #delay_for_size  => {
    #    10000000   => 90, # between 10MB and 50MB => max is 90 days, less than 10MB => max is max_delay (see above)
    #    50000000   => 60, # between 50MB ans 1GB  => max is 60 days
    #    1000000000 => 2,  # more than 1GB         => max is 2 days
    #},

    # URL sub-directory in which you want Lufi to be accessible
    # example: you want to have Lufi under https://example.org/lufi/
    # => set prefix to '/lufi' or to '/lufi/', it doesn't matter
    # optional, defaut is /
    #prefix        => '/',

    # Array of authorized domains for API calls.
    # If you want to authorize everyone to use the API: ['*']
    # optional, no domains allowed by default
    #allowed_domains => ['http://1.example.com', 'http://2.example.com'],

    # String of the URL to be redirected to when accessing /logout
    # optional, default is no redirection after logging out
    #logout_custom => 'https://sso.example.com/logout?redirect_uri=https%3A%2F%2Fexample.com',

    # Define a path to the upload directory, where the uploaded files will be stored
    # You can define it relative to lufi directory or set an absolute path
    # Remember that it has to be in a directory writable by Lufi user
    # optional, default is 'files'
    #upload_dir => 'files',

    #!!!!!!!!!!!!!!!
    # EXPERIMENTAL !
    #!!!!!!!!!!!!!!!
    # You can store files on Swift object storage (https://en.wikipedia.org/wiki/OpenStack#Swift) instead of filesystem
    # Please read https://metacpan.org/pod/Net::OpenStack::Swift#SYNOPSIS to know how to configure this setting
    # IMPORTANT: add a `container` key in it, to let Lufi know which container to use. This is not a regular Net::OpenStack::Swift setting, but Lufi need it.
    # EXPERIMENTAL: if the upload or download of files are stucked, reload Lufi and create a cron task to reload Lufi once a day
    # You can copy Lufi files to Swift object storage by launching the command `carton exec script/lufi copyFilesToSwift` (can take a long time)
    # optional, no default
    #swift => {
    #  auth_url    => 'https://auth-endpoint-url/v2.0',
    #  user        => 'userid',
    #  password    => 'password',
    #  tenant_name => 'project_id',
    #  container   => 'lufi'
    #},

    # Allow to add a password on files, asked before allowing to download files
    # optional, default is 0
    #allow_pwd_on_files => 0,

    # Force all files to be in "Burn after reading mode"
    # optional, default is 0
    #force_burn_after_reading => 0,

    # If set, the files' URLs will always use this domain
    # optional, no default
    #fixed_domain => 'example.org',

    # Abuse reasons
    # Set an integer in the abuse field of a file in the database and it will not be downloadable anymore
    # The reason will be displayed to the downloader, according to the reasons you will configure here.
    # optional, no default
    #abuse => {
    #   0 => 'Copyright infringment',
    #   1 => 'Illegal content',
    #},

    ###############
    # Mail settings
    ###############

    # Mail configuration
    # See https://metacpan.org/pod/Mojolicious::Plugin::Mail#EXAMPLES
    # optional, default to sendmail method with no arguments
    mail => {
    #    # Valid values are 'sendmail' and 'smtp'
        how => 'smtp',
        howargs => ['relais.v.sdem.fr']
    },

    # Email sender address
    # optional, default to no-reply@lufi.io
    mail_sender => 'hostmaster@morbihan-energies.fr',

    #############
    # DB settings
    #############

    # Choose what database you want to use
    # Valid choices are sqlite, postgresql and mysql (all lowercase)
    # optional, default is sqlite
    #dbtype => 'sqlite',

    # SQLite ONLY - only used if dbtype is set to sqlite
    # Define a path to the SQLite database
    # You can define it relative to lufi directory or set an absolute path
    # Remember that it has to be in a directory writable by Lufi user
    # optional, default is lufi.db
    #db_path           => 'lufi.db',

    # PostgreSQL ONLY - only used if dbtype is set to postgresql
    # These are the credentials to access the PostgreSQL database
    # mandatory if you choosed postgresql as dbtype
    #pgdb => {
    #    database => 'lufi',
    #    host     => 'localhost',
    #    # optional, default is 5432
    #    #port     => 5432,
    #    user     => 'DBUSER',
    #    pwd      => 'DBPASSWORD',
    #    # https://mojolicious.org/perldoc/Mojo/Pg#max_connections
    #    # optional, default is 1
    #    #max_connections => 1,
    #},

    # MySQL ONLY - only used if dbtype is set to mysql
    # These are the credentials to access the MySQL database
    # mandatory if you choosed mysql as dbtype
    #mysqldb => {
    #    database => 'lufi',
    #    host     => 'localhost',
    #    # optional, default is 3306
    #    #port     => 3306,
    #    user     => 'DBUSER',
    #    pwd      => 'DBPASSWORD',
    #    # https://metacpan.org/pod/Mojo::mysql#max_connections
    #    # optional, default is 5 (set to 0 to disable persistent connections)
    #    #max_connections => 5,
    #},

    #############################################
    # LDAP settings (authentication and features)
    #############################################

    # Set `ldap` if you want that only authenticated users can upload files
    # Please note that everybody can still download files
    # optional, no default
    #ldap => {
    #    uri         => 'ldaps://ldap.example.org',                 # server URI
    #    user_tree   => 'ou=users,dc=example,dc=org',               # search base DN
    #    bind_dn     => 'uid=ldap_user,ou=users,dc=example,dc=org', # search bind DN
    #    bind_pwd    => 'secr3t',                                   # search bind password
    #    user_attr   => 'uid',                                      # user attribute (uid, mail, sAMAccountName, etc.)
    #    user_filter => '(!(uid=ldap_user))',                       # user filter (to exclude some users, etc.)
    #    # optional start_tls configuration. See https://metacpan.org/pod/distribution/perl-ldap/lib/Net/LDAP.pod#start_tls
    #    # don't set or uncomment if you don't want to configure it
    #    start_tls => {
    #       verify     => 'optional',
    #       clientcert => '/etc/ssl/certs/ca-bundle.pem'
    #    }
    #},

    # If you've set ldap above, the session will last `session_duration` seconds before
    # the user needs to reauthenticate
    # optional, default is 3600
    #session_duration => 3600,

    # If you use `ldap` for authentication, you can map some attributes from LDAP to be able to access them in Lufi
    # Those attributes will be accessible with:
    #   $c->current_user->{lufi_attribute_name} in Lufi backend files (all that is in `lib` directory)
    #   <%= $self->current_user->{lufi_attribute_name} %> in templates files (in `themes` directory)
    #
    # Define the attributes like this: `lufi_attribute_name => 'LDAP_attribute_name'`
    # Note that you can’t use `username` as a Lufi attribute name: this name is reserved and will contain the login of the user
    # optional, no default
    #ldap_map_attr => {
    #    displayname => 'cn',
    #    mail        => 'mail'
    #},

    # When using LDAP authentication, LDAP users can invite people (by mail) to use Lufi to send them files without
    # being authenticated.
    # This is where you configure the behavior of the invitations.
    # You may need to fetch some attributes from LDAP to use some invitations settings. See `ldap_map_attr` above.
    # optional, no default
    #invitations => {
    #   # The name of the key set in `ldap_map_attr` (above) that corresponds to the mail of the LDAP user
    #   # optional, default is `mail`
    #   mail_attr => 'mail',
    #   # The `From` header of invitation mail can be the mail of the LDAP user
    #   # Be sure to have a mail system that will correctly send the mail from your users! (DKIM, SPF…)
    #   # To enable this feature, set it to 1
    #   # optional, disabled by default
    #   send_invitation_with_ldap_user_mail => 1,
    #   # The user is able to set an expiration delay for the invitation.
    #   # This expiration delay can’t be more than this setting (in days).
    #   # optional, default is 30 days
    #   max_invitation_expiration_delay => 30,
    #   # Once the guest has submitted his files, he has an additional period of time to submit forgotten files.
    #   # You can set that additional period of time in minutes here.
    #   # To disable that feature, set it to 0 or less
    #   # optional, default is 10 minutes
    #   max_additional_period => 10,
    #   # Lufi follows privacy-by-design, so, by default, no files URLs (with the decode secret) are stored in database.
    #   # However, the concern is different for this case. Storing files URLs makes users able to retrieve the guests’ sent files
    #   # from their `invitations` page.
    #   # Set to 1 to store guests’ files URLs in database
    #   # optional, default is 0 (disabled)
    #   save_files_url_in_db => 0,
    #   # Users can resend the invitation to their guest. This does not extend the invitation’s expiration delay unless you
    #   # set this option to 1.
    #   # optional, default is 0 (disabled)
    #   extend_invitation_expiration_on_resend => 0,
    #},

    #########################
    # Htpasswd authentication
    #########################

    # Set `htpasswd` if you want to use an htpasswd file instead of ldap
    # See 'man htpasswd' to know how to create such file
    #htpasswd => 'lufi.passwd',

    #######################
    # HTTP Headers settings
    #######################

    # Content-Security-Policy header that will be sent by Lufi
    # Set to '' to disable CSP header
    # https://content-security-policy.com/ provides a good documentation about CSP.
    # https://report-uri.com/home/generate provides a tool to generate a CSP header.
    # optional, default is "base-uri 'self'; connect-src 'self' ws://YOUR_HOST; default-src 'none'; font-src 'self'; form-action 'self'; frame-ancestors 'none'; img-src 'self' blob:; media-src blob:; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline'"
    #csp => "",

    # X-Frame-Options header that will be sent by Lufi
    # Valid values are: 'DENY', 'SAMEORIGIN', 'ALLOW-FROM https://example.com/'
    # Set to '' to disable X-Frame-Options header
    # See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options
    # Please note that this will add a "frame-ancestors" directive to the CSP header (see above) accordingly
    # to the chosen setting (See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors)
    # optional, default is 'DENY'
    #x_frame_options => 'DENY',

    # X-Content-Type-Options that will be sent by Lufi
    # See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Content-Type-Options
    # Set to '' to disable X-Content-Type-Options header
    # optional, default is 'nosniff'
    #x_content_type_options => 'nosniff',

    # X-XSS-Protection that will be sent by Lufi
    # See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-XSS-Protection
    # Set to '' to disable X-XSS-Protection header
    # optional, default is '1; mode=block'
    #x_xss_protection => '1; mode=block',

    #########################
    # Lufi cron jobs settings
    #########################

    # Expired files will be kept for 2 additional days after the expiration time has passed!
    # The reasoning behind this is to allow downloads to complete and avoid deleting them while
    # they are still being tranfered.

    # Number of days senders' IP addresses are kept in database
    # After that delay, they will be deleted from database (used with script/lufi cron cleanbdd)
    # optional, default is 365
    #keep_ip_during    => 365,

    # Max size of the files directory, in octets
    # Used by script/lufi cron watch to trigger an action
    # optional, no default
    #max_total_size    => 10*1024*1024*1024,

    # Default action when files directory is over max_total_size (used with script/lufi cron watch)
    # Valid values are 'warn', 'stop-upload' and 'delete'
    # Please, see README.md
    # optional, default is 'warn'
    #policy_when_full  => 'warn',

    # Files which are not viewed since delete_no_longer_viewed_files days will be deleted by the cron cleanfiles task
    # If delete_no_longer_viewed_files is not set, the no longer viewed files will NOT be deleted
    # optional, no default
    #delete_no_longer_viewed_files => 90,
};

E - ProFTPd

Serveur FTP :

Un serveur FTP est configuré pour répondre à plusieurs besoins interne nottamment par le servie Energies.
Nom de connexion : ftp.morbihan-energies.fr
Port : 21

MK-Keepass

01 - Description

A - Description :

1. Sources :

https://ssd.eff.org/fr/module/guide-pratique-utiliser-keepassxc

https://atelier-mediatheque.rlv.eu/blog/gerez-vos-mots-de-passe-avec-keepassxc/KeePassXC%20sous%20Windows.pdf

https://www.it-connect.fr/comment-gerer-ses-mots-de-passe-avec-keepass-ou-keepassxc/#F_Les_plugins_KeePass

OS : Windows 7 ou ultérieur, Linux, macOS 10.7 ou ultérieur

2. Rôle :

KeePassXC est un gestionnaire de mot de passe multiplateforme qui vous permet d’enregistrer tous vos mots de passe au même endroit. Un gestionnaire de mots de passe est un outil qui crée et enregistre des mots de passe pour vous. Vous pouvez ainsi utiliser de nombreux mots de passe différents sur des sites et services différents sans avoir à les mémoriser. Vous n’avez qu’à mémoriser un mot de passe maître qui vous permet d’accéder à la base de données chiffrée du gestionnaire de mots de passe contenant tous vos mots de passe.

MK-Keepass

02 - Installation

A - Préparation :

1. Téléchargement :

Le programme d'installation Windows MSI est signé par un certificat sécurisé appartenant à DroidMonkey Apps, LLC. Si vous ne voyez pas cette boîte de dialogue lors de l'installation de l'application, cliquez sur NON et téléchargez le programme d'installation depuis https://keepassxc.org .

B - Déroulement :

1. Installation :

Double-cliquez sur le fichier KeePassXC-YYY-WinZZ.msi. Ici, YYY représente la version du logiciel et ZZ représente la version 32 bits/64 bits du système d'exploitation Microsoft Windows.

Cliquez sur Suivant et suivez les instructions simples de l'assistant d'installation KeepPassXC pour terminer l'installation. Vous aurez la possibilité de choisir votre emplacement d'installation, d'ajouter un raccourci sur le bureau et de lancer au démarrage.

2. Création d'une base de donnée :

Ouvrez votre application KeePassXC. Cliquez sur le bouton Créer une nouvelle base de données (A) :

L'assistant de création de base de données apparaît. Saisissez le nom de la base de données souhaitée et une brève description (facultatif) :

Cliquez sur Continuer. L'écran Paramètres de cryptage apparaît. Nous vous déconseillons d'apporter des modifications autres que l'augmentation ou la diminution du temps de décryptage à l'aide du curseur. Régler le curseur "Temps de décryptage" sur des valeurs plus élevées signifie que la base de données bénéficiera d'un niveau de protection plus élevé, mais que le temps nécessaire à l'ouverture de la base de données augmentera.

Cliquez sur le bouton Continuer. L'écran Informations d'identification de la base de données apparaît, entrez le mot de passe de la base de données souhaité. Nous vous recommandons d'utiliser un mot de passe long et aléatoire.

(A) Ouvrez le générateur de mot de passe
(B) Basculez la visibilité du mot de passe

3. Ouverture d'une base de données existante :

Ouvrez votre application KeePassXC. Cliquez sur le bouton Ouvrir une base de données existante (A) ou sélectionnez une base de données récente dans la liste Bases de données récentes (B) .

Accédez à l'emplacement de la base de données sur votre ordinateur et ouvrez le fichier de base de données. L'écran de déverrouillage de la base de données apparaîtra : il ne reste plus cas entré votre mot de passe de base de données.

MK-Keepass

03 -Exploitation

A - Interface :

1. Disposition de l'application :

L'interface KeePassXC est conçue pour la simplicité et un accès facile à vos informations. La vue principale de la base de données est divisée en quatre partitions principales détaillées ci-dessous. Vous pouvez ouvrir plusieurs bases de données en même temps, elles apparaîtront dans des onglets.

(A) Groupes – Organisez vos entrées en groupes discrets pour mettre de l’ordre dans toutes vos informations sensibles. Les groupes peuvent être imbriqués les uns sous les autres pour créer une hiérarchie. Les paramètres des groupes de parents sont appliqués à leurs enfants. Vous pouvez masquer ce panneau dans le menu Affichage.

(B) Balises – Groupes dynamiques d’entrées pouvant être affichées rapidement en un seul clic. N'importe quel nombre de balises personnalisées peuvent être ajoutées lors de la modification d'une entrée. Ce panneau comprend également des recherches prédéfinies utiles, telles que la recherche de mots de passe expirés et faibles.

(C) Entrées – Les entrées contiennent toutes les informations que vous souhaitez stocker pour un site Web ou une application que vous stockez dans KeePassXC. Cette vue affiche toutes les entrées du groupe sélectionné. Chaque colonne peut être redimensionnée, réorganisée et affichée ou masquée selon vos préférences. Cliquez avec le bouton droit sur la ligne d'en-tête pour voir toutes les options disponibles.

(D) Aperçu – Affiche un aperçu du groupe ou de l'entrée sélectionné. Vous pouvez masquer temporairement cet aperçu à l'aide du bouton de fermeture situé à droite ou le désactiver complètement dans les paramètres de l'application.

Ici l'interface est en Anglais mais KeePassXC est nativement disponible en français.

2. Barre d'outils :

La barre d'outils fournit un moyen rapide d'effectuer des tâches courantes avec votre base de données. Certaines entrées de la barre d'outils sont désactivées dynamiquement en fonction des informations contenues dans l'entrée sélectionnée. Chaque action courante dans KeePassXC peut également être contrôlée avec un raccourci clavier.

(A) Base de données – Ouvrir la base de données, enregistrer la base de données, verrouiller
(B) Entrées de la base de données – Créer une entrée, modifier l'entrée, supprimer les entrées sélectionnées
(C) Données d'entrée – Copier le nom d'utilisateur, copier le mot de passe, copier l'URL, effectuer la saisie automatique
(D) Outils – Générateur de mot de passe,
recherche des paramètres d’application (E)

B - Utilisation :

1. Ajouter un entrée :

Tous les détails tels que les noms d'utilisateur, les mots de passe, les URL, les pièces jointes, les notes, etc. sont stockés dans les entrées de la base de données. Vous pouvez créer autant d'entrées que vous le souhaitez dans la base de données.

Pour ajouter une entrée, effectuez l'étape suivante :

Accédez à Entrées > Nouvelle entrée (ou appuyez sur Ctrl+N). L'écran suivant apparaît :

Entrez le titre souhaité pour l'entrée, le nom d'utilisateur, le mot de passe, l'URL et les notes sur cet écran.

2. Générateur de mot de passe :

Ce générateur de mots de passe vous aide à générer des mots de passe et des phrases secrètes aléatoires et forts que vous pouvez utiliser pour vos applications et sites Web que vous visitez.

Pour générer des mots de passe aléatoires, spécifiez les caractères à utiliser dans votre choix de mot de passe (par exemple, lettres majuscules, chiffres, caractères spéciaux, etc.) et KeePassXC sélectionnera au hasard les caractères dans l'ensemble.

Pour générer le mot de passe aléatoire à l'aide de Password Generator, effectuez les étapes suivantes :

Accédez à Outils > Générateur de mots de passe. L'écran suivant apparaît :
Sélectionnez la longueur du mot de passe souhaité en faisant glisser le curseur Longueur.
Sélectionnez les jeux de caractères que vous souhaitez inclure dans votre mot de passe.
Utilisez le bouton régénérer (Ctrl + R) pour créer un nouveau mot de passe en utilisant les options choisies.
Utilisez le bouton du presse-papiers (Ctrl + C) pour copier le mot de passe généré dans le presse-papiers.

D - Les Plugins :

1. KeepassXC Browser :

Le gestionnaire de mots de passe KeePassXC peut s’intégrer aux navigateurs internet basés sur Chromium comme Google Chrome, Vivaldi, Brave ou encore Microsoft Edge. L’intégration de KeePassXC aux autres navigateurs basés sur Chromium se fait avec l’ajout de l’extension KeePassXC-Browser dans le navigateur. Elle est disponible sur le chrome web store (Google Chrome, Chromium, Vivaldi ou Brave) et le site d'extension pour Microsoft Edge.

1.1 - Paramétrage sur KeepassXC

Avant d’installer ce module supplémentaire à votre navigateur, il faut au préalable activer cette possibilité d’intégration dans le gestionnaire de mot de passe.

Allez dans les paramètres du gestionnaire :

Alors, dans la section Intégration aux navigateurs (1) :

Activez l’option pour l’activer (2)
Cochez Google Chrome, Chromium, ou autres (3). Vous pouvez aussi adapter les autres options à votre convenance.
Cliquez sur le lien correspondant au navigateur où l’installer (4) pour ouvrir la page de l’extension KeePassXC-Browser dans votre navigateur web.
Et surtout, avant d’aller plus loin, cliquez sur OK (5) pour enregistrer les modifications des paramètres.

1.2 - Installation de l'extension dans le navigateur

Sur la page de l’extension KeePassXC-Browser, cliquez sur le bouton d’ajout.

Confirmez l’installation :

Alors, une fois KeePassXC-Browser installé, son icône s’ajoute à la barre d’adresse :

1.3 - Connection entre KeepassXC et l'extension

Cliquez sur l’icône de KeePassXC-Browser dans le navigateur (1). Alors dans la fenêtre popup, cliquez sur le bouton Connecter (2).

Dans KeePassXC une fenêtre s’ouvrira pour que vous donniez un ID unique à cette connexion :

Cliquez sur le bouton Enregistrer et autoriser l’accès.

Si vous utilisez un ID déjà utilisé, la connexion existante sera remplacée par la nouvelle et ne fonctionnera plus. Dans KeepassXC, vous pouvez voir les connexions existantes vers votre coffre en allant dans le menu Base de donnée > Paramètres de la base de donnée.... Puis, allez dans Intégration aux navigateurs, vous trouverez les clés enregistrées:

1.4 - Utiliser KeepassXC avec le navigateur

Pour utiliser KeePassXC avec Google Chrome ou autre, il faut garder le gestionnaire de mots de passe exécuté.

Pour éviter de le fermer par inadvertance en cliquant sur la croix de fermeture de fenêtre, allez dans les paramètres du gestionnaire, et dans Général (1), puis à la sélection Interface utilisateur (2). Alors, cochez Réduire au lieu de fermer l'appli (3). Après, pour fermer l'application, vous devrez passer par le menu Base de donnée > Quitter ou utiliser le raccourci clavier Ctrl + Q.

Dans le navigateur Web, l’icône de KeePassXC-Browser vous indiquera l’état de la connexion :

keepassxc-offline pour KeePassXC fermé ou déconnecté.

keepassxc-lock pour KeePassXC connecté, mais la base de données verrouillée.

keepassxc-online et pour KeePassXC connecté et prêt à être utilisé.

La première visite sur une page de connexion ayant un ou plusieurs identifiants déjà créés dans la base de donnée ouvrira une fenêtre de demande d’accès au navigateur.

Cochez Mémoriser (1) et cliquez sur le bouton Permettre les éléments sélectionnés (2).

Alors dans le champ de l’identifiant, cliquez sur l’icône KeePassXC. Si une seule entrée est disponible, cela complétera automatiquement les champs :

Ou, si plusieurs entrées sont disponibles, vous pourrez choisir celles à utiliser :

1.5 - Enregistrer une nouvelle entrée

Quand vous validerez un formulaire, KeePassXC-Browser pourra détecter automatiquement la création d’un nouvel identifiant/mot de passe. Alors, il proposera de l’enregistrer dans votre base de donnée.

Dans KeePassXC, vous retrouverez l’entrée créée dans le groupe KeePassXC-Browser :

Si vous mettez à jour mot de passe dans un formulaire, KeePassXC-Browser le détectera aussi. Et, vous pourrez mettre à jour l’entrée concernée directement depuis le navigateur :

Alors, une confirmation vous sera demandée avant qu’elle soit enregistrée dans la base de donnée.

C - Raccourcies Claviers :

Action	Raccourci clavier
Paramètres	Ctrl+,
Ouvrir la base de données	Ctrl + O
Enregistrer la base de données	Ctrl+S
Enregistrer la base de données sous	Ctrl + Maj + S
Nouvelle base de données	Ctrl + Maj + N
Fermer la base de données	Ctrl + W ; Ctrl+F4
Verrouiller toutes les bases de données	Ctrl + L
Paramètres de base de données	Ctrl + Maj + ,
Rapports de base de données	Ctrl + Maj + R
Quitter	Ctrl + Q
Nouvelle entrée	Ctrl+N
Modifier l'entrée	Entrer ; Ctrl+E
Supprimer l'entrée	Supprimer
Entrée de clone	Ctrl+K
Copier le nom d'utilisateur	Ctrl + B
Copier le mot de passe	Ctrl+C
Copier le lien	Ctrl + U
Ouvrir le lien	Ctrl + Maj + U
Copier TOTP	Ctrl+T
Copier le mot de passe et TOTP	Ctrl + Y
Afficher TOTP	Ctrl + Maj + T
Déclencher la saisie automatique	Ctrl + Maj + V
Ajouter une clé à l'agent SSH	Ctrl+H
Supprimer la clé de l'agent SSH	Ctrl + Maj + H
Réduire la fenêtre	Ctrl+M
Masquer la fenêtre	Ctrl + Maj + M
Sélectionnez l'onglet de base de données suivant	Ctrl + Tabulation ; Ctrl + PageDn
Sélectionnez l'onglet de base de données précédent	Ctrl + Maj + Tabulation ; Ctrl + Page précédente
Sélectionnez la nième base de données	Ctrl + n, où n est le numéro de l'onglet de la base de données
Basculer les mots de passe masqués	Ctrl + Maj + C
Basculer les noms d'utilisateur masqués	Ctrl + Maj + B
Groupes de discussion (modifier si ciblé)	F1
Entrées de focus (modifier si focus)	F2
Recherche ciblée	F3 ; Ctrl+F
Effacer la recherche	S'échapper
Afficher les raccourcis clavier	Ctrl+/

Action

Raccourci clavier

Paramètres

Ctrl+,

Ouvrir la base de données

Ctrl + O

Enregistrer la base de données

Ctrl+S

Enregistrer la base de données sous

Ctrl + Maj + S

Nouvelle base de données

Ctrl + Maj + N

Fermer la base de données

Ctrl + W ; Ctrl+F4

Verrouiller toutes les bases de données

Ctrl + L

Paramètres de base de données

Ctrl + Maj + ,

Rapports de base de données

Ctrl + Maj + R

Quitter

Ctrl + Q

Nouvelle entrée

Ctrl+N

Modifier l'entrée

Entrer ; Ctrl+E

Supprimer l'entrée

Supprimer

Entrée de clone

Ctrl+K

Copier le nom d'utilisateur

Ctrl + B

Copier le mot de passe

Ctrl+C

Copier le lien

Ctrl + U

Ouvrir le lien

Ctrl + Maj + U

Copier TOTP

Ctrl+T

Copier le mot de passe et TOTP

Ctrl + Y

Afficher TOTP

Ctrl + Maj + T

Déclencher la saisie automatique

Ctrl + Maj + V

Ajouter une clé à l'agent SSH

Ctrl+H

Supprimer la clé de l'agent SSH

Ctrl + Maj + H

Réduire la fenêtre

Ctrl+M

Masquer la fenêtre

Ctrl + Maj + M

Sélectionnez l'onglet de base de données suivant

Ctrl + Tabulation ; Ctrl + PageDn

Sélectionnez l'onglet de base de données précédent

Ctrl + Maj + Tabulation ; Ctrl + Page précédente

Sélectionnez la nième base de données

Ctrl + n, où n est le numéro de l'onglet de la base de données

Basculer les mots de passe masqués

Ctrl + Maj + C

Basculer les noms d'utilisateur masqués

Ctrl + Maj + B

Groupes de discussion (modifier si ciblé)

Entrées de focus (modifier si focus)

Recherche ciblée

F3 ; Ctrl+F

Effacer la recherche

S'échapper

Afficher les raccourcis clavier

Ctrl+/

LXC

01-Description

A - Description :

Nom DNS interne : lxc01.v.sdem.fr
Nom DNS Externe : NC
Type de serveur (Physique, VMware, LXC, Docker...) : VM VMware
OS : Ubuntu 22.04 LTS
Nom : lxc01.v.sdem.fr
CPU : 6
RAM : 12Go
Disque LVM :
/ : 50Go # ext4
/LXC : 300Go # Formaté par le daemon LXD en BTRFS

Rôle :

Serveur hébergeant des CT LXC
CT LXC :

Accès :

[*] Interne
[x] Externe

Réseaux :

Adresse IP : 192.168.1.31
Masque : 255.255.255.0
Passerelle : 192.168.1.254
DNS : 192.168.1.50
VLAN : SDEM_SERVEURS - 5

LXC

02-Installation

A - Paramétrage :

1. VMware :

Message UUID dans Syslog :

Sur Ubuntu 20, le syslog est vite noyé avec des messages UUID, il y a un petit réglage à effectuer côté VMWARE :

https://www.suse.com/support/kb/doc/?id=000016951

Pour faire simple il faut arrêter la VM et ajouter un attribut sur les VM Ubuntu 20 :

disk.EnableUUID = "TRUE"

VMware tools :

# Installation des VMware Tools :
apt install open-vm-tools

1. Gestion date et heure:

# Changer la date :
date -s "02/18/2017 12:34:00"

# Changer le fuseau horaire :
rm /etc/localtime
ln -s /usr/share/zoneinfo/Europe/Paris /etc/localtime
# Pour que le changement de fuseau survive au redémarrage de la machine, il faut aussi le mettre dans le bon fichier.
vi /etc/timezone
ZONE="Europe/Paris"

# Ce qui donne en une seule commande :
sudo su
rm /etc/localtime
ln -s /usr/share/zoneinfo/Europe/Paris /etc/localtime
cat > /etc/timezone << eof
ZONE="Europe/Paris"
eof
cat /etc/timezone
exit
date

3. Accès SSH :

L'algorithme ssh-rsa est désactivé dans la version de SSH livrée dans Ubuntu 22.04 car il utilise la fonction cryptographique SHA-1 qui est jugée dangereuse depuis des années.
La connexion SSH de guacamole vers ce serveur ne fonctionne pas. Il est nécessaire de réactiver temporairement la connexion RSA en attendant la mise à jour de Guacamole.

Source : http://shaarli.guiguishow.info/?4DVyLA

vi /etc/ssh/sshd_config

# JKT-20220517 - Connexion Guacamole :
# Source : http://shaarli.guiguishow.info/?4DVyLA
HostkeyAlgorithms +ssh-rsa
PubkeyAcceptedAlgorithms +ssh-rsa

/etc/init.d/ssh restart

4. Prérequis :

# Mise à jour du serveur :
apt-get update && apt-get upgrade -y

# Installation des utilitaires :
apt-get install ntp postfix

# Installation de la supervision :
apt-get install nagios-nrpe-server nagios-plugins -y

Ajout du disque de stockage BTRFS pour LXC :

Disque LXC :

Ce disque est dédié pour stocker les CT LXC.
On ne configure pas de base ce disque qui va être géré directement par LXC en BTRFS.
Il ne faut pas configurer le disque en ZFS car cela nécessite une configuration avancé du paramètre ashift.
Par défaut l'ashift est de 512byte =2^9
Hors sur les serveurs les secteurs sont à minima 4k = 2^12
Ce qui fait qu'il va écrire sur les disques 8 fois plus et cela va également générer un problème de fragmentation du disque et à terme une panne accéléré du disque.

5. Installation de LXC :

Certaines terminologies courantes utilisées avec LXC incluent :
chroot - Chroot, également appelé changement de racine ou changement de racine, est une section du système de fichiers isolée du reste du système de fichiers. Un programme exécuté dans cet environnement ne peut pas accéder aux fichiers en dehors de l'arborescence de répertoires désignée.
cgroups - Il s'agit d'une fonctionnalité du noyau qui permet d'agréger ou de partitionner des tâches (processus) et tous leurs enfants en groupes organisés hiérarchiquement pour isoler les ressources.

# Installation de lxd et des outils associés :
# sudo apt install lxd lxc-utils iraf-dev zfsutils-linux -y
sudo apt install lxc lxd-installer

Ajouter un utilisateur au groupe LXD à des fins de gestion :

Pas besoin d'être l'utilisateur root pour gérer le démon LXD. Pour gérer le serveur LXD, ajoutez votre nom d'utilisateur au groupe lxd à l'aide de la commande adduser sur Ubuntu Linux:

sudo adduser adminme lxd

Configurer les options de mise en réseau et de stockage LXD :

Maintenant que nous avons installé LXD, il est temps de configurer le serveur LXD. Vous devez configurer l'option de mise en réseau et de stockage telle que le répertoire, ZFS, Btrfs, etc., entrez :

sudo lxd init

Ensuite, vous devez répondre à une série de questions sur la façon de configurer le serveur LXD, y compris l'option de stockage et de mise en réseau.
Voici un exemple de session que j'ai configuré pour ZFS et le sous-réseau NAT 10.105.28.1/24. N'hésitez pas à choisir les options selon vos besoins:

Prérequis pour la préparation du stockage en ZFS :

sudo lxd init

Would you like to use LXD clustering? (yes/no) [default=no]: # no
Do you want to configure a new storage pool? (yes/no) [default=yes]: # yes
Name of the new storage pool [default=default]: # lxc-storage01
Name of the storage backend to use (ceph, btrfs, dir, lvm, zfs) [default=zfs]: # btrfs
Create a new BTRFS pool? (yes/no) [default=yes]: # yes
Would you like to use an existing empty block device (e.g. a disk or partition)? (yes/no) [default=no]: # yes
Path to the existing block device: /dev/disk/by-id/scsi-36000c2920fa37484c1bbc95b339370e5 # Stockage sdb
Would you like to connect to a MAAS server? (yes/no) [default=no]: # no
Would you like to create a new local network bridge? (yes/no) [default=yes]: # yes
What should the new bridge be called? [default=lxdbr0]: # lxdbr0
What IPv4 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]: # 192.168.25.1/24
Would you like LXD to NAT IPv4 traffic on your bridge? [default=yes]: # yes 
What IPv6 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]: # none
Would you like the LXD server to be available over the network? (yes/no) [default=no]: # no
Would you like stale cached images to be updated automatically? (yes/no) [default=yes] # yes
Would you like a YAML "lxd init" preseed to be printed? (yes/no) [default=no]: # no

# Redémarrer le serveur :
reboot

Vous êtes ensuite invité à configurer un pont réseau pour les conteneurs LXD. Cela active les fonctionnalités suivantes :
- Chaque conteneur obtient automatiquement une adresse IP privée.
- Chaque conteneur peut communiquer entre eux sur le réseau privé.
- Chaque conteneur peut initier des connexions à Internet.
- Chaque conteneur reste inaccessible depuis Internet par défaut ; vous ne pouvez pas initier une connexion à partir d'Internet et atteindre un conteneur à moins que vous ne l'activiez explicitement. Vous apprendrez à autoriser l'accès à un conteneur spécifique à l'étape suivante.

Nous pouvons vérifier les informations en tapant les commandes suivantes:

lxc profile list
lxc profile show default

lxc network list
lxc network show lxdbr0

lxc storage list
lxc storage show lxc-storage01

sudo btrfs filesystem show

Configurer VIM pour éditer la configuration des CT à la place de nano

Par défaut, nano est utilisé pour l'éditer de la configuration des containers. La documentation suivante permet de modifier l'éditeur et utilise vim.

Source : https://askubuntu.com/questions/1116800/change-default-editor-in-lxd-snap

# Modification de l'éditeur :
echo 'export EDITOR=vim' >> ~/.profile 
source ~/.profile

# Test :
lxc config edit $CTNAME

LXC

03-Exploitation

A - Commandes :

1. Gestion du stockage :

Gestion du storage pool BTRFS

# Afficher le storage pool :
lxc storage list
lxc storage show lxc-storage01
lxc storage list info lxc-storage01

# Affiche l'espace disque du volume BTRFS :
sudo btrfs filesystem show

Gestion des fichiers des CT :

Accès au stockage des CT : 
# Emplacement : 
/var/snap/lxd/common/mntns/var/snap/lxd/common/lxd/storage-pools/lxc-storage01/containers/CT/rootfs

# Lien symbolique du CT : 
ln -s /var/snap/lxd/common/mntns/var/snap/lxd/common/lxd/storage-pools/lxc-storage01/containers/CT/rootfs/ /home/adminme/CT

2. Commandes LXC :

Gestion LXC

# Gestion des profiles :
lxc profile list
lxc profile show default

# Gestion des réseaux :
lxc network list
lxc network show lxdbr0

# Afficher les informations d'un CT :
lxc info CT-NAME
lxc info --show-log CT-NAME
lxc show CT-NAME

# Se connecter dans un CT :
lxc exec CT-NAME bash

# Editer la configuration d'un CT :
lxc config edit CT-NAME

# Démarrage d'un serveur d'un CT :
lxc exec CT-NAME service -- ssh start

###################################
Source : https://www.cyberciti.biz/faq/create-snapshots-with-lxc-command-lxd/
### Gestion des snapshots d'un CT :
# Créer un snapshot :
lxc snapshot CT-NAME Snapname

# Vérifier les snapshots :
lxc info CT-NAME

# Restaurer un snapshot :
lxc restore CT-NAME Snapname

# Supprimer un snapshot :
lxc delete CT-NAME/Snapname
lxc delete CT-NAME/Snapname -i # Force la confirmation

lxc copy CT-NAME01/base030423 CT-NAME02
lxc delete CT-NAME/base090323

# Liste de l'image LXD intégrée pour diverses distributions Linux :
# Pour répertorier toutes les images LXD, exécutez :
lxc image list images: | grep -i ubuntu

Gestion des conteneurs

# Création d'un conteneur BASE qui servira de template :
# Syntaxe : lxc launch images:{distro}/{version}/{arch} {container-name-here}
lxc launch ubuntu:22.04 BASE

# Lister les conteneurs :
lxc list

# Répertorier les instances de conteneur Linux
# Nous pouvons répertorier les conteneurs existants en utilisant la syntaxe suivante et la commande grep / commande egrep en tant que pipe :
lxc list --fast
lxc list | grep RUNNING
lxc list | grep STOPPED
lxc list | grep -i opensuse
lxc list "*c1*"
lxc list "*c2*"

Comment exécuter/exécuter la commande spécifiée dans un conteneur

Nous exécutons ou exécutons des commandes dans des conteneurs à l'aide de la commande exec comme suit :

lxc exec containerName -- command
lxc exec containerName -- /path/to/script
lxc exec containerName --env EDITOR=/usr/bin/vim -- command
### run date, ip a, ip rm and other commands on various containers ###
lxc exec cenots-8-c2 -- date
lxc exec cenots-8-c2 -- ip a
lxc exec ubuntu-focal-c5 -- ip r
lxc exec fedora-31-c9 -- dnf -y update
lxc exec debian-10-www -- cat /etc/debian_version

Comment obtenir l'accès au shell bash dans un conteneur

Vous voulez obtenir un accès login/shell dans un conteneur nommé debian-10-www, entrez : Maintenant, vous pouvez exécuter des commandes ou installer des packages. Par exemple, utilisez la commande apt / la commande apt-get à l' intérieur du conteneur : tapez simplement exit pour revenir à l'hôte :

lxc exec {container-name} {shell-name}
lxc exec debian-10-www bash
lxc exec CT-NAME bash
lxc exec alpine-c1 sh
# cat /etc/*issue*
# apt update
# apt upgrade
# exit

Autres commandes

# Comment afficher des informations sur les serveurs et conteneurs LXD ?
lxc info
lxc info {container-name}
lxc info opensuse15-1-c10
lxc info -n CT-ID

# Vérifier la config :
lxc checkconfig 

# Extraire un fichier du conteneur
lxc file pull {continer-nane}/{path/to/file} {/path/to/local/dest}
lxc file pull ubuntu-xenial-c3/var/www/nginx/app/config.php .

# Copier et récupérer des fichiers d'un CT :
# Il est possible de transférer des fichiers vers un CT : PUSH
# Mais également de récupérer des fichiers depuis un CT : PULL 
# Pousser un fichier vers le conteneur
lxc file push {/path/to/file} {continer-nane}/path/to/dest/dir/
lxc file push config.php ubuntu-xenial-c3/var/www/nginx/app/
# PUSH d'un fichier vers un CT :
lxc file push /home/adminme/file.txt CT-NAME/tmp/
# PUSH d'un dossier vers un CT :
lxc file push -r /home/adminme/DOSSIER CT-NAME/tmp/
# PULL d'un fichier depuis un CT :
lxc file pull /home/adminme/file.txt CT-NAME/tmp/
# PULL d'un dossier depuis un CT :
lxc file pull -r CT-NAME/tmp/DOSSIER /home/adminme/ 


# Obtenir de l'aide sur les commandes lxc
lxc --help
lxc {command} --help
lxc list --help

# Gestion d'in Conteneur :
lxc start CT-ID
lxc restart CT-ID
lxc stop CT-ID
lxc delete CT-ID
lxc stop ubuntu-xenial-c3 && lxc delete ubuntu-xenial-c3

# Configurer l'autostart d'un CT :
lxc config set CT-ID boot.autostart true

B - Procédure de création d'un CT :

1. Création d'un CT :

# Déclarer la variable :
CTNAME=MONCT01
# Création du conteneur :
lxc launch ubuntu:22.04 $CTNAME

# Configurer l'autostart d'un CT :
lxc config set $CTNAME boot.autostart true

2. Paramétrage :

Editer le fichier de configuration afin de paramétrer une adresse IP fixe et le forward de port.

Configuration réseau et forward de port :

Il est nécessaire de bien renseigner le fichier de zone DNZ "lxc.morbihan-energies.fr" afin d'attribuer une adresse IP sur le réseau LXC (non routé).

# Editer le fichier de configuration :
lxc config edit $CTNAME

Ajouter les lignes suivantes :

  devices:
    eth0:
      ipv4.address: 192.168.25.XXX
      name: eth0
      network: lxdbr0
      type: nic
  port52201:
      connect: tcp:0.0.0.0:22
      listen: tcp:192.168.1.31:52201
      type: proxy
  port53080:
      connect: tcp:0.0.0.0:80
      listen: tcp:192.168.1.31:53080
      type: proxy

Création du compte d'admin :

# Se connecter dans le conteneur :
lxc exec $CTNAME bash

# Créer un utilisateur :
useradd adminme

# Ajouter un utilisateur au groupe sudo :
usermod -aG sudo adminme

# Modifier le mot de passe :
passwd adminme
passwd root

# Création de l'arborescence pour le déploiement des clés SSH :
mkdir /home/adminme/.ssh
vi /home/adminme/.ssh/auadminmethorized_keys
chown -R adminme:adminme /home/adminme/.ssh




# Autoriser un sudo sans demande de mot de passe :
sudo visudo

# Ajouter les lignes ci-dessous :
%sudo   ALL=(ALL:ALL) NOPASSWD:ALL

Configuration de la connexion SSH :

# Autoriser la connexion par mot de passe :
vi /etc/ssh/sshd_config

#Ajouter les lignes suivantes à la fin du fichier de conf :
----------------------------------------------------------
# Autoriser connexion par mot de passe :
PasswordAuthentication yes

# JKT-20220517 - Connexion Guacamole :
# Source : http://shaarli.guiguishow.info/?4DVyLA
HostkeyAlgorithms +ssh-rsa
PubkeyAcceptedAlgorithms +ssh-rsa
----------------------------------------------------------

# Redémarrer le service SSH :
/etc/init.d/ssh restart

B - CT-BASE :

1. Description :

SSS-Titre 1

Titre 1

Ce Conteneur a pour objectif d'être un Template qui pourra être déployé en dupliquant un snapshot.

1. Installation :

Cette procédure n'est pas encore terminée

# Prérequis :
apt update && apt upgrade -y
apt install software-properties-common bash-completion wget git  -y

# Installation de nginx :

# Installation de php-fpm :
$ sudo apt install php-fpm


vi parametres.php
vi /etc/nginx/sites-enabled/
vi /etc/nginx/sites-enabled/default

1. Exploitation :

Cette procédure n'est pas encore terminée

LXC

04-Gestion réseau et port forwarding

A - Gestion du réseau LXC :

Afin de réserver les adresses IP en cas de plusieurs serveur LXC et éviter les conflits. Il est nécessaire de renseigner le fichier de zone DNS "/etc/named/zone/lxc.morbihan-energies.fr".

La zone sert uniquement d'inventaire et n'est pas publiée.

Nom du CT	Adresse IP
BASE	192.168.25.150
WIKI	192.168.25.151
BASH	192.168.25.152
DASHBOARD	192.168.25.153
RACKTABLES	192.168.25.232
KANBOARD	192.168.25.156

B - Gestion du forwarding de port :

La gestion du forwarding de port (SSH, HTTP, MySQL...) est recensé dans un tableur spécifique :

N:\05-Informatique\01-Systeme\Réseaux\Network-Configuration.ods (Page LXC-Network)

Ce paramétrage permet à une personne de se connecter en SSH directement sur le CT sur un port spécifique sans passer par le serveur LXC.

LXC

10-Scripts

A - check-disk.sh :

Ce script à pour objectif d'envoyer un mail sur hostmaster pour avoir le délai de l'espace disque du stockage BTRFS de LXC.

Crontab -e :

# Check disques :
0 06 * * * cd /usr/local/bin/ && ./check-disk.sh 2>&1

Emplacement du script : /usr/local/bin/check-disk.sh

#!/bin/bash
( 
        echo To: hostmaster@morbihan-energies.fr
        echo From: hostmaster@morbihan-energies.fr
        echo Subject: Usage du disque sur le serveur lxc01.v.sdem.fr
        echo LXC01.V.SDEM.FR - Usage du disque :
        echo 
        sudo df -h /dev/mapper/ubuntu--vg-ubuntu--lv
        echo
        echo LXC01.V.SDEM.FR - Taille du stockage BTRFS de LXC01 :
        sudo btrfs filesystem show
        echo
) | /usr/sbin/sendmail -fhostmaster@morbihan-energies.fr hostmaster@morbihan-energies.fr

LXC

05 - Transfert de Conteneur

A - Transfert de Conteneur :

Voici mon exemple de configuration pour utiliser l'API LXD et le protocole Simplestreams à des fins de migration :

Encore une fois, vous avez besoin de deux serveurs avec LXD configuré. J'appellerai votre machine locale serveur1 et un serveur distant j'appellerai serveur2.

1. Configurer le serveur :

Ces étapes sont à faire sur les 2 Serveurs LXC.

Tapez la commande suivante pour activer un accès à distance via API en indiquant l'adresse IP du serveur LXC sur lequel on est connecté.

lxc config set core.https_address 192.168.1.6:8443

Définissez le mot de passe pour le démon server2 lxd : Remplacez le MOT DE PASSE ici par le mot de passe réel.

lxc config set core.trust_password PASSWORD

2. Configurer un local nommé server1 :

Tapez la commande suivante sur le serveur1 pour ajouter le serveur2 et inversement :

lxc remote add lxcXX.v.sdem.fr 192.168.1.6

Vous pouvez lister vos télécommandes et vous verrez « server2 » répertorié comme suit :

lxc remote list

3. Transfert du conteneur :

Instantané 1

Création d'une capture instantanée pour le conteneur transféré.

lxc snapshot {CT_NAME} {NOM_SNAP}

Transfert 1

lxc copy {CT_NAME}/{NOM_SNAP} server2:{CT_NAME} --verbose

4. Script de Transfert de Conteneur :

Voici un script permettant d'automatiser avec Salt le transfert d'un conteneur entre 2 serveurs LXC.

##############################################################
# Auteur : mkermorvant                                       #
# Date de modification : 20240115                            #
#                                                            #
# Description : Script de migration de conteneur lxc         #
#                                                            #
##############################################################
#! /bin/bash                                                 #
#                                                            #
##############################################################
# Variables :
echo""
read -p "Entrez le nom de votre Serveur Source: " SOURCE
read -p "Entrez le nom actuel de votre conteneur: " CT_NAME
read -p "Entrez le nom de votre Snapshot: " SNAP_NAME
echo ""
echo "Début de la Migration du Conteneur."
##############################################################
# 1 - Création de la Snapshot
echo "Création de la Snapshot."
echo""
salt ${SOURCE} cmd.run "lxc snapshot ${CT_NAME} ${SNAP_NAME}"
# 2 - Information supplémentaire
salt ${SOURCE} cmd.run "lxc remote list"
read -p "Entrez le nom de votre Remote Serveur: " REMOTE_SERV
# 3 - Migration du conteneur
salt ${SOURCE} cmd.run "lxc copy ${CT_NAME}/${SNAP_NAME} ${REMOTE_SERV}:${CT_NAME} --verbose"
echo ""
# 4 - Suppression du Conteneur de Base
read -r -p "Voulez-vous supprimer le conteneur ? [y/N] " response

case "$response" in
    [yY][eE][sS]|[yY])
        echo "Suppression de votre premier conteneur."
        salt ${SOURCE} cmd.run "lxc stop ${CT_NAME}"
        salt ${SOURCE} cmd.run "lxc delete ${CT_NAME}"
        echo ""
        echo "Le transfère de votre conteneur LXC est maintenant fini !"
        ;;
    *)
        echo "Le transfère de votre conteneur LXC est maintenant fini !"
        ;;
esac

B - Création de Conteneur :

1. Script de Création de conteneur LXC :

#############################################################
# Auteur : mkermorvant                                      #
# Date de modification : 20240108                           #
#                                                           #
# Description : Script de création de conteneur lxc         #
#                                                           #
#############################################################
#                                                           #
#! /bin/bash                                                #
#                                                           #
#############################################################
# Variables :
echo""
read -p "Entrez le nom de votre Serveur LXC: " SERVER
read -p "Entrez la distribution à installer: " DISTRIB
read -p "Entrez la version à installer: " VERSION
read -p "Entrez le nom de votre conteneur: " CONTENEUR
read -p "Donner le nom de votre snapshot: " SNAP
echo ""
echo "Début de la création du conteneur."
############################################################
# 1 - Création du conteneur
salt ${SERVER} cmd.run "lxc launch ${DISTRIB}:${VERSION} ${CONTENEUR}"
echo ""
# 2 - Création d'une Snapshot
echo "Création d'une Snapshot."
salt ${SERVER} cmd.run "lxc snapshot ${CONTENEUR} ${SNAP}"
echo ""
# 3 - Infos Conteneur
salt ${SERVER} cmd.run "lxc info ${CONTENEUR}"
echo ""
echo "Votre conteneur ${CONTENEUR} est maintenant créé et opérationnelle"
echo ""

Zammad

01 - Description

A - Une description :

Nom DNS interne :
Nom DNS Externe :
Type de serveur (Physique, VMware, LXC, Docker...) : VM VMWare < /span>Disque LVM : / : RAM :4Go CPU : 3
OS : Debian 12

Réseaux :

Adresse IP : 192.168.56.190
Masque : 255.255.255.0
Passerelle : 192.168.56.254
DNS : 192.168.56.1 192.168.1.50

1. Rôle :

Zammad est une solution de gestion de support/tickets opensource qui comporte beaucoup de fonctionnalités de haut niveau pour s'interfacer dans le système d'information existant ainsi qu'avec les principales plateformes de réseaux sociaux. Il vous permet de centralisé la gestion de vos échanges supports ou contacts téléphoniques, courriels et autres.

1. Accès :

Méthode d'accès :

[*] Interne
[x] Externe

1. Checklist - Création du serveur :

Sécurité :

[*] Création compte adminme
[*] Changement mot de passe root
[*] Changement mot de passe adminme < a i=3>[*] Sécurisation des mots de passe (20 caractères minimum et 3 types de caractères différents) [*] Mise à jour du coffre fort de mot de passe < a i=5>[*] Déploiement clé SSH [ ] Paramétrage du SUDO NOPASSWORD Liste des Ports ouverts :

B - LXC

1. Rôle :

Le projet Linux Containers (LXC) est un outil de conteneurisation, c'est une plateforme de conteneurs Open Source qui fournit un ensemble d'outils, de modèles, de bibliothèques et de liaisons de langage. Le projet LXC dispose d'une interface en ligne de commande simple qui facilite la prise en main pour les nouveaux utilisateurs. Il contient un environnement de virtualisation au niveau du système d'exploitation qu'il est possible d'installer sur de nombreux systèmes fonctionnant sur Linux.

2. Qu'est-ce que la Conteneurisation :

Un conteneur est une technologie qui permet d'assembler et d'isoler des applications avec leur environnement d'exécution complet, c'est-à-dire tous les fichiers nécessaires à leur exécution. Les applications conteneurisées sont plus faciles à déplacer d'un environnement vers un autre (développement, test, production, etc.), tout en conservant l'intégralité de leurs fonctions.< /span>

3. Conteneurs et virtualisation ; quelles sont les différences :

Ce n'est pas tout à fait la même chose. Les conteneurs et la virtualisation sont plutôt complémentaires. Voici deux définitions simples pour y voir plus clair :

La virtualisation permet à vos systèmes d'exploitation (Windows ou Linux) de s'exécuter simultanément sur un seul système matériel.
Les conteneurs partagent le même noyau de système d'exploitation et isolent les processus de l'application du reste du système.

Qu'est-ce que cela signifie ? En premier lieu, la virtualisation utilise un hyperviseur pour émuler le matériel, ce qui permet d'exécuter plusieurs systèmes d'exploitation en parallèle. C'est une solution moins légère que les conteneurs. Les conteneurs Linux s'exécutent en natif sur leur système d'exploitation, qu'ils partagent entre eux. Vos applications et services restent ainsi légers et s'exécutent rapidement en parallèle.

1. Commande LXC :

Gestion LXC :

# Affiche différentes informations du conteneur comme le nom des snapshots, ressources utilisées, etc...
lxc info {CT-NAME}

# Permet de se connecter aux conteneurs :
lxc exec {CT-NAME} bash

# Créer un snapshot :
lxc snapshot {CT-NAME} {Snapname}

# Restaurer un snapshot :
lxc restore {CT-NAME} Snapname

# Supprimer un snapshot :
lxc delete {CT-NAME}/{Snapname}

# Gestion des profils :
lxc profile list
lxc profile show default

# Gestion des réseaux :
lxc network list
lxc network show lxdbr0

# Éditer la configuration d'un CT :
lxc config edit {CT-NAME}

# Démarrage d'un serveur d'un CT :
lxc exec CT-NAME service -- ssh start

Gestion des conteneurs :

# Création d'un conteneur
lxc launch {distrib}:{version} {CT_Name} 

#Suprimer un conteneur
lxc delete {CT_NAME}

# Arréter un conteneur
lxc stop {CT_Name} 

# Démarrer un conteneur
lxc start {CT_Name}

# Lister les conteneurs :
lxc list

Zammad

02 - Installation

A - Préparation à l'installation :

https://docs.zammad.org/en/latest/install/package.html

https://docs.zammad.org/en/latest/install/elasticsearch.html#configure-zammad-with-elasticsearch

https://docs.zammad.org/en/latest/getting-started/configure-webserver.html

1. Prérequis :

Tout d'abord, pour le bon fonctionnement de Zammad il vous faudra installer Postfix.

#Installation postfix
apt install postfix

2. Installation de la dépendances du forfait :

Les dépendances ci-dessous doivent être installées sur votre système.

#Installation des dépendances du package
apt install curl apt-transport-https gnupg

3. Configuration d'Elasticsearch :

Source : https://docs.zammad.org/en/latest/install/elasticsearch.html

Installation

#Installation d'Elacticsearch

apt install apt-transport-https sudo wget curl gnupg

echo "deb [signed-by=/etc/apt/trusted.gpg.d/elasticsearch.gpg] https://artifacts.elastic.co/packages/7.x/apt stable main"| \
  tee -a /etc/apt/sources.list.d/elastic-7.x.list > /dev/null

curl -fsSL https://artifacts.elastic.co/GPG-KEY-elasticsearch | \
  gpg --dearmor | tee /etc/apt/trusted.gpg.d/elasticsearch.gpg> /dev/null

apt update

apt install elasticsearch

/usr/share/elasticsearch/bin/elasticsearch-plugin install ingest-attachment

Après avoir installé Elasticsearch et son plugin de pièce jointe, assurez-vous de l'activer par défaut et démarrez-le.

#Démarrage d'Elasticsearch
systemctl start elasticsearch
systemctl enable elasticsearch

4. Vérification des paramètres régionaux :

Pour que Zammad fonctionne correctement, votre système doit utiliser les paramètres régionaux corrects.

#Répertoriez vos paramètres régionaux actuels
apt install locales
locale-gen fr_FR.UTF-8
echo "LANG=fr_FR.UTF-8

B - Installation de Zammad :

Ajout d'un référentiel

#Installer la clé référentiel
curl -fsSL https://dl.packager.io/srv/zammad/zammad/key | \
  gpg --dearmor | tee /etc/apt/trusted.gpg.d/pkgr-zammad.gpg> /dev/null

#Ubuntu 22.04 
echo "deb [signed-by=/etc/apt/trusted.gpg.d/pkgr-zammad.gpg] https://dl.packager.io/srv/deb/zammad/zammad/stable/ubuntu 22.04 main"| \
   tee /etc/apt/sources.list.d/zammad.list > /dev/null

Installation de Zammad

#Installation de Zammad
apt update
apt install zammad

C - Connexion à Zammad :

#Définir l'adresse du serveur Elasticsearch
zammad run rails r "Setting.set('es_url', 'http://localhost:9200')"

#Construire l'index de recherche
zammad run rake zammad:searchindex:rebuild

D - Configuration des fichiers de conf :

Obtenez un fichier de configuration actuelle

Copiez et écrasez la valeur par défaut zammad.conf en utilisant

cp /opt/zammad/contrib/nginx/zammad_ssl.conf /etc/nginx/sites-available/zammad.conf

Ajustez le fichier de configuration

Ajustez le fichier que vous venez de copier avec un éditeur de texte de votre choix (par exemple viou nano).

nano /etc/nginx/sites-available/zammad.conf

Localisez n'importe quelle server_name directive et ajustez example.com la au sous-domaine que vous avez choisi pour votre instance Zammad.

Pour que le serveur soit opérationnel, il est important de supprimer toute la partie ssl du fichier de conf étant donné que c'est le proxy qui prendra en charge le ssl.

Configuration du conteneur

Après avoir édité le fichier de configuration de Zammad , il est nécessaire de modifier également celui du conteneur LXC .

#Configuration du conteneur LXC
lxc config edit {CT_Name}

Une fois dans le fichier de conf, supprimez la ligne "devices [ ]" et remplacez le par :

devices:
 eth0:
  ipv4.address: {adresse ip du conteneur}
  name: eth0
  network: lxdbr1
  type: nic
port22215:
  connect: tcp:0.0.0.0:22
  listen: tcp:192.168.56.190:22215
  type: proxy
port44215:
  connect: tcp:0.0.0.0:80
  listen: tcp:192.168.56.190:44215
  type: proxy

Attention, pensez à bien modifier l'adresse Ip ainsi que les différents ports.

E - Configuration du Serveur Web :

Une fois arrivé sur la page ci-dessous, la configuration peut commencer.

Après avoir cliqué sur "Set ip a new system", il vous faudra créer un compte administrateur.

Ensuite, vous devrez remplir le nom et le logo de l'organisation.

Maintenant, vous devrez configurer la notification par e-mail.

Ici, vous avez le choix de connecter les canaux ou bien de passer afin d'utiliser Zammad au plus vite.

Si vous choisissez de connecter les canaux, vous devrez remplir le compte email.

Puis pour finir, vous devrez remplir l'email entrant.

Une fois toutes ces étapes finies, l'installation de votre Zammad est terminée et vous n'avez plus cas l'utiliser !

Zammad

03 - Exploitation

A-Interface :

Après avoir installé Zammad, pour utiliser ses nombreuses fonctionnalités, vous devrez dans un premier temps vous connecter avec les identifiants créés au préalable.

Après vous être connecté, vous arriverez sur l'interface ci-dessous :

01- Le point numéro 1 permet la création de ticket.

02- La page aperçue est une page qui permet de voir l'ensemble des tickets de manière classée

03- Comme on peut le voir ci-dessus le point numéro 3 est le tableau de bord, il permet de voir statistiques différentes de la gestion des tickets.

04-Le point 4 est le flux d'activité, il permet de voir les différentes actions qui ont été faites comme la création d'un utilisateur ou d'un ticket.

05- Le point numéro 5 définit l'emplacement des paramètres.

06- En 6, vous pourrez voir les statistiques des différents tickets de la création à la fermeture.

07- Le point 7 vous permettra de personnaliser votre profil.

B - Création d'un Utilisateur :

Pour créer un utilisateur, vous devrez tout d'abord aller dans les paramètres situés en bas à gauche de votre interface.

Une fois dans cette interface, vous n'aurez plus cas cliquer sur "Nouvel Utilisateur".

Après cela, vous n'avez plus cas définir les informations ainsi que les autorisations qu'il va avoir.

C - Création de ticket :

Pour créer un ticket, il vous suffit de cliquer sur la croix verte en bas à droite de l'interface de Zammad.

Vous arriverez ensuite sur l'interface ci-dessous ou il vous suffira de remplir votre ticket.

D - Gestion des billets :

Pour gérer les différents tickets, vous devez aller dans l'onglet aperçu et vous pourrez y voir l'intégralité des tickets qui sont créés.

Une fois le ticket visible, vous pouvez cliquer dessus pour l'ouvrir. Sur la partie de droite, vous pouvez indiquer qui est le propriétaire du ticket, l'état du ticket ainsi que sa priorité.

Lorsque vous cliquez sur la zone de texte, vous avez la possibilité d'envoyer un message ou bien de créer une note. Si vous voulez que votre message soit visible par le créateur du ticket, il faut que les chaînes de gauche soient déverrouillées, dans le cas contraire, le message aura une lueur orange et ne pourra pas être vu par le client.

E - Création des Organisations :

1. Création de l'organisation

En allant dans les paramètres de Zammad, vous avez un onglet nommé organisations. Cet onglet vous permet de créer des organisations qui peuvent être ajoutées à différents utilisateurs. Pour cela a commencé par cliquer sur l'onglet "Nouvelle Organisation".

Vous arriverez ensuite sur l'interface ci-dessous ou vous pourrez remplir les paramètres de votre organisation. Pour valider vos organisations, vous n'aurez plus cas, cliquez sur envoyer.

2. Attribution de l'organisation

Une fois créé, vous pouvez affecter un utilisateur à votre organisation. Pour cela, allez dans les paramètres puis dans l'onglet utilisateur, cliquez sur votre utilisateur.

Une fois dans l'interface ci-dessous complétée l'onglet "Organisation" avec le nom de l'organisation créée au paravent.

Une fois ajouter votre utilisateur sera ajouter à l'organisation et cela sera précisé dans son profil utilisateur.

F - Configuration de Zammad :

Pour les étapes suivantes, nous avons le service Infra, DEV et SIG qui doivent recevoir leurs tickets. Chaque service doit pouvoir attribuer un ticket à l'un de ses membres, ils doivent également pouvoir déléguer un ticket à un autre service.

1.Groupe

Pour commencer, il faut tout d'abord créer un groupe avec les différents services.

Création des groupes 1

Dans un 1er temps, vous allez créer un premier groupe de service, vous devrez vous rendre dans l'onglet "Groupe" situé dans les paramètres. Vous devrez ensuite cliquer sur un nouveau groupe.

Une fois dans l'interface ci-dessous, vous n'aurez plus cas nommé votre manager et le créé.

Une fois votre premier service créé, vous n'avez plus cas faire la même chose pour les autres.

Ajout d'utilisateur dans le groupe 2

Si vous souhaitez ajouter un utilisateur au groupe, vous devrez vous diriger dans l'onglet utilisateur cliqué sur l'utilisateur. Vous arriverez ensuite sur l'utilisateur. interface ci-dessous ou vous n'aurez plus cas choisir le groupe a associer et les permissions accordées, dans notre cas toutes les permissions au groupe. N'oubliez pas de cliquer sur ajouter pour enregistrer !

Délégation de tâche 3

Afin que chaque groupe puisse se transférer des billets, il est important qu'un opérateur possède des droits sur chaque groupe. Des permissions "totale" dans le groupe de son service et seulement les autorisations de modification pour les autres services.

On peut voir ici que cet utilisateur fait partie du service Infra.

2. Rôles

Par défaut dans Zammad, il y a 3 rôles :

Administrateur
Opérateur
Client

Ici pour chaque membre des services Ifra, DEV et SIG nous allons leur mettre des droits d'opérateur afin qu'ils puissent gérer leur ticket.

Création des Rôles 1

Dans notre cas, les rôles fournis par Zammad ne seront pas suffisants, c'est pour cela que nous allons commencer par dupliquer 2 fois le rôle "Opérateur". Pour dupliquer un rôle allez dans l'onglet rôle et sélectionnez le logo de droite.

Une fois dupliquer, vous pouvez les renommées en cliquant dessus et en modifiant simplement le nom.

Ajout des droits opérateur 2

Une fois nos 3 rôles créés, il faut ajouter les utilisateurs. Pour cela, allez au même endroit que pour associer un groupe et ajouter l'opérateur à son service.

On peut voir ici que l'opérateur fait partie du groupe SIG.

3. Aperçu

Si ce n'est pas déjà le cas, vous devrez ajouter vos différents rôles au aperçu afin que chaque rôle puisse voir les différentes catégories de ticket. Pour cela aller dans l'onglet "Aperçu" et sélectionné les 3 petits points, vous n'aurez plus cas ajouter les différents rôles.

4. Vérification

Après ces différentes étapes, quand vous vous rendez dans les paramètres d'un utilisateur, vous devriez avoir ceci.

Si c'est le cas, vos 3 services sont prêts, si un client a créé un ticket, il pourra choisir l'un des 3 services pour envoyer le ticket. Du côté de l'opérateur, il est possible de choisir un responsable de ticket et il est également possible de pouvoir changer le ticket de service.

G - Configuration de l'email :

Afin que les utilisateurs puissent envoyer un ticket sans passer par l'interface web, il est possible de configurer des adresses emails qui transfèreront leurs mails à Zammad.

Pour commencer, allez dans l'onglet e-mail et cliquer sur "Nouveau".

Vous arriverez dans l'interface ci-dessous ou vous devrez remplir les différentes informations de l'adresse mail qui va recevoir les différents tickets.

Après avoir cliqué sur connecter, il vous affichera un message d'erreur et d'autre information à complété.

Remplissez le nom d'hôte, ici "imap.morbihan-energies.fr" et sélectionné "Pas de SSL".

Une fois ces informations remplie, valider vos paramètres et votre email sera relié à Zammad.

Zammad

04 - Maintenance

A - Mises à jours :

1. Mise à jour Zammad :

Si vous souhaitez mettre à jour votre système Zammad, vous devrez commencer par stopper le service.

#Arrêtez Zammad
systemctl stop zammad

Une fois Zammad arrêtez vous devrez commencer par vider le cash.

#Vider le cache Zammad
zammad run rails r "Rails.cache.clear"

Une fois ces étapes effectuées, il ne vous reste plus cas mettre à jour Zammad.

#Mettre à jour Zammad
apt update
apt upgrade

B-Entretien :

1. Création Sauvegarde :

Avant de pouvoir exécuter une sauvegarde ou une restauration, les scripts vous demandent de fournir un fichier de configuration. Nous expédions un config.dist dans les /opt/zammad/contrib/backup répertoire que vous pouvez simplement renommer.

Pour ce faire, exécutez les commandes suivantes en tant qu'utilisateur root ou zammad.

cd /opt/zammad/contrib/backup/
mv config.dist config

#Création de la Backup
/opt/zammad/contrib/backup/zammad_backup.sh

2. Restauration d'une sauvegarde :

#Restoration d'une Backup
/opt/zammad/contrib/backup/zammad_restore.sh

MK-GLPI - Comparatif avec Zammad

01-Cahier des charges

GLPI va permettre de faire la remonté d'inventaire du parc informatique via l'agent Fusion Inventory qui sera déployé sur l'ensemble des postes.

En parallèle une gestion de ticket sera mise en place pour pouvoir répondre aux demandes internes mais aussi potentiellement aux demandes externes.

Cahier des charges :

GLPI doit pouvoir être connecté à notre serveur OpenLDAP pour l'authentification.
GLPI doit pouvoir fournir une interface web permettant de gérer les tickets
GLPI doit pouvoir gérer plusieurs types de demande de ticket :
- Création d'un ticket depuis l'interface
- Création d'un ticket depuis 1 ou plusieurs adresses mail en fonction du type de demande
GLPI doit pouvoir cloisonner les types de demande par groupe d'utilisateur

Exemple de type de demande :
- Support Service Informatique Interne
- Supprt Applicatif GO
- Support Applicatif SIG
- Support autres à définir

GLPI doit pouvoir adapter le processus de gestion de vie du ticket en fonction du type de demande

GLPI doit pouvoir remonter de stats de suivi des tickets de façon manuelle voir automatique

MK-GLPI - Comparatif avec Zammad

02-Exploitation de GLPI

B - Gestion des entités :

1. Principe de fonctionnement :

Les entités servent principalement à classer et à isoler des éléments.
Un utilisateur attribué à une entité aura une visibilité uniquement sur cette entité. le choix de cette visibilité est défini par le profil de l'utilisateur.

L'entité racine est toujours présente. C'est le point de départ de l'arborescence, et on ne devrait rien y mettre si ce n'est le compte super-admin.

L'entité clients doit contenir l'ensemble des entités de nos clients. Chaque client doit posséder sa propre entité.

2. Création d'une entité :

Renseigné les champs demandés :
Nom : Nom du client
Comme enfant de : l'entité doit toujours être enfant de Clients, elle héritera de la configuration de base de l'entité.

Cliquez sur le bouton "Ajouter" pour créer l'entité.
Pour éditer ou modifier une entité, il suffit de retourner dans le menu "Administration/Entités" et de sélectionner le nom de l'entité.

3. Modifier l'entité d'un ticket :

Lorsqu'un ticket est créé au support alors que le contact n'est pas référencé dans la base utilisateurs de GLPI, ce ticket est attribué par défaut à l'entité "Client".
Il est important de ne jamais laisser de ticket attribué à l'entité client pour des raisons de confidentialité et de suivi des tickets pour les clients.
Si le contact n'existe pas, il faut le créer. Voir la procédure de création d'un utilisateur.

Pour modifier l'entité d'un ticket, il faut Aller dans "Accueil/Vue globale" :
- Si le ticket n'est pas encore attribué à un technicien : cliquez sur "Nouveau".
- Si le ticket à déjà été attribué à un technicien : cliquez sur "En cours (Attributé)".

4. Modifier l'entité d'un ticket :

Cocher le ou les tickets à déplacer dans une même entité puis cliquer sur le bouton "Actions".

Dans la fenêtre sur le menu déroulant du "mode de transfert" et sélectionnez "Complet".

Sélectionnez ensuite l'entité dans le menu déroulant et cliquez sur "Exécuter".

Le ticket est maintenant associé à l'entité choisie.

B - Gestion des profils :

1. Principe de fonctionnement :

Un profil utilisateur permet de personnaliser les accès et l'affichage des menus de GLPI pour les clients.

2. Liste des profils existants :

Super_Admin :
Ce profil est uniquement attribué aux personnes de Netensia car il donne tout les accès à GLPI.

Client_XXX :
Ce profil est attribué par défaut à la création d'un nouvel utilisateur dans GLPI. Il permet de limiter la consultation des tickets uniquement dans l'entité de l'utilisateur.

post-only :
Ce profil permet de visualiser uniquement ses propres tickets dans GLPI. Utile pour les prestataires de nos clients par exemple.

Notif_tickets :
Ce profil est utilisé pour les alertes de nouveaux tickets dans Rocket.Chat

C - Procédure de création et de modification d'un utilisateur :

Un compte utilisateur peut être attaché à une ou plusieurs entités. Lors de la création d'un utilisateur, il faut s'assurer d'être dans l'entité racine (celle par défaut).

1. Création d'un nouveau compte utilisateur :

Cliquer sur "Administration/Utilisateurs"
Dans le menu (de gauche) "Utilisateurs", renseignez les éléments ci-dessous :
- Identifiant : pnom (1ere lettre du prénom suivi du nom de famille, le tout en minuscule).
- Nom de Famille : (1ere lettre en Majuscule, le reste en minuscule).
- Prénom : (1ere lettre en Majuscule, le reste en minuscule).
- Actif : Oui
- Adresses de messagerie : Il est possible d'en ajouter plusieurs depuis le passage à la version 0.90.
- Entité par défaut : Renseigner ce champ plus tard en suivant la procédure décrite pus bas. Il n'est pas possible d'ajouter l'entité par défaut avant d'avoir habilité l'utilisateur dans son entité.

Cliquer sur le bouton "Sauvegarder" afin d'enregistrer les modifications.

2. Ajouter d'une habilitation à un utilisateur :

L'habilitation permet d'associer un utilisateur à une entité.
Cliquer sur le menu de gauche "Habilitations".

Sélectionner l'entité que vous souhaitez ajouter à l'utilisateur, choisissez le profil "Client_XXX" et cliquer sur le bouton ajouter.
L'utilisateur est maintenant associé à l'entité désirée.

3. Modifier l'entité par défaut d'un utilisateur :

Il faut maintenant modifier l'entité par défaut de l'utilisateur. Pour cela, cliquer de nouveau sur le menu de gacuhe "Utilisateur", modifier le champ "Entité par défaut" en bas à droite et sélectionner l'entité. cliquer sur "Sauvegarder" afin d'enregistrer les modifications.

D - Suppression ticket en Base sans notification :

Dans certains cas, il peut être utile de supprimer un ticket directement depuis la base de données de GLPI. Cette méthode permet d'éviter de notifier le contact au moment de la suppression/clôture.
Il faut utiliser cette méthode le moins possible afin de garder une base de données saine et des stats cohérents.

Se connecter en SSH sur "extranet.netensia.net"
Se connecter à MySQL et taper la commande ci-dessous avec entre parenthèse le N° du ticket.

mysql
USE glpi
UPDATE glpi_tickets SET status='6' WHERE ID IN (N°_Ticket);

Le ticket disparaîtra de l'interface GLPI sans notification.

E - Mise à jour de GLPI :

La mise à jour de GLPI ne doit pas être appliquée directement sur la PROD.
Il est préconiser de copier le dossier ainsi que la base de données pour tester la mise à jour.

1. Sauvegarde :

# Sauvegarder le dossier /var/www/glpi en /var/www/glpi_DATE.bck
cp -rp /var/www/glpi /var/www/glpi_20180110.bck

# Sauvegarder la base de données :
mysqldump glpi > /root/glpi-20180110.sql

2. Création de la base de test de GLPI :

# Copier le dossier glpi sur un dossier de test :
cp -rp /var/www/glpi /var/www/glpitest

Modification du vhost :
Editer le fichier "/etc/apache2/sites-enabled/extranet.netensia.net.conf" et décommenter la ligne ci-dessous :

	Alias /glpitest /var/www/glpitest

# Création de la base de test : 
create database glpi2;

# Import dans la base de test : 
mysql -D glpi2 < /root/glpi-20180110.sql

3. Installation de la nouvelle version :

Télécharger et décompresser la nouvelle version de GLPI dans /root
Il est important de le faire dans root car la décompresser va créer un dossier glpi. Il ne faut pas écraser la PROD.

cd /root/
wget https://github.com/glpi-project/glpi/releases/download/9.2.1/glpi-9.2.1.tgz
tar zxf glpi-9.2.1.tgz

Copier le contenu dans le dossier glpitest (sans confirmation) :

\cp -rf /root/glpi/* /var/www/glpitest/

4. Paramétrage de la nouvelle version de GLPI (Base de données...) :

Se connecter sur l'URL ci-dessous :

URL : https://extranet.domain.tld/glpitest

F - Configuration de la gestion des flux mail :

Dans cette configuration, la création de tickets se fait via une seule adresse mail.
Garder cette adresse et créer autant d'alias que d'entités souhaitées (selon le nombre de services, de sous-services, etc)
Dans cette procédure, une entité = un alias = un service
Ici une illustration de l'arborescence :

Commencer par créer les collecteurs de mails en plus de celui précédemment créé.
Remplir les champs comme pour le premier collecteur en prêtant attention à bien saisir un alias comme nom et non pas l'adresse mail originale.

Attention également à saisir le bon id et mot de passe qui sont ceux de l'adresse originale.

Lorsque l'opération a été répétée autant de fois qu'il y a d'alias, le résultat doit ressembler au suivant :

Continuer avec la création des entités.
Se rendre sur Administration puis Entités.

Ici, créer une entité "enfant" de l'entité racine native de GLPI. Cela n'est pas forcément nécessaire, mais cela permet de garder une base saine et surtout du pouvoir rajouter une ou plusieurs structures au cas où l'entreprise se développe dans le futur.
Cliquer sur "+".

Saisir le nom de l'entité, la première correspond généralement au nom de votre entrerpise ou domaine, choisir enfant de l'entité racine puis Ajouter.

Retourner dans le menu des entités et cliquer sur celle qui vient d'être créée.

La page suivante s'affiche. Non-ogbligatoire à remplir l'onglet adresse (en vert).
Dans l'onglet suivant Informations avancées, choisir le répertoire LDAP.

Dans l'onglet notifications, saisir l'adresse mail du support concerné ainsi que l'identifiant de l'administrateur.
Laisser les autres paramètres en héritage de l'entité parente.
Ne pas oublier de sauvegarder en bas de page.

Dans assistance, paramétrer la clôture automatique des futurs tickets.
Choisir l'effet souhaité, immédiat, 1 jour, 2 jours, 7 jours, etc.
Sauvegarder.

Se positionner ensuite sur utilisateur et paramétrer l'administrateur général de glpi en super-admin.
Le paramètre récursif permet à l'administrateur d'associer le profil également sur les entités enfants.

Répéter la manipulation pour chaque nouvelle entité.
Avant d'associer les utilisateurs à l'entité, il faut paramétrer le profil "self-service", profil d'utilisateur souhaitant faire un ticket.
Cela va permettre de choisir l'interface de connexion simplifiée, les différents types de droits des utilisateurs du groupe.

Choisir les paramètres selon le cahier des charges en cours.

S'arrêter après cette dernière sauvegarde.
Associer maintenant les utilisateurs aux entités.
Se rendre sur la page utilisateur, onglet habilitation, choisir la bonne entité, le profil souhaité, et non récursif (PS :Le profil " self-service" est paramétrable dans administration/profils)

Les utilisateurs sont associés à l'entité avec leur profil correspondant.

G - Automatisation de la récupération des mails :

Pour commencer, se connecter au serveur qui héberge GLPI.
S'identifer en utilisateur root.
Saisir la commande suivante.

crontab -e

Ajouter en dernière ligne ceci puis contrôle o pour sauvegarder et contrôle x pour quitter.

(Pour information, les étoiles correspondent dans l'ordre à : minute, heure, jour/mois, mois, jour/semaine)
Ici la syncrhonisation se fera donc toutes les minutes.
Vérifier le bon fonctionnement de cron avec les deux commandes suivantes.
La première informe si cron est actif et la seconde informe de son bon fonctionnement.

	systemctl status cron

tail -f /var/log/cron.log

Configurer maintenant les actions automatiques dans Glpi.
Pour cela, se rendre sur l'onglet Configuration, puis Actions automatiques.

Sélectionner toutes les actions et cliquer sur actions.

Sélectionner ensuite modifier, mode d'exécution et choisir CLI afin que ça soit la commande Cron qui soit prise en compte pour l'automatisation, finir en cliquant sur envoyer.

Toutes les actions sont paramétrées en CLI.

Saisir mailgate dans la barre de recherche et cliquer pour ouvrir les paramètres.

Apporter les modifications suivantes. Choisir une fréquence d'exécution égale à celle configurée avec crontab précédemment, statut en programmée et SURTOUT bien choisir CLI dans le mode d'exécution.

Faire un test avec un envoi de mail utilisteur au support, le ticket se créé automatiquement.

H - Gestion des catégories :

1. base de connaissances :

Glpi propose nativement la création d'une base de données de connaissances afin de mutualiser les connassances des différents techniciens sur les différentes problématiques qu'ils peuvent rencontrer.
Pour qu'elle soit active, il faut créer des catégories (voir même des sous-catégories) afin de classer les informations.

Se rendre dans configuration, intitulés puis catégories de la base de connaissances.

Activer l'effet pour les sous-entités.
Saisir le nom du répertoire de connaissance voulu.
Ajouter.

Répéter l'action autant de fois que de répertoire souhaité.

1. ITIL :

Les catégories ITL vont déterminées la catégorie à laquelle un ticket va être affecté.

Se rendre sur configuration puis intitulés.
Cliquer sur catégories ITIL.

1. Sauvegarde :

I - Changement de logo :

Pour changer de logo, utiliser filezilla client et se connecter au serveur hébergeant glpi.
La connexion établie se rendre dans /var/www/html/glpi/pics
Les deux logos qui seront modifier ici seront celui de la page d'identification et celui de l'acceuil de l'interface web.
Le premier s'intitule login_logo_glpi et le second fd_logo.

Attention les images doivent être en .png et respecter la taille des logos glpi de base.

Lorsque cela est fait, se déconnecter (si connecter) de l'interface web et se reconnecter. Les logos auront été modifiés.

J - Gestion des tickets :

1. Création de tickets par mail :

Commencer par créer un collecteur de mail. Pour cela, se rendre sur Configuration puis Collecteurs.

Cliquer sur le "+" et une fenêtre s'ouvre.

Plusieurs champs sont à remplir.

Nom : @ mails du serveur
Actif : Oui
Serveur : Domaine du serveur de mail
Options de connexion : Ici attention à bien vérifier les options configurer ces options par rapport aux paramètres du serveur mail que l'on souhaite lié.
Dossier des messages entrants : Saisir le nom du dossier de réception voulu ou laisser ce champs vide.
Port : Optionnel mais conseiller.
Chaine de connexion : Se créée lors qu'un numéro de port est saisi.
Identifiant : Id du compte de l'@ mail.
Mot de passe : Son mot de passe.

Les champs suivants ont été laissés par défaut comme illustré ci-dessous.
Sauvegarder.

Cliquer ensuite sur Actions puis Récupérer les courriels maintenant.

Une petite notification apparaît dans le bas droit de l'écran.

Quand cette étape est finie, envoyer ou se faire envoyer un mail par un utilisateur de la baseDN.
Une nouvelle notification s'affiche.

Un message d'erreur indiquant une erreur concernant l'envoie du mail retour.
Le mail qui s'envoie sur la boîte mail du support pour prévenir de la demande.

Se rendre dans l'onglet Configuration, puis Notifications.

Activer toutes les notifications, enregistrer puis cliquer sur Configuration des notifications par courriels.

Ici remplir les champs suivant l'exemple qui suit.

Après avoir cliquer sur Envoyer un courriel de test à l'administrateur, cette notification s'affiche.

Consulter la boîte mail associer et s'assurer d'avoir reçu le mail correspondant au test.

Un ticket a été créé précédemment suite à l'envoie du mail test pour le collecteur.
Cliquer sur Assistance, puis Tickets.

La page des tickets s'affiche, le ticket créé par l'envoi d'un mail utilistauer est bien présent.

Et l'envoi du mail associé à la demande se fait aussi correctement.

La création de tickets par mail se déroule comme voulue tout comme l'envoi des mails suite aux demandes.

A ce stade, la récupération des mails se fait manuellement mais celle-ci peut être automatiser.

2. Suivi des tickets :

Le suivi du ticket est la première manipulation du technicien qui va donner vie au ticket et entamé la procédure de support.

Gabarit du suivi

Le gabarit de suivi va permettre l'intégration direct d'un message expliquant par exemple que le ticket vient d'être pris en charge par les équipes supports.
Le contenu de ce gabarit est envoyé par mail à l'utilisateur demandeur.

3. Les solutions des tickets :

Types de solution

Se rendre sur configuration puis intitulés.
Cliquer sur l'intitulé types de solutions.

Cliquer le "+" d'ajout.

Saisir le nom du type de solution
Ajouter

Exemple d'une liste de types de solutions

Gabarits de solution

Le gabarit de solutions va permettre l'intégration direct d'un message expliquant quelle solution va être appliquée.
Le contenu de ce gabarit est envoyé par mail à l'utilisateur demandeur.

Cliquer sur "+" d'ajout

Autoriser l'effet sur les sous-entités.
Nommer le gabarit, saisir le contenu et ajouter.
Laisser volontairement le champ type de solution vide. Celui-ci sera défini lors du traitement du ticket par le technicien.

Répéter l'opération autant de fois que désiré.

K - Gestion des groupes :

Il est possible d'ajouter des groupes via un LDAP mais aussi manuellement.

A réitérer autant de fois que nécessaire.

L - Gestion des règles :

1. Règle pour que le ticket se créé dans la même entité que l'utilisateur demandeur :

Se rendre dans les règles pour assigner un ticket créé via un collecteur de courriels.

Cliquer sur le "+" pour créer une nouvelle règle.

Saisir le nom de la nouvelle règle, ou en opérateur logique et oui pour actif.

Dans les critères, choisir l'utilisateur possédant le profil "self-service" et ajouter.

Dans actions, cliquez sur ajouter une nouvelle action.

Choisir entité depuis profil de l'utilisateur et ajouter.

L'action apparaît comme ci-dessous.

La règle est créée, l'entité du ticket sera la bonne entité de l'utilisateur.

2. Règle pour la priorité des billets

Se rendre dans les règles métiers pour les tickets

Cliquez sur le "+" d'ajout de règle

Nommer la nouvelle règle priorités et suivre l'exemple suivant.

Dans critères, choisir description, est, urgent. C'est à dire que tous les mails entrants ayant urgent dans leur contenu seront classés en très haute priorité.

Dans les actions, sélectionnez la priorité et paramétrez sur très haute.

Les mails contenant désormais urgents créeront des tickets en haute priorité.

3. Règle pour assigner directement les tickets à leur création

Se rendre dans les règles métier pour les tickets

Cliquez sur le "+" d'ajout

Mettre oui pour les sous-entités, saisir un nom pour la règle, opérateur logique en et, actif oui et règle utilisée pour ajouter. Sauvegarder

Dans les critères, choisir comme valeur entité et l'entité correspondant à l'association souhaitée.

Dans les actions, choisissez l'utilisateur ou les groupes de techniciens auxquels on souhaite assigner les tickets.

Lorsqu'un utilisateur de l'entité a créé un ticket, celui-ci est attribué directement au bon groupe de techniciens.

MKT-KeeWeb

01 - Description

A - Description :

Nom DNS interne :
Nom DNS Externe :
Type de serveur (Physique, VMware, LXC, Docker...) : Docker
OS : Ubuntu 22.04
CPU : 3
RAM : 4Go
Disque LVM : 50 Go
/ :

Réseaux :

Adresse IP : 192.168.56.194
Masque : 255.255.255.0
Passerelle : 192.168.56.254
DNS : 192.168.56.1
VLAN :

Stockage :

1. Rôle :

KeeWeb est un gestionnaire de mots de passe gratuit et open source compatible avec KeePass, disponible en version Web et en applications de bureau.

1. Checklist - Création du serveur :

Sécurité :

[*] Création compte adminme
[*] Changement mot de passe root
[*] Changement mot de passe adminme
[*] Sécurisation des mots de passe (20 caractères minimum et 3 types de caractères différents)
[*] Mise à jour du coffre fort de mot de passe
[*] Déploiement clé SSH
[ ] Paramétrage du SUDO NOPASSWORD
Liste des Ports ouverts :

MKT-KeeWeb

02 - Installation

A -Installez Docker CE sur Ubuntu 22.04 :

1. Installation des packages Docker :

Installez les packages de dépendances Docker sur Ubuntu 20.04 avec la commande ci-dessous.

sudo apt update
sudo apt install apt-transport-https ca-certificates curl software-properties-common

2. Clé Docker GPG :

Ajoutez ensuite la clé Docker GPG et le référentiel Docker à votre serveur Ubuntu comme ci-dessous :

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"

3. Mise à jours des Packages :

Mettez maintenant à jour les packages et installez Docker CE sur Ubuntu :

sudo apt-get update
sudo apt install docker-ce

4. Vérification :

Une fois installé, le démon Docker devrait être automatiquement démarré. Vous pouvez confirmer le statut comme ci-dessous :

$ systemctl status docker
● docker.service - Docker Application Container Engine 
    Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled) 
    Active: active (running) since Sat 2020-10-17 16:28:08 EAT; 57s ago 
TriggeredBy: ● docker.socket 
      Docs: https://docs.docker.com 
  Main PID: 2807 (dockerd)

5. Ajout d'utilisateur :

Vous pouvez ajouter votre utilisateur au groupe Docker afin de ne pas avoir à écrire sudo lors de l'exécution de commandes Docker.

sudo usermod -aG docker {USER}
newgrp docker

B - Installation de KeeWeb sur Ubuntu :

1. Construction de KeeWeb :

Nous allons construire Keeweb à partir des sources avec les commandes ci-dessous :

docker pull svenc56/keeweb
git clone https://github.com/SvenC56/docker-keeweb.git
cd docker-keeweb
docker build -t svenc56/keeweb .

2. Exécution de l'image :

Exécutez maintenant l'image keeweb et exposez-la sur le port 80 comme indiqué ci-dessous :

docker run -d -p 80:80 keeweb

C - Erreur :

Une fois KeeWeb installée, vous pouvez y accédé depuis le navigateur avec https://<your-host-ip>. Il est possible que vous ayez une page blanche, si c'est le cas, c'est tout simplement parce que vous essayez de vous connecter en http, pour une question de sécurité, la connexion ; http est bloquer par KeeWeb. Pour y remédier, vous devrez paramétrer le r-proxy.

MK-Guacamole

01 - Description

Une description :

Nom DNS interne :
Nom DNS Externe :
Type de serveur (Physique, VMware, LXC, Docker...) : Conteneur LXC
OS : Ubuntu 22.04
CPU :
RAM :
Disque LVM :
/ :

Réseaux :

Adresse IP :
Masque : 255.255.255.0
Passerelle :
DNS : 192.168.1.50
VLAN :

1. Checklist - Création du serveur :

Domaine :

[*] Configuration de l'enregistrement A sur v.sdem.fr
[*] Configuration de l'enregistrement PTR sur v.sdem.fr
[*] Configuration de l'enregistrement A sur sdem.fr (interne)
[x] Configuration de l'enregistrement A sur sdem.fr (externe)
[x] Ajout du serveur dans la zone DNS morbihan-energies.fr avec un enregistrement CNAME

Sécurité :

[*] Création compte adminme
[*] Changement mot de passe root
[*] Changement mot de passe adminme
[*] Sécurisation des mots de passe (20 caractères minimum et 3 types de caractères différents)
[*] Mise à jour du coffre fort de mot de passe
[*] Déploiement clé SSH
[*] Paramétrage du SUDO NOPASSWORD
Liste des Ports ouverts :

Sauvegarde :

[*] Configurer la sauvegarde locale
[*] Configurer la sauvegarde sur le PRA (si serveur critique)
[ ] Configurer la sauvegarde de Base de données (Dump local)

Autres :

[*] Ajout du serveur dans Guacamole
[*] Ajout du serveur dans la supervision
[*] Ajout de la documentation d'installation et de paramétrage de la VM dans ZIM
[ ] Configuration du NTP

A - Qu'est ce que Guacamole:

Le serveur Apache Guacamole sera utilisé comme point d'entrée unique pour accéder aux serveurs et équipements de l'infrastructure que ce soit via les protocoles RDP, SSH, VNC et Telnet, et même Kubernetes. Que l'on soit en externe ou en interne, les connexions aux serveurs vont passer obligatoirement par l'hôte Apache Guacamole.

Dans l'exemple ci-dessous, l'hôte Apache Guacamole est positionné en DMZ puisqu'il doit être accessible depuis l'extérieur. L'accès depuis l'extérieur n'est pas obligatoire puisque l'on pourrait imposer une connexion VPN au réseau de l'entreprise avant de permettre la connexion sur l'interface de Guacamole. De la même manière pour publier l'hôte Guacamole sur Internet, il est recommandé de s'appuyer sur un reverse proxy en frontal (le pare-feu pourrait très bien assurer cette fonction), ce qui permettra en même temps de passer les flux en HTTPS.

Apache Guacamole devient un élément central de l'infrastructure puisqu'il sert de passerelle pour administrer les machines. Rassurez-vous, il est possible d'avoir plusieurs hôtes Apache Guacamole pour répartir la charge et assurer la haute disponibilité.

Enfin, les règles de pare-feu doivent aussi être adaptées : l'hôte Apache Guacamole doit être le seul à pouvoir se connecter en RDP/SSH/VNC/Etc. sur les machines de l'infrastructure.

MK-Guacamole

02 - Installation

A - Installation de Guacamole :

1. Installation des Dépendances :

sudo apt-get install libcairo2-dev libjpeg-turbo8-dev libpng-dev libtool-bin uuid-dev libossp-uuid-dev libwebsockets-dev libssl-dev libavcodec-dev freerdp2-dev libpango1.0-dev libssh2-1-dev libtelnet-dev libwebsockets-dev libpulse-dev libvorbis-dev libwebp-dev libavcodec-dev libavformat-dev libavutil-dev libswscale-dev

2. Télécharger Serveur Guacamole :

wget https://downloads.apache.org/guacamole/1.5.3/source/guacamole-server-1.5.3.tar.gz

3. Décompression :

tar -xvf guacamole-server-1.5.3.tar.gz
cd guacamole-server-1.5.3
autoreconf -fi

4. Script de Configuration :

./configure --with-init-dir=/etc/init.d

5. Compilation et installation :

make
make install

6. Liens :

ldconfig

Redémarrage des services 1

systemctl restart guacd

B - Installation de Tomcat :

1. Installation de Tomcat :

sudo apt-get install tomcat9 tomcat9-admin tomcat9-common tomcat9-user
sudo mkdir /etc/guacamole/
sudo wget https://downloads.apache.org/guacamole/1.5.3/binary/guacamole-1.5.3.war -O /etc/guacamole/guacamole.war

2. Lien symbolique avec Tomcat :

sudo wget https://downloads.apache.org/guacamole/1.5.3/binary/guacamole-1.5.3.war -O /etc/guacamole/guacamole.war

Redémarrer Guac Tomcat 1

systemctl restart tomcat9
systemctl restart guacd

3. Extension du répertoire :

mkdir /etc/guacamole/{extensions,lib}

C-MYSQL :

1. Installation de MySQL :

apt install mariadb-server
mysql_secure_installation

2. Création d'une base de données Guacamole :

mysql -u root -p
CREATE DATABASE guacamole_db;
CREATE USER 'guacamole_user'@'localhost' IDENTIFIED BY 'Testeur';
GRANT SELECT,INSERT,UPDATE,DELETE ON guacamole_db.* TO 'guacamole_user'@'localhost';
FLUSH PRIVILEGES;
quit;

3. Module Mysql/Guacamole :

wget https://downloads.apache.org/guacamole/1.5.3/binary/guacamole-auth-jdbc-1.5.3.tar.gz
tar -xvf guacamole-auth-jdbc-1.5.3.tar.gz

4. Extension Mysql/Guacamole :

cp guacamole-auth-jdbc-1.5.3/mysql/guacamole-auth-jdbc-mysql-1.5.3.jar /etc/guacamole/extensions/

5. Importer le schéma dans la base de donné :

cat guacamole-auth-jdbc-1.5.3/mysql/schema/*.sql | mysql -u root -p guacamole_db

6. Pilote Mysql/Guacamole :

wget https://cdn.mysql.com//Downloads/Connector-J/mysql-connector-j-8.0.33.tar.gz
tar -xvzf mysql-connector-j-8.0.33.tar.gz
cp mysql-connector-j-8.0.33/mysql-connector-j-8.0.33.jar /etc/guacamole/lib/

Redémarrage Mysql 1

systemctl restart mariadb.service

7. Fichier de propriété Guacamole :

touch /etc/guacamole/guacamole.properties
nano /etc/guacamole/guacamole.properties

echo "
# Hostname and Guacamole server port
guacd-hostname: localhost
guacd-port: 4822

# MySQL properties
mysql-hostname: localhost
mysql-port: 3306
mysql-database: guacamole_db
mysql-username: guacamole_user
mysql-password: Testeur
" > /etc/guacamole/guacamole.properties

Redémarrer Guac Tomcat 2

systemctl restart tomcat9
systemctl restart guacd

8. Connexion via l'interface :

http://adresseIP:8080/guacamole/

D - Connexion LDAP :

1. Installation du LDAP :

Tout d'abord, connectez-vous sur le serveur Guacamole en ligne de commande afin d'installer l'extension LDAP.

Ensuite, positionnez-vous dans "/tmp" et téléchargez l'archive tar.gz de l'extension :

cd /tmp
wget https://downloads.apache.org/guacamole/1.5.2/binary/guacamole-auth-ldap-1.5.2.tar.gz

Une fois que c'est fait, décompressez cette archive tar.gz :

tar -xzf guacamole-auth-ldap-1.5.2.tar.gz

Puis, déplacez le fichier JAR de l'extension vers le répertoire "extensions" de Guacamole.

sudo mv guacamole-auth-ldap-1.5.2/guacamole-auth-ldap-1.5.2.jar /etc/guacamole/extensions

Pour que cette extension soit prise en charge, il convient de redémarrer Tomcat9 :

sudo systemctl restart tomcat9

2. Connexion au LDAP :

Toujours sur le serveur Apache Guacamole, ouvrez le fichier de configuration :

sudo nano /etc/guacamole/guacamole.properties

Dans ce fichier, il y a déjà d'autres propriétés définies, notamment les informations de connexion à la base de données MySQL (MariaDB). Vous devez configurer l'extension LDAP.

Tout d'abord, vous devez indiquer le nom du contrôleur de domaine, le port LDAP ( 389 par défaut) et la méthode de chiffrement ( none avec du LDAP classique). Ce qui donne les lignes suivantes à ajouter dans le fichier :

### Active Directory
# Controleur de domaine
ldap-hostname: ldap.v.sdem.fr
ldap-port: 389
ldap-encryption-method: none

Deuxièmement, à la suite, vous devez ajouter les informations sur le compte à utiliser pour s'authentifier auprès de l'annuaire Active Directory. Ce compte sert uniquement à lire le contenu de l'annuaire (utilisateurs, groupes et membre des groupes). Dans l'exemple ci-dessous, le compte « Sync_Guacamole@it-connect.local » est utilisé.

# Utilisateur pour connexion AD
ldap-search-bind-dn: cn=LDAP Administrator,ou=DIT Roles,dc=sdem,dc=fr
ldap-search-bind-password: PASSWORD

Troisièmement, vous devez indiquer comment rechercher les utilisateurs dans l'Active Directory . Comme base DN, c'est-à-dire comme base de recherche , on évite de mettre la racine de l'annuaire Active Directory.

Ici, l'OU " OU=Tiering,OU=IT,DC=it-connect,DC=local " qui contient d'autres sous-OU ainsi que les comptes d'administration seront ciblés. Tout ce qui est en dehors de cette racine " ne sera pas vu " par Guacamole. Ceci correspond au paramètre " ldap-user-base-dn ". Ensuite, le paramètre " ldap-username-attribute " sert à préciser l'attribut AD utilisé pour les noms d'utilisateurs.

Enfin, le paramètre « ldap-user-search-filter » permet de déclarer le filtre de recherche. Ici, on prend tous les utilisateurs qui sont membres du groupe de sécurité Active Directory « GDL-Guacamole-Access ».

# Recherche des utilisateurs
ldap-user-base-dn: ou=People,dc=sdem,dc=fr
ldap-username-attribute: uid
#ldap-user-search-filter: (&(objectClass=User)(sAMAccountName=*)(memberOf:1.2.840.113556.1.4.1941:=CN=GDL-Guacamole-A>

Quatrièmement, vous devez ajouter des paramètres de recherche pour les groupes . Si vous souhaitez rechercher uniquement les utilisateurs, cette partie n'est pas obligatoire. Sur le même principe, on indique la base de recherche et le filtre. Ici, on prend tous les groupes situés sous la base DN.

# Recherche des groupes
#ldap-group-base-dn: OU=Tiering,OU=IT,DC=it-connect,DC=local
#ldap-group-search-filter: (objectClass=Group)

Le fichier de configuration est prêt ! Sauvegardez et fermez le fichier. Il ne reste plus qu'à relancer Tomcat9 :

sudo systemctl restart tomcat9

Grafana

01 - Description

A - Description

Hyper-V : Debian

Distribution : Debian 12.5

1 Version

Installation de Grafana en utilisant la dernière version stable disponible (12.0) au moment de la rédaction.
L'utilisation de cette version garantit non seulement l'accès aux dernières fonctionnalités, aux améliorations de performance et aux correctifs de sécurité, mais représente également une nette évolution par rapport à la version 9.1.5 précédemment utilisée. En effet, cette ancienne version offre significativement moins d'avantages en termes de compatibilité avec les sources de données modernes, de capacités d'alerte unifiées, de personnalisation de l'interface, et de prise en charge des tableaux de bord avancés.

Différence entre les version

- Alertes et notifications

Alerting unifié : Introduction d'un système d'alertes unifié avec une interface utilisateur améliorée, remplaçant les anciens systèmes d'alertes. AWS Documentation
Opsgenie : Ajout du support des répondants dans l'intégration Opsgenie.GitHub

- Sécurité et authentification

Comptes de service : Remplacement des clés API par des comptes de service pour une gestion plus sécurisée de l'accès à Grafana. AWS Documentation
Authentification externe : Verrouillage des rôles d'organisation synchronisés depuis les fournisseurs d'authentification externes.

- Visualisations et transformations

Transformations : Refonte de l'onglet Transformations avec une expérience utilisateur et une conception visuelle améliorées. AWS Documentation
Canvas : Ajout de la fonctionnalité de zoom et de panoramique pour une meilleure interactivité.

- Sources de données et intégrations

Prometheus : Amélioration des performances et de l'utilisabilité, avec l'introduction d'une encyclopédie des métriques et d'un cache du navigateur Prometheus. AWS Documentation
InfluxDB : Utilisation de la configuration SQL par défaut pour une meilleure compatibilité.

- Développement et plugins

React 18 : Mise à jour vers React 18, apportant des améliorations de performance et de sécurité. Grafana Labs+1GitHub+1
Plugins : Amélioration de la gestion des plugins, avec des options pour désactiver l'interface de dépréciation Angular pour des plugins spécifiques.

- Rapports et personnalisation

Rapports : Amélioration de l'interface utilisateur des rapports pour une meilleure correspondance avec le nouveau style de navigation. Grafana Labs
Personnalisation : Amélioration de la personnalisation de l'interface utilisateur pour une meilleure adaptation aux besoins spécifiques.

2 Sources

https://grafana.com/docs/grafana/latest/setup-grafana/installation/debian/

Grafana

02 - Installation

A - Installation à partir du référentiel APT

1 Paquet

Installez les packages prérequis.

sudo apt-get install -y apt-transport-https software-properties-common wget

2 Clé GPG

Importer la clé GPG.

sudo mkdir -p /etc/apt/keyrings/
wget -q -O - https://apt.grafana.com/gpg.key | gpg --dearmor | sudo tee /etc/apt/keyrings/grafana.gpg > /dev/null

3 Référentiel Stable

Pour ajouter un référentiel pour les versions stables, exécutez la commande suivante.

echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com stable main" | sudo tee -a /etc/apt/sources.list.d/grafana.list

4 Référentiel Bêta

Pour ajouter un référentiel pour les versions bêta, exécutez la commande suivante.

echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com beta main" | sudo tee -a /etc/apt/sources.list.d/grafana.list

5 Mise à jour

Exécutez la commande suivante pour mettre à jour la liste des packages disponibles.

sudo apt-get update

6 Installation Grafana OSS

Pour installer Grafana OSS, exécutez la commande suivante.

sudo apt-get install grafana

7 Installation Grafana Entreprise

Pour installer Grafana Enterprise, exécutez la commande suivante.

sudo apt-get install grafana-enterprise

Grafana

03 - Maintenance

A - Sauvegarde

1 Sauvegarde de la base de donné Grafana

C’est là où sont stockés les dashboards, datasources, utilisateurs, organisations, etc.
Par défaut, Grafana utilise SQLite, mais il peut aussi utiliser MySQL ou PostgreSQL.

sudo cp /var/lib/grafana/grafana.db /chemin/vers/ta/sauvegarde/

2 Sauvegarde de la configuration

Le fichier de configuration principal contient les paramètres d’accès, de stockage, etc.

sudo cp /etc/grafana/grafana.ini /chemin/vers/ta/sauvegarde/

Vous pouvez aussi sauvegarder tout le dossier si tu as plusieurs fichiers.

sudo cp -r /etc/grafana/ /chemin/vers/ta/sauvegarde/etc-grafana/

3 Sauvegarde des plugins (si personnalisés)

Si vous avez installé des plugins manuellement ou via l’interface.

sudo cp -r /var/lib/grafana/plugins/ /chemin/vers/ta/sauvegarde/plugins/

4 Sauvegarde de la base InfluxDB

InfluxDB contient les métriques, pas les dashboards.

#Pour connaitre sa version InfluxDB
influxd version

#InfluxDB v1.x
influxd backup -portable /chemin/vers/ta/sauvegarde/influx-backup/

#InfluxDB v2.x
influx backup /chemin/vers/ta/sauvegarde/influx-backup/

5 Script

Création d’un script bash qui permet de sauvegarder la base de données de Grafana ainsi que les fichiers de configuration puis les plugins et pour finir la base de données Influxdb qu’il va transférer du docker sur la machine locale.

##############################################################
# Auteur : mkermorvant                                       #
# Date de modification : 20250515                            #
#                                                            #
# Description : Script de Sauvegarde de la config Grafana    #
# 
##############################################################
#! /bin/bash                                                 #
#                                                            #
##############################################################
# Variables :
echo ""
read -p "Entrez le chemin de Sauvegarde de la bdd Grafana: " BDDGRAFANA
read -p "Entrez le chemin de Sauvegarde des fichiers de configuration de Grafana: " CONF
read -p "Entrez le chemin de Sauvegarde des plugins: " PLUGINS
read -p "Entrez le nom de votre conteneur docker Influxdb: " NOM
read -p "Entrez le chemin de Sauvegarde de Influxdb dans votre conteneur: " CONTENEUR
read -p "Entrez le chemin de Sauvegarde de Influxdb dans votre machine: " INFLUXDB
read -p "Entrez votre token Influxdb: " TOKEN
echo ""
##############################################################
# 1 - Sauvegarde de la Base de Données de Grafana
sudo cp /var/lib/grafana/grafana.db ${BDDGRAFANA}
echo "La base de données de Grafana a été sauvegardé."

# 2 - Sauvegarde des Fichiers de configurations
read -r -p "Voulez-vous sauvegarder tout le dossier ? [y/N] " response

case "$response" in
    [yY][eE][sS]|[yY])
        echo "Sauvegarde du dossier."
        sudo cp -r /etc/grafana/ ${CONF}
        echo "Le dossier de configuration a bien été sauvegardé !"
        ;;
    *)
        sudo cp /etc/grafana/grafana.ini ${CONF}
        echo "Le fichié de configuration a bien été sauvegardé !"
        ;;
esac

# 3 - Sauvegarde des plugins
sudo cp -r /var/lib/grafana/plugins/ ${PLUGINS}
echo "Les plugins ont bien été sauvegardé !"
echo ""

# 4 - Sauvegarde de la base de données InfluxDB
influx_version=$(sudo docker exec ${NOM} influxd version)
echo "Version détecté : $influx_version"
read -r -p "Votre version est-elle en InfluxDB v2.x ? [y/N] " version

case "$version" in
    [yY][eE][sS]|[yY])
        sudo docker exec ${NOM} influx backup -t ${TOKEN} ${CONTENEUR}
        echo "La base de données Influxdb a bien été sauvegardé !"
        ;;
    *)
        sudo docker exec ${NOM} influxd backup -portable -t ${TOKEN} ${CONTENEUR}
        echo "Le fichié de configuration a bien été sauvegardé !"
        ;;
esac

sudo docker cp ${NOM}:${CONTENEUR} ${INFLUXDB}
echo "Votre base de données Influxdb à bien été copié dans vos réperoire."
echo ""

B - Mise à niveau Grafana

Pour mettre à niveau Grafana installé à partir du référentiel APT Grafana Labs, procédez comme suit :

1 Dépôt officiel

Mise à jour des paquet

sudo apt update
sudo apt upgrade grafana

Grafana se met à jour automatiquement lorsque vous exécutez apt-get upgrade.

##############################################################
# Auteur : mkermorvant                                       #
# Date de modification : 20250515                            #
#                                                            #
# Description : Script de mise à jour Grafana                #
#                                                            #
##############################################################
#! /bin/bash                                                 #
#                                                            #
##############################################################
# 1 - Ajout des dépôt
curl https://packages.grafana.com/gpg.key | sudo tee /usr/share/keyrings/grafana.asc
echo "Ajout du dépôt de Grafana à la liste des sources APT."
echo "deb [signed-by=/usr/share/keyrings/grafana.asc] https://packages.grafana.com/oss/deb stable main" | sudo tee />
echo ""

# 2 - Mise à jour des sources APT
echo "Mise à jour des sources APT."
sudo apt update
echo ""

# 3 - Vérification des versions disponible
echo "Vérification des versions disponible."
sudo apt-cache show grafana | grep Version
echo ""

# 4 - Mise à jour de Grafana
echo "Mise à jour de votre Grafana"
sudo apt-get install --only-upgrade grafana
echo ""

# 5 - Redémmarage du service
echo "Votre service Grafana va se redémmarer."
sudo systemctl restart grafana-server
echo ""
echo "Votre Grafana est maintenant à jour !"
echo ""

Zabbix

00 - Comparatif Zabbic Vs Grafana

1) Objectif des outils

Zabbix - Solution de supervision complète

Outil tout en un : collecte, stockage, alertes, découverte réseau, dashboards.
SNMP natif, agentless ou via agent
Très adapté aux infrastructures réseau (switchs, routeur, UPS, firewalls, serveurs ...)
Pensé pour la supervision IT classique (CPU, RAM, interfaces ...)

Grafana - Plateforme de visualisation

Outil centré sur les dashboards et la visualisation des données.
Ne collecte pas les données SNMP par lui même (obligé de passer par Télégraf)
Exelente ergonomie, très visuel.

2) Supervision SNMP : Comparaison détaillé

Critère SNMP	Zabbix	Grafana
Support SNMP natif	Oui, support complet intégré (SNMP v1/v2c/v3)	Non. Nécessite un collecteur externe (ex : Prometheus + snmp_exporter ou Telegraf + InfluxDB)
Poller SNMP intégré	Oui, polling interne via Zabbix server/proxy (bulk requests, retry). [zabbix.com]	Non. SNMP Exporter ou Telegraf doivent interroger les équipements et exporter les données vers une base compatible. [grafana.com]
SNMP Traps	Support natif des traps via snmptrapd + intégration directe dans Zabbix. [thezabbixbook.com]	Reçoit les traps uniquement via Telegraf SNMP Trap plugin → base → dashboard. Pas de traitement natif des traps.
Alertes basées sur SNMP	Oui, alerting avancé, triggers, escalades.	Limité : alerting possible via Prometheus Alertmanager ou alertes Grafana, moins puissantes.
Performances SNMP	Optimisé pour le polling à grande échelle (bulk requests).	Dépend totalement de Prometheus/Telegraf, pas optimisé nativement pour SNMP.

3) Installation & maintenance

Zabbix

Installation plus complexe
Paramétrage parfois lourd mais complet
Solution centralisée

Grafana

Installation simple
Peut tourner en conteneur docker en quelque lignes
Nécessite d'installer la "stack SNMP" complète

Zabbix

01 - Description

Matériels

VM Proxmox

OS : Debian 13

RAM : 4Go

Processeur : 2

Stockage : 50Go

Identifiants

Proxmox

IRS-admin
ieufdL

Debian-Zabbix

root
ieufdl
real name (zabbix)
Z@bB/*

Asterisck

Debian-Asterisck
asterisck
stjolorient

Zabbix

02 - Installation Zabbix

Source :

https://www.libra-linux.com/blog/15-supervision-avec-zabbix-7-0-lts-sur-debian-ubuntu

1) Installation du serveur Zabbix

Prérequis

OS : Debian 12
2 Go de RAM , 1 CPU
Accès root / sudo

Ajout du dépôt Zabbix

Pour Debian 12

wget https://repo.zabbix.com/zabbix/7.0/debian/pool/main/z/zabbix-release/zabbix-release_7.0-1+debian12_all.deb
sudo dpkg -i zabbix-release_7.0-1+debian12_all.deb
sudo apt update

Pour Ubuntu 22.04

wget https://repo.zabbix.com/zabbix/7.0/ubuntu/pool/main/z/zabbix-release/zabbix-release_7.0-1+ubuntu22.04_all.deb
sudo dpkg -i zabbix-release_7.0-1+ubuntu22.04_all.deb
sudo apt update

Installer le serveur Zabbix + frontend + BDD

sudo apt install zabbix-server-mysql zabbix-frontend-php zabbix-apache-conf \
zabbix-sql-scripts zabbix-agent mariadb-server

Configurer MariaDB

sudo mysql_secure_installation

Puis :

CREATE DATABASE zabbix CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;
CREATE USER zabbix@localhost IDENTIFIED BY 'ieufdl';
GRANT ALL PRIVILEGES ON zabbix.* TO zabbix@localhost;
FLUSH PRIVILEGES;

Importer le schéma :

zcat /usr/share/zabbix-sql-scripts/mysql/server.sql.gz | mysql -uzabbix -p zabbix

Configurer Zabbix

Fichier /etc/zabbix/zabbix_server.conf :

DBPassword=ieufdl

Ne pas oubliez de démarrer le service :)

sudo systemctl restart zabbix-server zabbix-agent apache2
sudo systemctl enable zabbix-server zabbix-agent apache2

Accéder à l’interface web

Accéder à : http://<IP_serveur>/zabbix

Identifiants initiaux :

Mot de passe : zabbix

Zabbix

03 - Configuration

1) Configuration

Langue

Une fois sur l'interface web, la configuration de Zabbix commence. Vous commencerez par simplement choisir votre langue.

Vérification des Prérequis

A cette étape, vous n'aurez besoin que de vérifié que tous les prérequis sont bien "OK".

Configuration de la connexion à la BDD

A cette étapes, vous devrez remplir les différentes informations pour que la connexion entre Zabbix et la base de données se déroule correctement.

Pensé a bien noté ces identifiant dans un gestionnaire de mot de passe !!!

Paramétrage

Ici vous n'aurez cas remplir le nom de votre serveur, son fuseau horaire par defaut (pourras être changé plus tard) et si vous le souhaitez un thème.

Résumé

Pour finir, vous aurez un résumé de pré-installation, n'hésitez pas à stocker les informations qui pourraient être utilisées plus tard.

Connexion

Une fois ces étapes réalisées, vous aurez accès à l'interface web de Zabbix.

Identifiant par défaut :