# Informatique
Guide et documentations liés à l'informatique
# Devops
Un mélange parfait entre Développement et Administration Système
# DOCKER : Commandes basiques Docker
## Obtenir les informations de versions de Docker
Vérification de la version de docker
```bash
docker version
```
Vérification de la version de docker compose
```bash
docker-compose version
```
Obtenir les informations plus globale de Docker
```bash
docker info
```
## Utilisation d'un conteneur
### Bibliothèque de conteneur
Le moyen le plus courant pour obtenir des images est avec le [Docker Hub](https://hub.docker.com/)
Une fois l'image choisie, il faut le nom de l'image et la version que l'on souhaite télécharger :
[](https://astuxio.com/uploads/images/gallery/2026-04/ygs9h8kNoq7FYmEa-image.png)
Le titre permet d'indiquer le nom de l'image et potentiellement d'autres informations (Image officielle, nombre de téléchargements, nombre de favoris).
Les Tags indiquent l'ensemble des versions disponible au téléchargements.
Sur cette page nginx nous indique les dernières versions disponibles.
### Téléchargement d'une image
Pour terminer a droite on retrouve la commande pour télécharger une image :
```
docker pull NOM_IMAGE_VERSION
```
### Lancement d'un conteneur
Lancer un conteneur basique, ici depuis l'image nginx avec le port 80.
Le --publish permet de mettre en relation le port du conteneur avec le port de la machine hôte.
```bash
docker container run --publish 80:80 nginx
```
Ou plus simplement
```
docker container run -p 80:80 nginx
```
Lancer un conteneur mais en arrière plan dans cette configuration il aura un nom aléatoire
```
docker container run --detach --publish 80:80 nginx
```
Le --detach s'écrit aussi -d
```
docker container run -d -p 80:80 nginx
```
Le --name permet de choisir le nom du conteneur qui sera crée
```
docker container run --detach --name nginx_web --publish 80:80 nginx
```
De la même manière que les commandes précédentes il est possible de simplifier l'argument
```
docker container run -d --name nginx_web -p 80:80 nginx
```
Dans le cas d'une petite infrastructure renommer les conteneur n'est pas obligatoire mais on peut vite s'y perdre.
### Affichage des conteneurs
Il est possible d'afficher l'ensemble des conteneurs qui ont été crées mais pas encore supprimés.
```
docker container ls -a
```
Pour afficher les conteneurs actifs sur la machine hôte c'est avec la commande suivante
```
docker ps
```
### Stopper un conteneur
Pour stopper un conteneur il faut son nom ou son ID
```
docker container stop 'NOM/ID'
```
Idem avec
```
docker stop 'NOM/ID'
```
### Supprimer un conteneur
Pour supprimer le ou les conteneur qui sont arrêtés mais toujours présent en fonds
Il est possible d'en supprimer plusieurs en ajoutant tous les noms a la suite les un des autres.
```
docker container rm 'NOM/ID'
```
Idem avec
```
docker rm 'NOM/ID'
```
Il n'est normalement pas possible de supprimer un conteneur en cours d'exécution sauf en le forçant avec l'ajout suivant
```
docker rm -f 'NOM/ID'
```
### Affichage de logs
Pour regarder les logs
```
docker container logs 'NOM/ID'
```
Idem avec
```
docker logs 'NOM/ID'
```
### Afficher les processus
Voir les processus en cours dans un container docker
```
docker container top 'NOM/ID'
```
Idem avec
```
docker top 'NOM/ID'
```
### Informations sur les conteneur
La commande inspect permet d'obtenir un grand nombre d'informations sur la configuration et le fonctionnement du conteneur.
```
docker container inspect 'NOM/ID'
```
Idem avec
```
docker inspect 'NOM/ID'
```
Il est possible de formater le résultats pour n'avoir que certains résultats.
En modifiant la valeur entre crochet pour correspondre a la recherche souhaitée.
```
docker container inspect --format '{{.NetworkSettings.IPAddress}}' 'NOM/ID'
```
Il faudra faire attention a suivre le cheminement que l'on peut retrouver dans la commande inspect. Autre par exemple State.Status
[](https://wikinul.com/books/devops/page/utilisation-container/edit?content-id=bkmrk-&content-text= "Aller à la section dans l'éditeur")
[](https://wikinul.com/uploads/images/gallery/2024-07/Q4Y6kTTDOSvJu4U5-image.png)
### Utilisation des ressources d'un conteneur
La commande stats permet d'afficher les informations d'utilisation des ressources d'un conteneur.
```
docker container stats 'NOM/ID'
```
Idem avec
```
docker stats 'NOM/ID'
```
### Intervenir dans un conteneur
#### Lancer un conteneur et intervenir a l'intérieur
Pour lancer un conteneur la commande sera identique mais il y aura quelques options en plus pour accéder a un terminal
```
docker container run -it --name webserver -p 80:80 nginx bash
```
-t permet de simuler un terminal
-i permet de de garder le terminal ouvert et recevoir l'output des commandes
bash correspond a la commande qui est lancée au lancement du terminal, il permet de créer un terminal
On entre directement dans la console du conteneur
pour quitter le container il faut entrer `exit` mais cette commande éteint aussi le container
La raison pour laquelle le container s'éteint c'est que la commande pour faire fonctionner le container a été définit avec bash donc si l'on met fin au bash on met fin au conteneur par contre si on execute une autre commande puis avec la syntaxe ci-dessous que l'on execute une commande bash supplémentaire le conteneur restera allumé.
#### Lancer une commande dans un conteneur
Pour lancer une commande dans un conteneur qui tourne déja
```
docker container exec -it 'NOM/ID' 'commande'
```
ou
```
docker exec -it 'NOM/ID' 'commande'
```
la commande pour accéder a un terminal reste bash :
```
docker exec -it 'NOM/ID' bash
```
## Etapes de création d'un conteneur
Dans un premier temps docker regarde sur son cache local si l'image est déja présente si elle ne l'est pas il la télécharge depuis DockerHub ou un autre repository s'il est configuré, comme exemple de repository personnalisé on peut citer [Harbor](https://goharbor.io/).
Il téléchargera forcément la dernière version (:latest) de l'image si aucune version ne lui est précisé.
Il crée ensuite un conteneur basé sur l'image indiquée dans la commande.
Il attribue ensuite une IP virtuelle au container sur le réseau privé interne au serveur docker.
Avec l'option --publish il va ouvrir le port définit et le rediriger vers le port définit du conteneur.
Il va ensuite démarrer le conteneur avec la commande (CMD), qui est définit dans le Dockerfile lors de la création de l'image (normalement a la fin).
## Exemple d'utilisation
La commande suivante permet de créer un conteneur avec l'application de base de donnée MySQL, le lancement du conteneur est simple et rapide mais le mot de passe 'root' sera généré aléatoirement.
```
docker container run -d --name sqlserv --env MYSQL_RANDOM_ROOT_PASSWORD=yes -p 3306:3306 mysql
```
Pour récupérer le mot de passe c'est plutôt simple il est noté de façon claire dans les logs du conteneur.
```
[Note] [Entrypoint]: GENERATED ROOT PASSWORD: 7Lh6eUrE7cRKJDQVPjEEodtEeSNNF3Hh
```
[](https://wikinul.com/books/devops/page/utilisation-container/edit?content-id=bkmrk--2&content-text= "Aller à la section dans l'éditeur")
Il est important de le conserver et de supprimer cette ligne des logs.
# Système
Tout ce qui est en rapport avec le système de près ou de loin
# GUIDE : Linux mise en place d'un RAID Logiciel
## Prérequis
### Configuration
Création d'un RAID depuis une VM Ubuntu
Il y a 2 disque de 1 Go qui ont été ajouté /dev/sdb et /dev/sdc
[](https://wikinul.com/uploads/images/gallery/2024-02/stsbanIfBp2ycZaC-image.png)
Installer **mdadm**
```
apt-get install mdadm
```
Vérification des disques avec "lsblk, fdisk, df-h, et gparted"
Avec le module mdadm la commande suivante ajoute un RAID 1
/dev/sd**b** et /dev/sd**c** sont a modifier en fonction de la configuration.
```
mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sdb /dev/sdc
```
Obtenir les détails du disque
```
mdadm --detail /dev/md0
```
Scan des devices
```
mdadm --detail --scan
```
Le définir
```
mdadm --detail --scan | sudo tee -a /etc/mdadm/mdadm.conf
```
Mettre a jour
```
sudo update-initramfs -u
```
Ajouter des disques au RAID 1 (hors TP)
```
sudo mdadm /dev/md0 --add-spare /dev/sdd /dev/sde
```
```
mdadm --manage /dev/md0 --add /dev/sdd
```
### Transformer le RAID 1 en RAID 5
```
sudo mdadm --grow /dev/md0 --level=5
```
Ajouter les disques au RAID 5
```
mdadm --grow /dev/md0 --add --raid-devices=4 /dev/sdd /dev/sde
```
### Formater un Filesystem
Vérifier que LVM2 soit installé
```
apt install lvm2
```
Création du Volume Physique
```
pvcreate /dev/md0
```
Lister les volumes physiques et détail d'un volume
```
pvs
```
```
pvdisplay v2
```
Lister les groupes de volumes et détails d'un volume
```
vgs
```
```
vgdisplay v1
```
Création du Groupe de volume
```
vgcreate nom_volume_groupe /dev/md0
```
Création de 2 volumes logiques sur md0
```
lvcreate -n nom_volume_logique -L 1G nom_volume_groupe
```
Formater les volumes logiques dans 2 formats différents ext4 et XFS
```
mkfs.ext4 /dev/nom_volume_groupe/nom_volume_logique1
```
```
mkfs.xfs /dev/nom_volume_groupe/nom_volume_logique2
```
Si absence de XFS : apt install xfsprogs
Vérifier la configuration des volumes logiques
```
lsblk -f /dev/nom_volume_groupe/nom_volume_logique1
```
```
lsblk -f /dev/nom_volume_groupe/nom_volume_logique2
```
Monter le volume pour qu'il soit utilisable
```
mkdir chemin_a_créer (/srv/data1)
```
```
mount /dev/nom_volume_groupe/nom_volume_logique2 chemin_a_créer
```
### Redimensionner un disque déjà partitionné
Par exemple on a un disque /dev/sda qui contient 2 partition l'objectif est d'agrandir la taille du 2ème disque donc /dev/sda2
- /dev/sda1
- /dev/sda2
Pour cela il faut agrandir le disque dans VMware avec la taille souhaitée
Il faut ensuite effectuer
```
fdisk /dev/sda
```
Vérifier que la place supplémentaire a bien été ajoutée
```
F
```
Il devrait indiquer l'espace restant attaché au disque.
Supprimer une partition donc
```
d
```
puis indiquer le n° de la partition ici 2 sda**2**
```
Numéro de partition (1,2, 2 par défaut) : 2
```
Il faut ensuite recréer une partition
```
n
```
Bien faire attention au type de partition ici la partition que nous allons modifier est la partition principale de la machine donc primaire.
Indiquer le n° de partition qu'il devra avoir, ici le même numéro :
```
Numéro de partition (2-4, 2 par défaut) : 2
```
Laisser le premier secteur par défaut
```
Premier secteur (1026048-251658239, 1026048 par défaut) :
```
Pour le dernier secteur si le choix est laissé par défaut il occupera tout l'espace, sinon il est possible d'ajouter une taille souhaitée +100G par exemple (+taille{K,M,G,T,P}) (Kilo, Mega, Giga, Tera, Peta)
S'il indique que la partition contient une signature surtout ne pas la supprimer
Puis valider le partitionnement avec
```
w
```
Pour que les volumes soient mis a jour il y a une commande a passer
Pour un disque précis
```
echo 1 > /sys/block/sda/device/rescan
```
Pour plusieurs disques
```
ls /sys/class/scsi_disk/ | while read disk ; do echo 1 > /sys/class/scsi_disk/$disk/device/rescan ; done
```
```
fdisk -l
/dev/sda2 1026048 251658239 250632192 119,5G
```
### Agrandir un volume logique
Si l'étape précédente (Redimensionnement d'un volume physique à été correctement réalisé, en agrandissant le disque qui contient ce volume logique, il est très simple d'augmenter la taille d'un des volumes logiques.
Il faut cependant connaitre le nom du volume physique et la taille que l'on souhaite ajouter, ici 100 Go et il s'appelle vg
```
lvresize --resizefs --size +100G /dev/mapper/vg
```
Pour vérifier, il suffit de lancer un df-h, et voici le résultat le volume faisait 5Go et il a augmenté a 105 Go
```
Sys. de fichiers Taille Utilisé Dispo Uti% Monté sur
/dev/mapper/vg 105G 788M 105G 1% /home
```
```
pvresize nom du volume
```
#### Ajouter plusieurs disque dans un volume logique
Ajoute le disque physique dans le volume choisi
```
vgextend nom_du_volume /dev/sdx
```
### Réduire un volume logique
Pour réduire un volume logique, ce n'est pas beaucoup plus compliqué
```
lvreduce -L 50G -v /dev/mapper/vg
```
### Vérification de l'intégrité des disques
#### Smartmontools
Installation de smartmontools
```
apt install smartmontools
```
Vérifier la configuration de smart
```
less/etc/smartd.conf
```
Vérifier l'intégrité des disques
```
smartctl -t short /dev/disque
smartctl -H /dev/disque
```
#### Hdparm
Installation de HDParm
```
apt install hdparm
```
vérification de la capacité d'écriture des disques
```
hdparm -Tt /dev/mapper/disque
```
## Mise en situation
Client ébéniste
Fait lui même sa compta, ses devis, factures (sur un pc), il gère lui-même ses clients volume environ 50Go/an.
Chaque plan fait environ 1Go et il produit environ pour 1To de plans par mois.
Il veut simplifier son système en ayant:
- 2 machines numériques acceptant les plans numériques (autocad, sketchup) pour tournage (tour a bois)
- Une possibilité de faire valider les plans mis en production
- Un suivi de ses employés
Proposez une solution (stockage + backup)
### Solution
NAS + DD Externe + Sauvegarde (avec maintenance comprise)
#### Comparatif
1) NAS
- Placement physique
- MAINTENANCE intégré /mois
- BACKUP Integré
2\) Cloud
- Dépendant de la connexion (temps de sauvegarde + remontage backup)
- localisation (RGPD)
3\) Nextcloud + serveur
- Infrastructure trop couteuse et trop complexe a mettre en place
## Sources
[https://tekatux.fr](https://tekatux.fr)
[https://www.linuxtricks.fr/wiki/mdadm-raid-logiciel-sous-linux](https://www.linuxtricks.fr/wiki/mdadm-raid-logiciel-sous-linux)
cmatrix (apt install cmatrix)
# GUIDE : Windows modifier l'adresse IP d'une carte réseau
L'objectif de ce guide est de montrer comment modifier une adresse IP sur une carte réseau.
Que ce soit depuis une carte réseau physique, ou logique, depuis une machine virtuelle ou physique la démarche est identique.
[](https://astuxio.com/uploads/images/gallery/2026-05/r9jtG9ZBMMas9YFf-image-2.png)
Dans notre cas ce sera la modification d'une IP sur une carte physique.
Précision pour une carte physique
Si l’on est pas sur de la carte correspondant a la carte physique qui est branchée à l’appareil à configurer, désactiver les cartes jusqu’à ce que les LED’s de connexion au port de l’appareil s’éteigne, la carte physique sera sur la dernière carte désactivée.