Procédure

1. Créez un nouveau fichier playbook.yml avec le contenu suivant :

   ---
   - name: Configure the storage
     hosts: managed-node-01.example.com
     tasks:
     - name: Create a RAID on sdd, sde, sdf, and sdg
       include_role:
         name: rhel-system-roles.storage
       vars:
       storage_safe_mode: false
       storage_volumes:
         - name: data
           type: raid
           disks: [sdd, sde, sdf, sdg]
           raid_level: raid0
           raid_chunk_size: 32 KiB
           mount_point: /mnt/data
           state: present

   Avertissement

   Les noms de périphériques peuvent changer dans certaines circonstances, par exemple lorsque vous ajoutez un nouveau disque à un système. Par conséquent, pour éviter toute perte de données, n'utilisez pas de noms de disques spécifiques dans le guide de lecture.

2. Facultatif : Vérifiez la syntaxe du playbook :

   # ansible-playbook --syntax-check playbook.yml

3. Exécutez le manuel de jeu :

   # ansible-playbook -i inventory.file /path/to/file/playbook.yml

Procédure

1. Créez un nouveau fichier playbook.yml avec le contenu suivant :

   - hosts: all
     vars:
       storage_safe_mode: false
       storage_pools:
         - name: my_pool
           type: lvm
           disks: [sdh, sdi]
           raid_level: raid1
           volumes:
             - name: my_pool
               size: "1 GiB"
               mount_point: "/mnt/app/shared"
               fs_type: xfs
               state: present
     roles:
       - name: rhel-system-roles.storage

   Note

   Pour créer un pool LVM avec RAID, vous devez spécifier le type de RAID à l'aide du paramètre raid_level.

2. Facultatif. Vérifier la syntaxe du playbook.

   # ansible-playbook --syntax-check playbook.yml

3. Exécutez le playbook sur votre fichier d'inventaire :

   # ansible-playbook -i inventory.file /path/to/file/playbook.yml

Procédure

1. Créez un nouveau fichier playbook.yml avec le contenu suivant :

   - hosts: all
     vars:
       storage_volumes:
         - name: barefs
           type: disk
           disks:
            - sdb
           fs_type: xfs
           fs_label: label-name
           mount_point: /mnt/data
           encryption: true
           encryption_password: your-password
     roles:
      - rhel-system-roles.storage

   Vous pouvez également ajouter les autres paramètres de cryptage tels que encryption_key, encryption_cipher, encryption_key_size, et encryption_luks version dans le fichier playbook.yml.

2. Facultatif : Vérifier la syntaxe du playbook :

   # ansible-playbook --syntax-check playbook.yml

3. Exécutez le playbook sur votre fichier d'inventaire :

   # ansible-playbook -i inventory.file /path/to/file/playbook.yml

Vérification

1. Visualiser l'état du cryptage :

   # cryptsetup status sdb
   
   /dev/mapper/sdb is active and is in use.
   type: LUKS2
   cipher: aes-xts-plain64
   keysize: 512 bits
   key location: keyring
   device: /dev/sdb
   [...]

2. Vérifiez le volume crypté LUKS créé :

   # cryptsetup luksDump /dev/sdb
   
   Version:       	2
   Epoch:         	6
   Metadata area: 	16384 [bytes]
   Keyslots area: 	33521664 [bytes]
   UUID:          	a4c6be82-7347-4a91-a8ad-9479b72c9426
   Label:         	(no label)
   Subsystem:     	(no subsystem)
   Flags:       	allow-discards
   
   Data segments:
     0: crypt
   	offset: 33554432 [bytes]
   	length: (whole device)
   	cipher: aes-xts-plain64
   	sector: 4096 [bytes]
   [...]

3. Consultez les paramètres cryptsetup dans le fichier playbook.yml que le rôle storage prend en charge :

   # cat ~/playbook.yml
   
       - hosts: all
         vars:
           storage_volumes:
             - name: foo
               type: disk
               disks:
                - nvme0n1
               fs_type: xfs
               fs_label: label-name
               mount_point: /mnt/data
               encryption: true
               #encryption_password: passwdpasswd
               encryption_key: /home/passwd_key
               encryption_cipher: aes-xts-plain64
               encryption_key_size: 512
               encryption_luks_version: luks2
   
         roles:
          - rhel-system-roles.storage

Procédure

1. Démarrer l'interpréteur de commandes interactif parted:

   # parted block-device

2. Déterminez s'il existe déjà une table de partition sur le périphérique :

   # (parted) print

   Si l'appareil contient déjà des partitions, celles-ci seront supprimées au cours des étapes suivantes.

3. Créez la nouvelle table de partition :

   # (parted) mklabel table-type

   • Remplacez table-type par le type de table de partition prévu :

     • msdos pour MBR
     • gpt pour GPT

   Exemple 4.1. Création d'une table de partition GUID (GPT)

   Pour créer une table GPT sur le disque, utilisez la commande suivante

   # (parted) mklabel gpt

   Les modifications commencent à s'appliquer après l'entrée de cette commande.

4. Affichez la table de partition pour confirmer qu'elle est créée :

   # (parted) print

5. Quitter le shell parted:

   # (parted) quit

Procédure

1. Lancez l'utilitaire parted. Par exemple, la sortie suivante répertorie le périphérique /dev/sda:

   # parted /dev/sda

2. Affichez la table de partition :

   # (parted) print
   
   Model: ATA SAMSUNG MZNLN256 (scsi)
   Disk /dev/sda: 256GB
   Sector size (logical/physical): 512B/512B
   Partition Table: msdos
   Disk Flags:
   
   Number  Start   End     Size    Type      File system  Flags
    1      1049kB  269MB   268MB   primary   xfs          boot
    2      269MB   34.6GB  34.4GB  primary
    3      34.6GB  45.4GB  10.7GB  primary
    4      45.4GB  256GB   211GB   extended
    5      45.4GB  256GB   211GB   logical

3. Facultatif : Passez à l'appareil que vous souhaitez examiner ensuite :

   # (parted) select block-device

Procédure

1. Lancez l'utilitaire parted:

   # parted block-device

2. Affichez la table de partition actuelle pour déterminer s'il y a suffisamment d'espace libre :

   # (parted) print

   • Redimensionnez la partition si l'espace libre est insuffisant.

   • À partir de la table de partition, déterminez

     • Les points de départ et d'arrivée de la nouvelle partition.
     • Dans le cas du MBR, quel type de partition doit être utilisé.

3. Créez la nouvelle partition :

   # (parted) mkpart part-type name fs-type start end

   • Remplacez part-type par primary, logical ou extended. Cela ne s'applique qu'à la table de partition MBR.
   • Remplacez name par un nom de partition arbitraire. Cela est nécessaire pour les tables de partition GPT.
   • Remplacez fs-type par xfs, ext2, ext3, ext4, fat16, fat32, hfs, hfs , linux-swap, ntfs, ou reiserfs. Le paramètre fs-type est facultatif. Notez que l'utilitaire parted ne crée pas le système de fichiers sur la partition.
   • Remplacez start et end par les tailles qui déterminent les points de départ et d'arrivée de la partition, en comptant à partir du début du disque. Vous pouvez utiliser des suffixes de taille, tels que 512MiB, 20GiB, ou 1.5TiB. La taille par défaut est en mégaoctets.

   Exemple 4.2. Création d'une petite partition primaire

   Pour créer une partition primaire de 1024MiB à 2048MiB sur une table MBR, utilisez :

   # (parted) mkpart primary 1024MiB 2048MiB

   Les modifications commencent à s'appliquer après la saisie de la commande.

4. Affichez la table de partition pour confirmer que la partition créée se trouve dans la table de partition avec le type de partition, le type de système de fichiers et la taille corrects :

   # (parted) print

5. Quitter le shell parted:

   # (parted) quit

6. Enregistrer le nouveau nœud de l'appareil :

   # udevadm settle

7. Vérifiez que le noyau reconnaît la nouvelle partition :

   # cat /proc/partitions

Procédure

1. Démarrer l'interpréteur de commandes interactif fdisk:

   # fdisk block-device

2. Affichez la table de partition actuelle pour déterminer le numéro de la partition mineure :

   Commande (m pour l'aide) : print

   Vous pouvez voir le type de partition actuel dans la colonne Type et son ID de type correspondant dans la colonne Id.

3. Entrez la commande de type de partition et sélectionnez une partition à l'aide de son numéro mineur :

   Command (m for help): type
   Partition number (1,2,3 default 3): 2

4. Facultatif : Afficher la liste en codes hexadécimaux :

   Code hexagonal (tapez L pour obtenir la liste de tous les codes) : L

5. Définir le type de partition :

   Code hexagonal (tapez L pour obtenir la liste de tous les codes) : 8e

6. Écrivez vos modifications et quittez le shell fdisk:

   Command (m for help): write
   The partition table has been altered.
   Syncing disks.

7. Vérifiez vos modifications :

   # fdisk --list block-device

Procédure

1. Lancez l'utilitaire parted:

   # parted block-device

2. Afficher la table de partition actuelle :

   # (parted) print

   À partir de la table de partition, déterminez

   • Le numéro mineur de la partition.
   • L'emplacement de la partition existante et son nouveau point d'arrivée après le redimensionnement.

3. Redimensionner la partition :

   # (parted) resizepart 1 2GiB

   • Remplacez 1 par le numéro mineur de la partition que vous redimensionnez.
   • Remplacez 2 par la taille qui détermine le nouveau point final de la partition redimensionnée, en comptant à partir du début du disque. Vous pouvez utiliser des suffixes de taille, tels que 512MiB, 20GiB, ou 1.5TiB. La taille par défaut est en mégaoctets.

4. Affichez la table de partition pour confirmer que la partition redimensionnée se trouve dans la table de partition avec la taille correcte :

   # (parted) print

5. Quitter le shell parted:

   # (parted) quit

6. Vérifiez que le noyau enregistre la nouvelle partition :

   # cat /proc/partitions

7. Facultatif : si vous avez étendu la partition, étendez également le système de fichiers qu'elle contient.

Procédure

1. Démarrer l'interpréteur de commandes interactif parted:

   # parted block-device

   • Remplacez block-device par le chemin d'accès au périphérique sur lequel vous souhaitez supprimer une partition : par exemple, /dev/sda.

2. Affichez la table de partition actuelle pour déterminer le numéro mineur de la partition à supprimer :

   (parted) print

3. Retirer la partition :

   (paré) rm minor-number

   • Remplacez minor-number par le numéro mineur de la partition que vous souhaitez supprimer.

   Les modifications commencent à s'appliquer dès que vous entrez cette commande.

4. Vérifiez que vous avez supprimé la partition de la table de partition :

   (parted) print

5. Quitter le shell parted:

   (parted) quit

6. Vérifiez que le noyau enregistre la suppression de la partition :

   # cat /proc/partitions

7. Supprimez la partition du fichier /etc/fstab, si elle est présente. Trouvez la ligne qui déclare la partition supprimée et supprimez-la du fichier.

8. Régénérez les unités de montage pour que votre système enregistre la nouvelle configuration /etc/fstab:

   # systemctl daemon-reload

9. Si vous avez supprimé une partition d'échange ou des éléments de LVM, supprimez toutes les références à la partition dans la ligne de commande du noyau :

   1. Liste les options actives du noyau et vérifie si l'une d'entre elles fait référence à la partition supprimée :

      # grubby --info=ALL

   2. Supprime les options du noyau qui font référence à la partition supprimée :

      # grubby --update-kernel=ALL --remove-args="option"

10. Pour enregistrer les changements dans le système de démarrage anticipé, reconstruisez le système de fichiers initramfs:

    # dracut --force --verbose

Procédure

1. Installer l'outil targetcli:

   # dnf install targetcli

2. Démarrer le service cible :

   # systemctl start target

3. Configurer la cible pour qu'elle démarre au moment du démarrage :

   # systemctl enable target

4. Ouvrez le port 3260 dans le pare-feu et rechargez la configuration du pare-feu :

   # firewall-cmd --permanent --add-port=3260/tcp
   Success
   
   # firewall-cmd --reload
   Success

Procédure

1. Naviguez jusqu'au répertoire iSCSI :

   /> iscsi/

   Note

   La commande cd est utilisée pour changer de répertoire ainsi que pour répertorier le chemin à emprunter.

2. Utilisez l'une des options suivantes pour créer une cible iSCSI :

   1. Création d'une cible iSCSI à l'aide d'un nom de cible par défaut :

      /iscsi> create
      
      Created target
      iqn.2003-01.org.linux-iscsi.hostname.x8664:sn.78b473f296ff
      Created TPG1

   2. Création d'une cible iSCSI à l'aide d'un nom spécifique :

      /iscsi> create iqn.2006-04.com.example:444
      
      Created target iqn.2006-04.com.example:444
      Created TPG1
      Here iqn.2006-04.com.example:444 is target_iqn_name

      Remplacer iqn.2006-04.com.example:444 par le nom spécifique de la cible.

3. Vérifier la cible nouvellement créée :

   /iscsi> ls
   
   o- iscsi.......................................[1 Target]
       o- iqn.2006-04.com.example:444................[1 TPG]
           o- tpg1...........................[enabled, auth]
              o- acls...............................[0 ACL]
               o- luns...............................[0 LUN]
              o- portals.........................[0 Portal]

Procédure

1. Naviguez vers le site fileio/ à partir du répertoire backstores/:

   /> backstores/fileio

2. Créer un objet de stockage fileio:

   /backstores/fileio> create file1 /tmp/disk1.img 200M write_back=false
   
   Created fileio file1 with size 209715200

Procédure

1. Naviguez vers le site block/ à partir du répertoire backstores/:

   /> backstores/block/

2. Créer un backstore block:

   /backstores/block> create name=block_backend dev=/dev/sdb
   
   Generating a wwn serial.
   Created block storage object block_backend using /dev/vdb.

Procédure

1. Naviguez vers le site pscsi/ à partir du répertoire backstores/:

   /> backstores/pscsi/

2. Créez un backstore pscsi pour un périphérique SCSI physique, un périphérique TYPE_ROM utilisant /dev/sr0 dans cet exemple :

   /backstores/pscsi> create name=pscsi_backend dev=/dev/sr0
   
   Generating a wwn serial.
   Created pscsi storage object pscsi_backend using /dev/sr0

Procédure

1. Naviguez vers le site ramdisk/ à partir du répertoire backstores/:

   /> backstores/ramdisk/

2. Créez un disque RAM backstore de 1 Go :

   /backstores/ramdisk> create name=rd_backend size=1GB
   
   Generating a wwn serial.
   Created rd_mcp ramdisk rd_backend with size 1GB.

Procédure

1. Naviguez jusqu'au répertoire TPG :

   /iscsi> iqn.2006-04.example:444/tpg1/

2. Utilisez l'une des options suivantes pour créer un portail iSCSI :

   1. La création d'un portail par défaut utilise le port iSCSI par défaut 3260 et permet à la cible d'écouter toutes les adresses IP sur ce port :

      /iscsi/iqn.20...mple:444/tpg1> portals/ create
      
      Using default IP port 3260
      Binding to INADDR_Any (0.0.0.0)
      Created network portal 0.0.0.0:3260

      Note

      Lorsqu'une cible iSCSI est créée, un portail par défaut est également créé. Ce portail est configuré pour écouter toutes les adresses IP avec le numéro de port par défaut, à savoir : 0.0.0.0:3260.

      Pour supprimer le portail par défaut, utilisez la commande suivante :

      /iscsi/iqn-name/tpg1/portals delete ip_address=0.0.0.0 ip_port=3260

   2. Création d'un portail utilisant une adresse IP spécifique :

      /iscsi/iqn.20...mple:444/tpg1> portals/ create 192.168.122.137
      
      Using default IP port 3260
      Created network portal 192.168.122.137:3260

Procédure

1. Créer des LUN d'objets de stockage déjà créés :

   /iscsi/iqn.20...mple:444/tpg1> luns/ create /backstores/ramdisk/rd_backend
   Created LUN 0.
   
   /iscsi/iqn.20...mple:444/tpg1> luns/ create /backstores/block/block_backend
   Created LUN 1.
   
   /iscsi/iqn.20...mple:444/tpg1> luns/ create /backstores/fileio/file1
   Created LUN 2.

2. Vérifiez les LUN créés :

   /iscsi/iqn.20...mple:444/tpg1> ls
   
   o- tpg.................................. [enambled, auth]
       o- acls ......................................[0 ACL]
       o- luns .....................................[3 LUNs]
       |  o- lun0.........................[ramdisk/ramdisk1]
       |  o- lun1.................[block/block1 (/dev/vdb1)]
       |  o- lun2...................[fileio/file1 (/foo.img)]
       o- portals ................................[1 Portal]
           o- 192.168.122.137:3260......................[OK]

   Le nom du LUN par défaut commence par 0.

   Important

   Par défaut, les LUN sont créés avec des permissions de lecture-écriture. Si un nouveau LUN est ajouté après la création des ACL, le LUN est automatiquement mappé à tous les ACL disponibles, ce qui peut entraîner un risque de sécurité. Pour créer une LUN avec des autorisations en lecture seule, voir Création d'une LUN iSCSI en lecture seule.

3. Configurez les ACL. Pour plus d'informations, voir Création d'une ACL iSCSI.

Procédure

1. Définir les autorisations de lecture seule :

   /> set global auto_add_mapped_luns=false
   
   Parameter auto_add_mapped_luns is now 'false'.

   Cela empêche le mappage automatique des LUN aux ACL existants, ce qui permet le mappage manuel des LUN.

2. Naviguez jusqu'au répertoire initiator_iqn_name:

   /> iscsi/target_iqn_name/tpg1/acls/initiator_iqn_name/

3. Créer le LUN :

   /iscsi/nom_de_la_cible/tpg1/acls/initiator_iqn_name> create mapped_lun=next_sequential_LUN_number tpg_lun_ou_backstore=backstore write_protect=1

   Exemple :

   /iscsi/target_iqn_name/tpg1/acls/2006-04.com.example:888> create mapped_lun=1 tpg_lun_or_backstore=/backstores/block/block2 write_protect=1
   
   Created LUN 1.
   Created Mapped LUN 1.

4. Vérifiez le LUN créé :

   /iscsi/target_iqn_name/tpg1/acls/2006-04.com.example:888> ls
    o- 2006-04.com.example:888 .. [Mapped LUNs: 2]
    | o- mapped_lun0 .............. [lun0 block/disk1 (rw)]
    | o- mapped_lun1 .............. [lun1 block/disk2 (ro)]

   La ligne mapped_lun1 comporte désormais (ro) à la fin (contrairement à la ligne mapped_lun0 (rw)), indiquant qu'elle est en lecture seule.

5. Configurez les ACL. Pour plus d'informations, voir Création d'une ACL iSCSI.

Procédure

1. Facultatif : Pour désactiver le mappage automatique des LUN aux ACL, voir Création d'un LUN iSCSI en lecture seule.

2. Naviguez jusqu'au répertoire acls :

   /> iscsi/target_iqn_name/tpg_name/acls/

3. Utilisez l'une des options suivantes pour créer une liste de contrôle d'accès :

   • Utilisez le initiator_iqn_name du fichier /etc/iscsi/initiatorname.iscsi sur l'initiateur :

     iscsi/target_iqn_name/tpg_name/acls> create initiator_iqn_name
     
     Created Node ACL for initiator_iqn_name
     Created mapped LUN 2.
     Created mapped LUN 1.
     Created mapped LUN 0.

   • Utilisez une adresse custom_name et mettez à jour l'initiateur pour qu'il corresponde à cette adresse :

     iscsi/target_iqn_name/tpg_name/acls> create custom_name
     
     Created Node ACL for custom_name
     Created mapped LUN 2.
     Created mapped LUN 1.
     Created mapped LUN 0.

     Pour plus d'informations sur la mise à jour du nom de l'initiateur, voir Création d'un initiateur iSCSI.

Procédure

1. Définir l'authentification des attributs :

   /iscsi/iqn.20...mple:444/tpg1> set attribute authentication=1
   
   Parameter authentication is now '1'.

2. Set userid et password:

   /tpg1> set auth userid=redhat
   Parameter userid is now 'redhat'.
   
   /iscsi/iqn.20...689dcbb3/tpg1> set auth password=redhat_passwd
   Parameter password is now 'redhat_passwd'.

Procédure

1. Se déconnecter de la cible :

   # iscsiadm -m node -T iqn.2006-04.example:444 -u

   Pour plus d'informations sur la façon de se connecter à la cible, voir Création d'un initiateur iSCSI.

2. Supprimez l'ensemble de la cible, y compris les ACL, les LUN et les portails :

   /> iscsi/ delete iqn.2006-04.com.example:444

   Remplacez iqn.2006-04.com.example:444 par le nom de l'utilisateur cible.

   • Pour supprimer un backstore iSCSI :

     /> backstores/backstore-type/ delete block_backend

     • Remplacez backstore-type par fileio, block, pscsi, ou ramdisk.
     • Remplacez block_backend par le backstore-name que vous souhaitez supprimer.

   • Pour supprimer des parties d'une cible iSCSI, comme une ACL :

     /> /iscsi/nom-iqn/tpg/acls/ delete iqn.2006-04.com.example:444

Procédure

1. Installer iscsi-initiator-utils sur la machine du client :

   # dnf install iscsi-initiator-utils

2. Vérifier le nom de l'initiateur :

   # cat /etc/iscsi/initiatorname.iscsi
   
   InitiatorName=iqn.2006-04.com.example:888

3. Si l'ACL a reçu un nom personnalisé dans Création d'une ACL iSCI, mettez à jour le nom de l'initiateur pour qu'il corresponde à l'ACL :

   1. Ouvrez le fichier /etc/iscsi/initiatorname.iscsi et modifiez le nom de l'initiateur :

      # vi /etc/iscsi/initiatorname.iscsi
      
      InitiatorName=custom-name

   2. Redémarrez le service iscsid:

      # systemctl restart iscsid

4. Découvrez la cible et connectez-vous à la cible avec l'IQN affiché :

   # iscsiadm -m discovery -t st -p 10.64.24.179
       10.64.24.179:3260,1 iqn.2006-04.example:444
   
   # iscsiadm -m node -T iqn.2006-04.example:444 -l
       Logging in to [iface: default, target: iqn.2006-04.example:444, portal: 10.64.24.179,3260] (multiple)
       Login to [iface: default, target: iqn.2006-04.example:444, portal: 10.64.24.179,3260] successful.

   Remplacez 10.64.24.179 par l'adresse IP cible.

   Vous pouvez utiliser cette procédure pour un nombre quelconque d'initiateurs connectés à la même cible si leurs noms d'initiateurs respectifs sont ajoutés à l'ACL comme décrit dans la section Création d'une ACL iSCSI.

5. Recherchez le nom du disque iSCSI et créez un système de fichiers sur ce disque iSCSI :

   # grep "Attached SCSI" /var/log/messages
   
   # mkfs.ext4 /dev/disk_name

   Remplacez disk_name par le nom du disque iSCSI affiché dans le fichier /var/log/messages.

6. Monter le système de fichiers :

   # mkdir /mount/point
   
   # mount /dev/disk_name /mount/point

   Remplacez /mount/point par le point de montage de la partition.

7. Modifiez le fichier /etc/fstab pour monter le système de fichiers automatiquement au démarrage du système :

   # vi /etc/fstab
   
   /dev/disk_name /mount/point ext4 _netdev 0 0

   Remplacez disk_name par le nom du disque iSCSI et /mount/point par le point de montage de la partition.

Procédure

1. Activer l'authentification CHAP dans le fichier iscsid.conf:

   # vi /etc/iscsi/iscsid.conf
   
   node.session.auth.authmethod = CHAP

   Par défaut, le site node.session.auth.authmethod est réglé sur None

2. Ajouter les cibles username et password dans le fichier iscsid.conf:

   node.session.auth.username = redhat
   node.session.auth.password = redhat_passwd

3. Démarrer le démon iscsid:

   # systemctl start iscsid.service

Procédure

1. Installer le site iscsi-initiator-utils sur la machine du client :

   # dnf install iscsi-initiator-utils

2. Trouvez des informations sur les sessions de course à pied :

   # iscsiadm -m session -P 3

   Cette commande affiche l'état de la session ou du périphérique, l'ID de session (sid), certains paramètres négociés et les périphériques SCSI accessibles via la session.

   • Pour obtenir un résultat plus court, par exemple pour afficher uniquement le mappage sid-to-node, exécutez la commande :

     # iscsiadm -m session -P 0
             or
     # iscsiadm -m session
     
     tcp [2] 10.15.84.19:3260,2 iqn.1992-08.com.netapp:sn.33615311
     tcp [3] 10.15.85.19:3260,3 iqn.1992-08.com.netapp:sn.33615311

     Ces commandes impriment la liste des sessions en cours dans le format suivant : driver [sid] target_ip:port,target_portal_group_tag proper_target_name.

Procédure

1. Déterminer quels périphériques sont des chemins d'accès pour une unité logique multipath:

   multipath -ll

2. Re-scanner les unités logiques Fibre Channel sur un système qui utilise le multipathing :

   $ echo 1 > /sys/block/sdX/device/rescan

Procédure

1. Créez un instantané de votre volume logique root:

   • Si votre système de fichiers racine utilise le provisionnement fin, créez un instantané fin :

     # lvcreate -s rhel/root -kn -n root_snapshot_before_changes

     Ici :

     • -s crée l'instantané.
     • rhel/root copie le système de fichiers sur le volume logique.

     • -n root_snapshot_before_changes indique le nom de l'instantané.

       Lors de la création d'un instantané fin, ne définissez pas la taille de l'instantané. L'instantané est alloué à partir du thin pool.

   • Si votre système de fichiers racine utilise le provisionnement épais, créez un instantané épais :

     # lvcreate -s  rhel/root -n root_snapshot_before_changes -L 25g

     Ici :

     • -s crée l'instantané.
     • rhel/root copie le système de fichiers sur le volume logique.
     • -n root_snapshot_before_changes indique le nom de l'instantané.

     • -L 25g est la taille de l'instantané. Faites une estimation de la taille en vous basant sur la taille de l'installation d'origine.

       Lors de la création d'un instantané épais, définissez la taille de l'instantané qui peut contenir toutes les modifications pendant la mise à niveau.

       Important

       L'instantané créé n'inclut aucune modification supplémentaire du système.

2. Créer le profil :

   # boom profile create --from-host --uname-pattern el9

3. Créer une entrée de démarrage instantanée du système d'origine à l'aide de copies de sauvegarde des images de démarrage d'origine :

   # boom create --backup --title "Root LV snapshot before changes" --rootlv rhel/root_snapshot_before_changes

   Ici :

   • --titleRoot LV snapshot before changes est le nom de l'entrée d'amorçage qui apparaît dans la liste des entrées d'amorçage lors du démarrage du système.
   • --rootlv est le volume logique racine qui correspond à la nouvelle entrée de démarrage.
   • Après avoir effectué l'étape précédente, vous disposez d'une entrée de démarrage qui permet d'accéder au système d'origine, avant la mise à niveau.

4. Mettez à niveau vers Red Hat Enterprise Linux 9 à l'aide de l'utilitaire Leapp :

   # leapp upgrade

   • Examiner et résoudre les éventuels blocages indiqués dans le rapport de commandement leapp upgrade.

5. Redémarrez avec l'entrée de démarrage mise à jour :

   # leapp upgrade --reboot

   • Sélectionnez l'entrée Red Hat Enterprise Linux Upgrade Initramfs dans l'écran de démarrage de GRUB.

   • L'utilitaire leapp crée l'entrée de démarrage de la mise à niveau. Exécutez la commande mentionnée ci-dessus pour redémarrer dans l'entrée de démarrage de mise à niveau, et procédez à l'exécution de la mise à niveau en place vers Red Hat Enterprise Linux 9. Après le processus de mise à niveau, l'argument reboot (redémarrer) initie un redémarrage automatique du système. L'écran GRUB s'affiche pendant le redémarrage.

     Note

     Le sous-menu Snapshots de l'écran de démarrage GRUB n'est pas disponible dans Red Hat Enterprise Linux 9.

Procédure

1. Redémarrer le système :

   # reboot

2. Sélectionnez l'entrée de démarrage requise dans l'écran du chargeur de démarrage GRUB.

Procédure

1. Démarrez Red Hat Enterprise Linux 9 à partir de l'entrée GRUB. La sortie suivante confirme que le nouvel instantané est sélectionné :

   # boom list
   BootID    Version                  Name                             RootDevice
   6d2ec72 3.10.0-957.21.3.el8.x86_64 Red Hat Enterprise Linux Server /dev/rhel/root_snapshot_before_changes

2. Supprimer l'entrée de l'instantané à l'aide de la valeur BootID:

   # boom delete --boot-id 6d2ec72

   • Cette opération supprime l'entrée de démarrage du menu GRUB.

3. Supprimer l'instantané LV :

   # lvremove rhel/root_snapshot_before_changes
   Do you really want to remove active logical volume rhel/root_snapshot_before_changes? [y/n]: y
         Logical volume "root_snapshot_before_changes" successfully removed

Procédure

1. Fusionner l'instantané avec le volume d'origine (le point d'origine) :

   # lvconvert --merge rhel/root_snapshot_before_changes

   Avertissement

   Après avoir fusionné l'instantané, vous devez poursuivre toutes les étapes restantes de cette procédure afin d'éviter toute perte de données.

2. Créer une entrée de démarrage de retour en arrière pour l'instantané fusionné :

   • Pour boom-0.9:

     boom create --title "RHEL Rollback" --rootlv rhel/root

   • Pour boom-1.2, ou les versions ultérieures :

     boom create --backup --title "RHEL Rollback" --rootlv rhel/root

3. Facultatif : Redémarrez votre machine pour rétablir l'état du système d'exploitation :

   # reboot

   • Une fois le système redémarré, sélectionnez l'entrée de démarrage Red Hat Enterprise Linux Rollback dans l'écran GRUB.

   • Une fois que le volume logique root est actif, le système lance automatiquement l'opération de fusion des instantanés.

     Important

     Une fois que l'opération de fusion commence, le volume snapshot n'est plus disponible. Après avoir démarré avec succès l'entrée de démarrage de Red Hat Enterprise Linux Rollback, le site Root LV snapshot boot entry ne fonctionne plus. La fusion du volume logique snapshot détruit le snapshot Root LV et restaure l'état antérieur du volume original.

4. Facultatif : Une fois l'opération de fusion terminée, supprimez les entrées inutilisées et restaurez l'entrée de démarrage d'origine :

   1. Supprimez les entrées de démarrage inutilisées de Red Hat Enterprise Linux 9 du système de fichiers /boot et reconstruisez le fichier grub.cfg pour que les modifications soient prises en compte :

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

   2. Restaurez l'entrée de démarrage originale de Red Hat Enterprise Linux :

      # new-kernel-pkg --update $(uname -r)

5. Après un retour au système réussi, supprimez l'entrée de démarrage boom:

   # boom list
   # boom delete boot-id

Procédure

1. Créer le sous-système nvmet-rdma:

   # modprobe nvmet-rdma
   
   # mkdir /sys/kernel/config/nvmet/subsystems/testnqn
   
   # cd /sys/kernel/config/nvmet/subsystems/testnqn

   Remplacez testnqn par le nom du sous-système.

2. Permet à tout hôte de se connecter à ce contrôleur :

   # echo 1 > attr_allow_any_host

3. Configurer un espace de noms :

   # mkdir namespaces/10
   
   # cd namespaces/10

   Remplacer 10 par le numéro de l'espace de noms

4. Définir un chemin d'accès au périphérique NVMe :

   # echo -n /dev/nvme0n1 > device_path

5. Activer l'espace de noms :

   # echo 1 > enable

6. Créer un répertoire avec un port NVMe :

   # mkdir /sys/kernel/config/nvmet/ports/1
   
   # cd /sys/kernel/config/nvmet/ports/1

7. Affichez l'adresse IP de mlx5_ib0:

   # ip addr show mlx5_ib0
   
   8: mlx5_ib0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 4092 qdisc mq state UP group default qlen 256
       link/infiniband 00:00:06:2f:fe:80:00:00:00:00:00:00:e4:1d:2d:03:00:e7:0f:f6 brd 00:ff:ff:ff:ff:12:40:1b:ff:ff:00:00:00:00:00:00:ff:ff:ff:ff
       inet 172.31.0.202/24 brd 172.31.0.255 scope global noprefixroute mlx5_ib0
          valid_lft forever preferred_lft forever
       inet6 fe80::e61d:2d03:e7:ff6/64 scope link noprefixroute
          valid_lft forever preferred_lft forever

8. Définir l'adresse de transport du contrôleur :

   # echo -n 172.31.0.202 > addr_traddr

9. Définir RDMA comme type de transport :

   # echo rdma > addr_trtype
   
   # echo 4420 > addr_trsvcid

10. Définir la famille d'adresses pour le port :

    # echo ipv4 > addr_adrfam

11. Créer un lien souple :

    # ln -s /sys/kernel/config/nvmet/subsystems/testnqn   /sys/kernel/config/nvmet/ports/1/subsystems/testnqn

Procédure

1. Installez le paquetage nvmetcli:

   # dnf install nvmetcli

2. Téléchargez le fichier rdma.json:

   # wget http://git.infradead.org/users/hch/nvmetcli.git/blob_plain/0a6b088db2dc2e5de11e6f23f1e890e4b54fee64:/rdma.json

3. Modifiez le fichier rdma.json et remplacez la valeur traddr par 172.31.0.202.

4. Configurez le contrôleur en chargeant le fichier de configuration du contrôleur NVMe :

   # nvmetcli restore rdma.json

Procédure

1. Installer l'outil nvme-cli:

   # dnf install nvme-cli

2. Charger le module nvme-rdma s'il n'est pas chargé :

   # modprobe nvme-rdma

3. Découvrez les sous-systèmes disponibles sur le contrôleur NVMe :

   # nvme discover -t rdma -a 172.31.0.202 -s 4420
   
   Discovery Log Number of Records 1, Generation counter 2
   =====Discovery Log Entry 0======
   trtype:  rdma
   adrfam:  ipv4
   subtype: nvme subsystem
   treq:    not specified, sq flow control disable supported
   portid:  1
   trsvcid: 4420
   subnqn:  testnqn
   traddr:  172.31.0.202
   rdma_prtype: not specified
   rdma_qptype: connected
   rdma_cms:    rdma-cm
   rdma_pkey: 0x0000

4. Se connecter aux sous-systèmes découverts :

   # nvme connect -t rdma -n testnqn -a 172.31.0.202 -s 4420
   
   # lsblk
   NAME                         MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
   sda                            8:0    0 465.8G  0 disk
   ├─sda1                         8:1    0     1G  0 part /boot
   └─sda2                         8:2    0 464.8G  0 part
     ├─rhel_rdma--virt--03-root 253:0    0    50G  0 lvm  /
     ├─rhel_rdma--virt--03-swap 253:1    0     4G  0 lvm  [SWAP]
     └─rhel_rdma--virt--03-home 253:2    0 410.8G  0 lvm  /home
   nvme0n1
   
   # cat /sys/class/nvme/nvme0/transport
   rdma

   Remplacez testnqn par le nom du sous-système NVMe.

   Remplacez 172.31.0.202 par l'adresse IP du contrôleur.

   Remplacez 4420 par le numéro de port.

Procédure

1. Installer l'outil nvme-cli:

   # dnf install nvme-cli

   Cette opération crée le fichier hostnqn dans le répertoire /etc/nvme/. Le fichier hostnqn identifie l'hôte NVMe.

2. Trouvez les identifiants WWNN et WWPN des ports locaux et distants et utilisez les résultats pour trouver le NQN du sous-système :

   # cat /sys/class/scsi_host/host*/nvme_info
   
   NVME Host Enabled
   XRI Dist lpfc0 Total 6144 IO 5894 ELS 250
   NVME LPORT lpfc0 WWPN x10000090fae0b5f5 WWNN x20000090fae0b5f5 DID x010f00 ONLINE
   NVME RPORT       WWPN x204700a098cbcac6 WWNN x204600a098cbcac6 DID x01050e TARGET DISCSRVC ONLINE
   
   NVME Statistics
   LS: Xmt 000000000e Cmpl 000000000e Abort 00000000
   LS XMIT: Err 00000000  CMPL: xb 00000000 Err 00000000
   Total FCP Cmpl 00000000000008ea Issue 00000000000008ec OutIO 0000000000000002
       abort 00000000 noxri 00000000 nondlp 00000000 qdepth 00000000 wqerr 00000000 err 00000000
   FCP CMPL: xb 00000000 Err 00000000

   # nvme discover --transport fc \
                   --traddr nn-0x204600a098cbcac6:pn-0x204700a098cbcac6 \
                   --host-traddr nn-0x20000090fae0b5f5:pn-0x10000090fae0b5f5
   
   Discovery Log Number of Records 2, Generation counter 49530
   =====Discovery Log Entry 0======
   trtype:  fc
   adrfam:  fibre-channel
   subtype: nvme subsystem
   treq:    not specified
   portid:  0
   trsvcid: none
   subnqn:  nqn.1992-08.com.netapp:sn.e18bfca87d5e11e98c0800a098cbcac6:subsystem.st14_nvme_ss_1_1
   traddr:  nn-0x204600a098cbcac6:pn-0x204700a098cbcac6

   Remplacer nn-0x204600a098cbcac6:pn-0x204700a098cbcac6 par traddr.

   Remplacer nn-0x20000090fae0b5f5:pn-0x10000090fae0b5f5 par host-traddr.

3. Connectez-vous au contrôleur NVMe à l'aide du site nvme-cli:

   # nvme connect --transport fc \
                  --traddr nn-0x204600a098cbcac6:pn-0x204700a098cbcac6 \
                  --host-traddr nn-0x20000090fae0b5f5:pn-0x10000090fae0b5f5 \
                  -n nqn.1992-08.com.netapp:sn.e18bfca87d5e11e98c0800a098cbcac6:subsystem.st14_nvme_ss_1_1

   Remplacer nn-0x204600a098cbcac6:pn-0x204700a098cbcac6 par traddr.

   Remplacer nn-0x20000090fae0b5f5:pn-0x10000090fae0b5f5 par host-traddr.

   Remplacer nqn.1992-08.com.netapp:sn.e18bfca87d5e11e98c0800a098cbcac6:subsystem.st14_nvme_ss_1_1 par le subnqn.

Procédure

1. Installer l'outil nvme-cli:

   # dnf install nvme-cli

   Cette opération crée le fichier hostnqn dans le répertoire /etc/nvme/. Le fichier hostnqn identifie l'hôte NVMe.

2. Rechargez le module qla2xxx:

   # rmmod qla2xxx
   # modprobe qla2xxx

3. Trouver les identifiants WWNN et WWPN des ports locaux et distants :

   # dmesg |grep traddr
   
   [    6.139862] qla2xxx [0000:04:00.0]-ffff:0: register_localport: host-traddr=nn-0x20000024ff19bb62:pn-0x21000024ff19bb62 on portID:10700
   [    6.241762] qla2xxx [0000:04:00.0]-2102:0: qla_nvme_register_remote: traddr=nn-0x203b00a098cbcac6:pn-0x203d00a098cbcac6 PortID:01050d

   En utilisant ces valeurs host-traddr et traddr, trouvez le sous-système NQN :

   # nvme discover --transport fc \
                   --traddr nn-0x203b00a098cbcac6:pn-0x203d00a098cbcac6 \
                   --host-traddr nn-0x20000024ff19bb62:pn-0x21000024ff19bb62
   
   Discovery Log Number of Records 2, Generation counter 49530
   =====Discovery Log Entry 0======
   trtype:  fc
   adrfam:  fibre-channel
   subtype: nvme subsystem
   treq:    not specified
   portid:  0
   trsvcid: none
   subnqn:  nqn.1992-08.com.netapp:sn.c9ecc9187b1111e98c0800a098cbcac6:subsystem.vs_nvme_multipath_1_subsystem_468
   traddr:  nn-0x203b00a098cbcac6:pn-0x203d00a098cbcac6

   Remplacer nn-0x203b00a098cbcac6:pn-0x203d00a098cbcac6 par traddr.

   Remplacer nn-0x20000024ff19bb62:pn-0x21000024ff19bb62 par host-traddr.

4. Connectez-vous au contrôleur NVMe à l'aide de l'outil nvme-cli:

   # nvme connect  --transport fc \
                   --traddr nn-0x203b00a098cbcac6:pn-0x203d00a098cbcac6 \
                   --host-traddr nn-0x20000024ff19bb62:pn-0x21000024ff19bb62 \
                   -n nqn.1992-08.com.netapp:sn.c9ecc9187b1111e98c0800a098cbcac6:subsystem.vs_nvme_multipath_1_subsystem_468

   Remplacer nn-0x203b00a098cbcac6:pn-0x203d00a098cbcac6 par traddr.

   Remplacer nn-0x20000024ff19bb62:pn-0x21000024ff19bb62 par host-traddr.

   Remplacer nqn.1992-08.com.netapp:sn.c9ecc9187b1111e98c0800a098cbcac6:subsystem.vs_nvme_multipath_1_subsystem_468 par le subnqn.

Procédure

1. Installer l'outil nvme-cli:

   # dnf install nvme-cli

   Cet outil crée le fichier hostnqn dans le répertoire /etc/nvme/, qui identifie l'hôte NVMe.

2. Trouver le nvme hostid et hostnqn:

   # cat /etc/nvme/hostnqn
   nqn.2014-08.org.nvmexpress:uuid:8ae2b12c-3d28-4458-83e3-658e571ed4b8
   
   # cat /etc/nvme/hostid
   09e2ce17-ccc9-412d-8dcf-2b0a1d581ee3

   Utilisez les valeurs hostid et hostnqn pour configurer le contrôleur NVMe/TCP.

3. Vérifier l'état du contrôleur :

   # nmcli device show ens6
   GENERAL.DEVICE:                         ens6
   GENERAL.TYPE:                           ethernet
   GENERAL.HWADDR:                         52:57:02:12:02:02
   GENERAL.MTU:                            1500
   GENERAL.STATE:                          30 (disconnected)
   GENERAL.CONNECTION:                     --
   GENERAL.CON-PATH:                       --
   WIRED-PROPERTIES.CARRIER:               on

4. Configurer le réseau hôte pour un contrôleur Ethernet nouvellement installé avec une adresse IP statique :

   # nmcli connection add con-name ens6 ifname ens6 type ethernet ip4 192.168.101.154/24 gw4 192.168.101.1

   Remplacez ici 192.168.101.154 par l'adresse IP de l'hôte.

   # nmcli connection mod ens6 ipv4.method manual
   # nmcli connection up ens6

   Étant donné qu'un nouveau réseau est créé pour connecter l'hôte NVMe/TCP au contrôleur NVMe/TCP, exécutez également cette étape sur le contrôleur.

Procédure

1. Charger le module nvme_tcp si ce n'est pas déjà fait :

   # modprobe nvme_tcp

2. Découvrez les sous-systèmes disponibles sur le contrôleur NVMe :

   # nvme discover --transport=tcp --traddr=192.168.101.55 --host-traddr=192.168.101.154 --trsvcid=8009
   
   Discovery Log Number of Records 2, Generation counter 7
   =====Discovery Log Entry 0======
   trtype:  tcp
   adrfam:  ipv4
   subtype: current discovery subsystem
   treq:	not specified, sq flow control disable supported
   portid:  2
   trsvcid: 8009
   subnqn:  nqn.2014-08.org.nvmexpress.discovery
   traddr:  192.168.101.55
   eflags:  not specified
   sectype: none
   =====Discovery Log Entry 1======
   trtype:  tcp
   adrfam:  ipv4
   subtype: nvme subsystem
   treq:	not specified, sq flow control disable supported
   portid:  2
   trsvcid: 8009
   subnqn:  nqn.2014-08.org.nvmexpress:uuid:0c468c4d-a385-47e0-8299-6e95051277db
   traddr:  192.168.101.55
   eflags:  not specified
   sectype: none

   Ici, 192.168.101.55 est l'adresse IP du contrôleur NVMe/TCP et 192.168.101.154 est l'adresse IP de l'hôte NVMe/TCP.

3. Configurer le fichier /etc/nvme/discovery.conf pour ajouter les paramètres utilisés dans la commande nvme discover:

   # echo "--transport=tcp --traddr=192.168.101.55 --host-traddr=192.168.101.154 --trsvcid=8009" >> /etc/nvme/discovery.conf

4. Connectez l'hôte NVMe/TCP au système contrôleur :

   # nvme connect-all

Procédure

1. Vérifier si le multipathing NVMe natif est activé :

   # cat /sys/module/nvme_core/parameters/multipath

   La commande affiche l'un des éléments suivants :

   N

   Le multipathing NVMe natif est désactivé.

   Y

   Le multipathing NVMe natif est activé.

2. Si le multipathing NVMe natif est activé, désactivez-le en utilisant l'une des méthodes suivantes :

   • Utilisation d'une option du noyau :

     1. Ajoutez l'option nvme_core.multipath=N à la ligne de commande :

        # grubby --update-kernel=ALL --args="nvme_core.multipath=N"

     2. Sur l'architecture IBM Z 64 bits, mettez à jour le menu de démarrage :

        # zipl

     3. Redémarrer le système.

   • Utilisation d'un fichier de configuration du module du noyau :

     1. Créez le fichier de configuration /etc/modprobe.d/nvme_core.conf avec le contenu suivant :

        options nvme_core multipath=N

     2. Sauvegarder le fichier initramfs:

        # cp /boot/initramfs-$(uname -r).img /boot/initramfs-$(uname r).bak.$(date %m\r%H%M%S).img

     3. Reconstruire le site initramfs:

        # cp /boot/initramfs-$(uname -r).img /boot/initramfs-$(uname -r).bak.$(date +%m-%d-%H%M%S).img
        # dracut --force --verbose

     4. Redémarrer le système.

3. Activer DM Multipath :

   # systemctl enable --now multipathd.service

4. Distribuer les E/S sur tous les chemins disponibles. Ajoutez le contenu suivant dans le fichier /etc/multipath.conf:

   devices {
           device {
                   vendor "NVME"
                   product ".*"
                   path_grouping_policy group_by_prio
           }
   }

   Note

   Le fichier de configuration /sys/class/nvme-subsystem/nvme-subsys0/iopolicy n'a aucun effet sur la distribution des E/S lorsque DM Multipath gère les périphériques NVMe.

5. Rechargez le service multipathd pour appliquer les changements de configuration :

   # multipath -r

Procédure

1. Vérifier si le multipathing NVMe natif est activé dans le noyau :

   # cat /sys/module/nvme_core/parameters/multipath

   La commande affiche l'un des éléments suivants :

   N

   Le multipathing NVMe natif est désactivé.

   Y

   Le multipathing NVMe natif est activé.

2. Si le multipathing NVMe natif est désactivé, activez-le en utilisant l'une des méthodes suivantes :

   • Utilisation d'une option du noyau :

     1. Supprime l'option nvme_core.multipath=N de la ligne de commande du noyau :

        # grubby --update-kernel=ALL --remove-args="nvme_core.multipath=N"

     2. Sur l'architecture IBM Z 64 bits, mettez à jour le menu de démarrage :

        # zipl

     3. Redémarrer le système.

   • Utilisation d'un fichier de configuration du module du noyau :

     1. Supprimez le fichier de configuration /etc/modprobe.d/nvme_core.conf:

        # rm /etc/modprobe.d/nvme_core.conf

     2. Sauvegarder le fichier initramfs:

        # cp /boot/initramfs-$(uname -r).img /boot/initramfs-$(uname -r).bak.$(date %m-\r%H%M%S).img

     3. Reconstruire le site initramfs:

        # dracut --force --verbose

     4. Redémarrer le système.

3. Facultatif : Sur le système en cours d'exécution, modifiez la stratégie d'E/S sur les périphériques NVMe afin de répartir les E/S sur tous les chemins disponibles :

   # echo "round-robin" > /sys/class/nvme-subsystem/nvme-subsys0/iopolicy

4. Facultatif : Définissez la politique d'E/S de manière persistante à l'aide des règles udev. Créez le fichier /etc/udev/rules.d/71-nvme-io-policy.rules avec le contenu suivant :

   ACTION=="add|change", SUBSYSTEM=="nvme-subsystem", ATTR{iopolicy}="round-robin"

Vérification

1. Vérifiez que votre système reconnaît les périphériques NVMe. L'exemple suivant suppose que vous avez un sous-système de stockage NVMe over fabrics connecté avec deux espaces de noms NVMe :

   # nvme list
   
   Node             SN                   Model                                    Namespace Usage                      Format           FW Rev
   ---------------- -------------------- ---------------------------------------- --------- -------------------------- ---------------- --------
   /dev/nvme0n1     a34c4f3a0d6f5cec     Linux                                    1         250.06  GB / 250.06  GB    512   B +  0 B   4.18.0-2
   /dev/nvme0n2     a34c4f3a0d6f5cec     Linux                                    2         250.06  GB / 250.06  GB    512   B +  0 B   4.18.0-2

2. Liste de tous les sous-systèmes NVMe connectés :

   # nvme list-subsys
   
   nvme-subsys0 - NQN=testnqn
   \
    +- nvme0 fc traddr=nn-0x20000090fadd597a:pn-0x10000090fadd597a host_traddr=nn-0x20000090fac7e1dd:pn-0x10000090fac7e1dd live
    +- nvme1 fc traddr=nn-0x20000090fadd5979:pn-0x10000090fadd5979 host_traddr=nn-0x20000090fac7e1dd:pn-0x10000090fac7e1dd live
    +- nvme2 fc traddr=nn-0x20000090fadd5979:pn-0x10000090fadd5979 host_traddr=nn-0x20000090fac7e1de:pn-0x10000090fac7e1de live
    +- nvme3 fc traddr=nn-0x20000090fadd597a:pn-0x10000090fadd597a host_traddr=nn-0x20000090fac7e1de:pn-0x10000090fac7e1de live

   Vérifiez le type de transport actif. Par exemple, nvme0 fc indique que l'appareil est connecté via le transport Fibre Channel, et nvme tcp indique que l'appareil est connecté via TCP.

3. Si vous avez modifié les options du noyau, vérifiez si le multipathing NVMe natif est activé sur la ligne de commande du noyau :

   # cat /proc/cmdline
   
   BOOT_IMAGE=[...] nvme_core.multipath=Y

4. Si vous avez modifié la stratégie d'E/S, vérifiez que round-robin est la stratégie d'E/S active sur les périphériques NVMe :

   # cat /sys/class/nvme-subsystem/nvme-subsys0/iopolicy
   
   round-robin

Procédure

1. Installez le paquetage dracut-network:

   # dnf install dracut-network

2. Ajoutez la ligne suivante au fichier /etc/dracut.conf.d/network.conf:

   add_dracutmodules =" nfs "

Procédure

1. Activer le service tftp:

   # systemctl enable --now tftp

2. Créez un répertoire pxelinux à l'intérieur du répertoire racine tftp:

   # mkdir -p /var/lib/tftpboot/pxelinux/

3. Copiez le fichier /usr/share/syslinux/pxelinux.0 dans le répertoire /var/lib/tftpboot/pxelinux/:

   # cp /usr/share/syslinux/pxelinux.0 /var/lib/tftpboot/pxelinux/

   • Vous pouvez trouver le répertoire racine tftp (chroot) dans le répertoire /var/lib/tftpboot.

4. Copier /usr/share/syslinux/ldlinux.c32 sur /var/lib/tftpboot/pxelinux/:

   # cp /usr/share/syslinux/ldlinux.c32 /var/lib/tftpboot/pxelinux/

5. Créez un répertoire pxelinux.cfg à l'intérieur du répertoire racine tftp:

   # mkdir -p /var/lib/tftpboot/pxelinux/pxelinux.cfg/

   Cette configuration ne permet pas de démarrer via l'interface UEFI (Unified Extensible Firmware Interface). Pour effectuer l'installation pour l'UEFI, suivez la procédure décrite dans la section Configuration d'un serveur TFTP pour les clients basés sur l'UEFI.

Procédure

1. Ajoutez la configuration au fichier /etc/dhcp/dhcpd.conf pour mettre en place un serveur DHCP et activer le Preboot Execution Environment (PXE) pour le démarrage :

   option space pxelinux;
   option pxelinux.magic code 208 = string;
   option pxelinux.configfile code 209 = text;
   option pxelinux.pathprefix code 210 = text;
   option pxelinux.reboottime code 211 = unsigned integer 32;
   option architecture-type code 93 = unsigned integer 16;
   
   subnet 192.168.205.0 netmask 255.255.255.0 {
     option routers 192.168.205.1;
     range 192.168.205.10 192.168.205.25;
   
     class "pxeclients" {
       match if substring (option vendor-class-identifier, 0, 9) = "PXEClient";
       next-server 192.168.205.1;
   
       if option architecture-type = 00:07 {
         filename "BOOTX64.efi";
         } else {
         filename "pxelinux/pxelinux.0";
       }
     }
   }

   • Votre configuration DHCP peut être différente en fonction de votre environnement, comme la définition de la durée du bail ou de l'adresse fixe. Pour plus de détails, voir Fournir des services DHCP.

     Note

     Lors de l'utilisation de la machine virtuelle libvirt en tant que client sans disque, le démon libvirt fournit le service DHCP et le serveur DHCP autonome n'est pas utilisé. Dans cette situation, le démarrage en réseau doit être activé avec l'option bootp file=<filename> dans la configuration du réseau libvirt, virsh net-edit.

2. Activer dhcpd.service:

   # systemctl enable --now dhcpd.service

Procédure

1. Configurez le serveur NFS (Network File System) pour exporter le répertoire racine en l'ajoutant au répertoire /etc/exports. Pour obtenir l'ensemble des instructions, voir Configuration du serveur NFS.

2. Installez une version complète de Red Hat Enterprise Linux dans le répertoire racine afin d'accommoder les clients sans disque. Pour ce faire, vous pouvez soit installer un nouveau système de base, soit cloner une installation existante.

   • Installez Red Hat Enterprise Linux à l'emplacement exporté en remplaçant exported-root-directory par le chemin d'accès au système de fichiers exporté :

     # dnf install @Base kernel dracut-network nfs-utils \ --installroot=pass:quotes[exported-root-directory] --releasever=/

   • Utilisez l'utilitaire rsync pour vous synchroniser avec un système en cours d'exécution :

     # rsync -a -e ssh --exclude='/proc/' --exclude='/sys/' \ pass:quotes example.com:/ pass:quotes exported-root-directory

     • Remplacez example.com par le nom d'hôte du système en cours d'exécution avec lequel vous souhaitez vous synchroniser via l'utilitaire rsync.

     • Remplacez exported-root-directory par le chemin d'accès au système de fichiers exporté.

       Notez que pour cette option, vous devez disposer d'un système existant distinct, que vous clonerez sur le serveur à l'aide de la commande ci-dessus.

Configuration d'un système de fichiers

1. Copiez le noyau supporté par le client sans disque (vmlinuz-_kernel-version_pass:attributes) dans le répertoire de démarrage tftp:

   # cp /exported-root-directory/boot/vmlinuz-kernel-version /var/lib/tftpboot/pxelinux/

2. Créer le fichier initramfs-kernel-version.img localement et le déplacer vers le répertoire racine exporté avec le support de NFS :

   # dracut --add nfs initramfs-kernel-version.img kernel-version

   Par exemple :

   # dracut --add nfs /exports/root/boot/initramfs-5.14.0-202.el9.x86_64.img 5.14.0-202.el9.x86_64

   Exemple de création d'un initrd, en utilisant la version actuelle du noyau et en écrasant l'image existante :

   # dracut -f --add nfs \N-"boot/initramfs-$(uname -r).img\N" \N-"$(uname -r)\N"

3. Modifiez les permissions du fichier initrd en 0644:

   # chmod 0644 /exported-root-directory/boot/initramfs-kernel-version.img

   Avertissement

   Si vous ne modifiez pas les permissions du fichier initrd, le chargeur de démarrage pxelinux.0 échoue avec une erreur "file not found" (fichier introuvable).

4. Copiez le fichier résultant initramfs-kernel-version.img dans le répertoire de démarrage de tftp:

   # cp /exported-root-directory/boot/initramfs-kernel-version.img /var/lib/tftpboot/pxelinux/

5. Ajoutez la configuration suivante dans le fichier /var/lib/tftpboot/pxelinux/pxelinux.cfg/default pour modifier la configuration de démarrage par défaut pour l'utilisation de initrd et du noyau :

   default rhel9
   
   label rhel9
     kernel vmlinuz-kernel-version
     append initrd=initramfs-kernel-version.img root=nfs:_server-ip_:/exported-root-directory rw

   • Cette configuration indique à la racine du client sans disque de monter le système de fichiers exporté (/exported-root-directory) en lecture/écriture.

6. Facultatif : Montez le système de fichiers au format read-only en modifiant le fichier /var/lib/tftpboot/pxelinux/pxelinux.cfg/default avec la configuration suivante :

   default rhel9
   
   label rhel9
     kernel vmlinuz-kernel-version
     append initrd=initramfs-kernel-version.img root=nfs:server-ip:/exported-root-directory ro

7. Redémarrez le serveur NFS :

   # systemctl restart nfs-server.service

Procédure

1. Pour modifier le mot de passe de l'utilisateur, procédez comme suit :

   • Modifiez la ligne de commande en /exported/root/directory:

     # chroot /exported/root/directory /bin/bash

   • Modifiez le mot de passe de l'utilisateur souhaité :

     # passwd <username>

     Remplacez le <username> par un utilisateur réel pour lequel vous souhaitez modifier le mot de passe.

   • Quitter la ligne de commande.

2. Installer un logiciel sur un système distant sans disque :

   # dnf install <package> --installroot=/exported/root/directory --releasever=/ --config /etc/dnf/dnf.conf --setopt=reposdir=/etc/yum.repos.d/

   • Remplacez <package> par le paquet que vous souhaitez installer.
3. Configurez deux exportations distinctes pour diviser un système sans disque distant en un système /usr et un système /var. Voir la configuration du serveur NFS pour plus d'informations.

Procédure

1. Désactiver l'échange pour le volume logique associé :

   # swapoff -v /dev/VolGroup00/LogVol01

2. Redimensionner le volume logique LVM2 par 2 GB:

   # lvresize /dev/VolGroup00/LogVol01 -L  2G

3. Formatez le nouvel espace de pagination :

   # mkswap /dev/VolGroup00/LogVol01

4. Activer le volume logique étendu :

   # swapon -v /dev/VolGroup00/LogVol01

Procédure

1. Créer le volume logique LVM2 de taille 2 GB:

   # lvcreate VolGroup00 -n LogVol02 -L 2G

2. Formatez le nouvel espace de pagination :

   # mkswap /dev/VolGroup00/LogVol02

3. Ajoutez l'entrée suivante au fichier /etc/fstab:

   /dev/VolGroup00/LogVol02 none swap defaults 0 0

4. Régénérez les unités de montage pour que votre système enregistre la nouvelle configuration :

   # systemctl daemon-reload

5. Activer le swap sur le volume logique :

   # swapon -v /dev/VolGroup00/LogVol02

Procédure

1. Déterminez la taille du nouveau fichier d'échange en mégaoctets et multipliez-la par 1024 pour déterminer le nombre de blocs. Par exemple, la taille des blocs d'un fichier d'échange de 64 Mo est de 65536.

2. Créer un fichier vide :

   # dd if=/dev/zero of=/swapfile bs=1024 count=65536

   Remplacez 65536 par la valeur correspondant à la taille de bloc souhaitée.

3. Configurez le fichier d'échange avec la commande :

   # mkswap /swapfile

4. Modifier la sécurité du fichier d'échange pour qu'il ne soit pas lisible par le monde entier.

   # chmod 0600 /swapfile

5. Modifiez le fichier /etc/fstab avec les entrées suivantes pour activer le fichier d'échange au moment du démarrage :

   /swapfile none swap defaults 0 0

   La prochaine fois que le système démarre, il active le nouveau fichier d'échange.

6. Régénérez les unités de montage pour que votre système enregistre la nouvelle configuration /etc/fstab:

   # systemctl daemon-reload

7. Activer immédiatement le fichier d'échange :

   # swapon /swapfile

Procédure

1. Désactiver l'échange pour le volume logique associé :

   # swapoff -v /dev/VolGroup00/LogVol01

2. Réduisez le volume logique LVM2 de 512 Mo :

   # lvreduce /dev/VolGroup00/LogVol01 -L -512M

3. Formatez le nouvel espace de pagination :

   # mkswap /dev/VolGroup00/LogVol01

4. Activer le swap sur le volume logique :

   # swapon -v /dev/VolGroup00/LogVol01

Procédure

1. Désactiver l'échange pour le volume logique associé :

   # swapoff -v /dev/VolGroup00/LogVol02

2. Supprimer le volume logique LVM2 :

   # lvremove /dev/VolGroup00/LogVol02

3. Supprimer l'entrée associée suivante du fichier /etc/fstab:

   /dev/VolGroup00/LogVol02 none swap defaults 0 0

4. Régénérer les unités de montage pour enregistrer la nouvelle configuration :

   # systemctl daemon-reload

Procédure

1. À l'invite d'un shell, exécutez la commande suivante pour désactiver le fichier d'échange, où /swapfile est le fichier d'échange :

   # swapoff -v /swapfile

2. Supprimez son entrée du fichier /etc/fstab en conséquence.

3. Régénérez les unités de montage pour que votre système enregistre la nouvelle configuration :

   # systemctl daemon-reload

4. Supprimer le fichier actuel :

   # rm /swapfile

Procédure

1. Installez le paquetage fcoe-utils:

   # dnf install fcoe-utils

2. Copiez le fichier modèle /etc/fcoe/cfg-ethx dans /etc/fcoe/cfg-interface_name. Par exemple, si vous voulez configurer l'interface enp1s0 pour utiliser FCoE, entrez la commande suivante :

   # cp /etc/fcoe/cfg-ethx /etc/fcoe/cfg-enp1s0

3. Activez et démarrez le service fcoe:

   # systemctl enable --now fcoe

4. Découvrez le VLAN FCoE sur l'interface enp1s0, créez un périphérique réseau pour le VLAN découvert et démarrez l'initiateur :

   # fipvlan -s -c enp1s0
   Created VLAN device enp1s0.200
   Starting FCoE on interface enp1s0.200
   Fibre Channel Forwarders Discovered
   interface       | VLAN | FCF MAC
   ------------------------------------------
   enp1s0          | 200  | 00:53:00:a7:e7:1b

5. Facultatif : Affichez des détails sur les cibles découvertes, les LUN et les périphériques associés aux LUN :

   # fcoeadm -t
   Interface:        enp1s0.200
   Roles:            FCP Target
   Node Name:        0x500a0980824acd15
   Port Name:        0x500a0982824acd15
   Target ID:        0
   MaxFrameSize:     2048 bytes
   OS Device Name:   rport-11:0-1
   FC-ID (Port ID):  0xba00a0
   State:            Online
   
   LUN ID  Device Name   Capacity   Block Size  Description
   ------  -----------  ----------  ----------  ---------------------
        0  sdb           28.38 GiB      512     NETAPP LUN (rev 820a)
        ...

   Cet exemple montre que le LUN 0 du SAN a été attaché à l'hôte en tant que périphérique /dev/sdb.

Conditions préalables

1. Vous avez installé le paquetage mt-st. Pour plus d'informations, voir Installation de l'outil de gestion des lecteurs de bande.

2. Charger le lecteur de bande :

   # mt -f /dev/st0 load

Procédure

1. Vérifier la tête de lecture :

   # mt -f /dev/st0 status
   
   SCSI 2 tape drive:
   File number=-1, block number=-1, partition=0.
   Tape block size 0 bytes. Density code 0x0 (default).
   Soft error count since last status=0
   General status bits on (50000):
    DR_OPEN IM_REP_EN

   Ici :

   • la valeur actuelle de file number est -1.
   • le site block number définit la tête de bande. Par défaut, il est fixé à -1.
   • le block size 0 indique que l'unité de bande n'a pas de taille de bloc fixe.
   • le site Soft error count indique le nombre d'erreurs rencontrées après l'exécution de la commande mt status.
   • le site General status bits explique les caractéristiques de l'appareil à bandes.
   • DR_OPEN indique que la porte est ouverte et que le dispositif de bande est vide. IM_REP_EN est le mode de rapport immédiat.

2. Si le périphérique de bande n'est pas vide, écrasez-le :

   # tar -czf /dev/st0 _/source/directory

   Cette commande écrase les données d'un périphérique de bande avec le contenu de /source/directory.

3. Sauvegarder le /source/directory sur l'appareil à bandes :

   # tar -czf /dev/st0 _/source/directory
   tar: Removing leading `/' from member names
   /source/directory
   /source/directory/man_db.conf
   /source/directory/DIR_COLORS
   /source/directory/rsyslog.conf
   [...]

4. Visualiser l'état de l'unité de bande :

   # mt -f /dev/st0  status

Conditions préalables

1. Vous avez installé le paquetage mt-st. Pour plus d'informations, voir Installation de l'outil de gestion des lecteurs de bande.

2. Charger le lecteur de bande :

   # mt -f /dev/nst0 load

Procédure

1. Vérifiez la tête de bande de l'appareil à bande non rembobinée /dev/nst0:

   # mt -f /dev/nst0 status

2. Spécifier le pointeur à la tête ou à la fin de la bande :

   # mt -f /dev/nst0 rewind

3. Ajouter les données sur le périphérique de bande :

   # mt -f /dev/nst0 eod
   # tar -czf /dev/nst0 /source/directory/

4. Sauvegarder le /source/directory/ sur l'appareil à bandes :

   # tar -czf /dev/nst0 /source/directory/
   tar: Removing leading `/' from member names
   /source/directory/
   /source/directory/man_db.conf
   /source/directory/DIR_COLORS
   /source/directory/rsyslog.conf
   [...]

5. Visualiser l'état de l'unité de bande :

   # mt -f /dev/nst0  status

Conditions préalables

1. Vous avez installé le paquetage mt-st. Pour plus d'informations, voir Installation de l'outil de gestion des lecteurs de bande.
2. Les données sont écrites sur le périphérique à bande. Pour plus d'informations, voir Écriture sur des périphériques à bande rembobinée ou Écriture sur des périphériques à bande non rembobinée.

Conditions préalables

1. Vous avez installé le paquetage mt-st. Pour plus d'informations, voir Installation de l'outil de gestion des lecteurs de bande.
2. Les données sont écrites sur le périphérique à bande. Pour plus d'informations, voir Écriture sur des périphériques à bande rembobinée ou Écriture sur des périphériques à bande non rembobinée.

Conditions préalables

1. Vous avez installé le paquetage mt-st. Pour plus d'informations, voir Installation de l'outil de gestion des lecteurs de bande.
2. Les données sont écrites sur le périphérique à bande. Pour plus d'informations, voir Écriture sur des périphériques à bande rembobinée ou Écriture sur des périphériques à bande non rembobinée.

Procédure

1. Efface les données de l'unité de bande :

   # mt -f /dev/st0 erase

2. Décharger l'appareil à bande :

   mt -f /dev/st0 hors ligne

Procédure

1. Dans le volet gauche de la fenêtre Manual Partitioning, sélectionnez la partition requise.
2. Sous la section Device(s), cliquez sur Modifier. La boîte de dialogue Configure Mount Point s'ouvre.
3. Sélectionnez les disques que vous souhaitez inclure dans le périphérique RAID et cliquez sur Sélectionner.
4. Cliquez sur le menu déroulant Device Type et sélectionnez RAID.
5. Cliquez sur le menu déroulant File System et sélectionnez votre type de système de fichiers préféré.
6. Cliquez sur le menu déroulant RAID Level et sélectionnez le niveau de RAID de votre choix.
7. Cliquez sur Mettre à jour les paramètres pour enregistrer vos modifications.
8. Cliquez sur Terminé pour appliquer les paramètres et revenir à la fenêtre Installation Summary.

Procédure

1. Créez un RAID de deux blocs, par exemple /dev/sda1 et /dev/sdc1:

   # mdadm --create /dev/md0 --level=2 --raid-devices=2 /dev/sda1 /dev/sdc1
   mdadm: Defaulting to version 1.2 metadata
   mdadm: array /dev/md0 started.

   L'option level_value définit le niveau de RAID.

2. Facultatif : Vérifiez l'état du RAID :

   # mdadm --detail /dev/md0
   /dev/md0:
              Version : 1.2
        Creation Time : Thu Oct 13 15:17:39 2022
           Raid Level : raid0
           Array Size : 18649600 (17.79 GiB 19.10 GB)
         Raid Devices : 2
        Total Devices : 2
          Persistence : Superblock is persistent
   
          Update Time : Thu Oct 13 15:17:39 2022
                State : clean
       Active Devices : 2
      Working Devices : 2
       Failed Devices : 0
        Spare Devices : 0
   [...]

3. Facultatif : Observez les informations détaillées concernant chaque périphérique du RAID :

   # mdadm --examine /dev/sda1 /dev/sdc1
   /dev/sda1:
             Magic : a92b4efc
           Version : 1.2
       Feature Map : 0x1000
        Array UUID : 77ddfb0a:41529b0e:f2c5cde1:1d72ce2c
              Name : 0
     Creation Time : Thu Oct 13 15:17:39 2022
        Raid Level : raid0
      Raid Devices : 2
   [...]

4. Créez un système de fichiers sur le lecteur RAID :

   # mkfs -t xfs /dev/md0

   Remplacez xfs par le système de fichiers avec lequel vous avez choisi de formater le disque.

5. Créez un point de montage pour le lecteur RAID et montez-le :

   # mkdir /mnt/raid1
   # mount /dev/md0 /mnt/raid1

   Remplacez /mnt/raid1 par le point de montage.

   Si vous souhaitez que RHEL monte automatiquement le périphérique RAID md0 au démarrage du système, ajoutez une entrée pour votre périphérique dans le fichier /etc/fstab file:

   /dev/md0   /mnt/raid1 xfs  defaults   0 0

Procédure

1. Créez un nouveau fichier playbook.yml avec le contenu suivant :

   ---
   - name: Configure the storage
     hosts: managed-node-01.example.com
     tasks:
     - name: Create a RAID on sdd, sde, sdf, and sdg
       include_role:
         name: rhel-system-roles.storage
       vars:
       storage_safe_mode: false
       storage_volumes:
         - name: data
           type: raid
           disks: [sdd, sde, sdf, sdg]
           raid_level: raid0
           raid_chunk_size: 32 KiB
           mount_point: /mnt/data
           state: present

   Avertissement

   Les noms de périphériques peuvent changer dans certaines circonstances, par exemple lorsque vous ajoutez un nouveau disque à un système. Par conséquent, pour éviter toute perte de données, n'utilisez pas de noms de disques spécifiques dans le guide de lecture.

2. Facultatif : Vérifiez la syntaxe du playbook :

   # ansible-playbook --syntax-check playbook.yml

3. Exécutez le manuel de jeu :

   # ansible-playbook -i inventory.file /path/to/file/playbook.yml

Procédure

1. Étendre les partitions RAID. Pour plus d'informations, voir Redimensionnement d'une partition avec parted.

2. Étendre le RAID au maximum de la capacité de la partition :

   # mdadm --grow --size=max /dev/md0

   Pour définir une taille spécifique, écrivez la valeur du paramètre --size en kB, par exemple --size=524228.

3. Augmentez la taille du système de fichiers. Par exemple, si le volume utilise XFS et est monté sur /mnt/, entrez :

   # xfs_growfs /mnt/

Procédure

1. Réduire le système de fichiers. Pour plus d'informations, voir Gestion des systèmes de fichiers.

2. Réduire le RAID à la taille voulue, par exemple à 512 MB:

   # mdadm --grow --size=524228 /dev/md0

   Inscrivez le paramètre --size en kB.

3. Réduisez la partition à la taille dont vous avez besoin.

Procédure

1. Convertir le RAID /dev/md0 au niveau RAID 5:

   # mdadm --grow --level=5 -n 3 /dev/md0 --force

2. Ajouter un nouveau disque à la matrice :

   # mdadm --manage /dev/md0 --add /dev/sdd

Procédure

1. Copiez le contenu de la partition de démarrage de la plate-forme de référence PowerPC (PReP) de /dev/sda1 à /dev/sdb1:

   # dd if=/dev/sda1 of=/dev/sdb1

2. Mettez à jour les drapeaux prep et boot sur la première partition des deux disques :

   $ parted /dev/sda set 1 prep on
   $ parted /dev/sda set 1 boot on
   
   $ parted /dev/sdb set 1 prep on
   $ parted /dev/sdb set 1 boot on

Procédure

1. Insérer le disque d'installation.
2. Lors du démarrage initial, sélectionnez Rescue Mode au lieu de Install ou Upgrade. Lorsque le système démarre complètement à Rescue mode, vous pouvez voir le terminal de ligne de commande.

3. À partir de ce terminal, exécutez les commandes suivantes :

   1. Créez des partitions RAID sur les disques durs cibles à l'aide de la commande parted.
   2. Créez manuellement des matrices raid en utilisant la commande mdadm à partir de ces partitions en utilisant tous les paramètres et options disponibles.
4. Facultatif : Après avoir créé des tableaux, créez également des systèmes de fichiers sur les tableaux.
5. Redémarrez l'ordinateur et sélectionnez Install ou Upgrade pour l'installation. Lorsque le programme d'installation d'Anaconda recherche les disques du système, il trouve les périphériques RAID préexistants.
6. Lorsque l'on vous demande comment utiliser les disques du système, sélectionnez Custom Layout et cliquez sur Suivant. Dans la liste des périphériques, les périphériques MD RAID préexistants sont répertoriés.
7. Sélectionnez un périphérique RAID et cliquez sur Modifier.
8. Configurez son point de montage et éventuellement le type de système de fichiers à utiliser si vous n'en avez pas créé un auparavant, puis cliquez sur Terminé. Anaconda s'installe sur ce périphérique RAID préexistant, en préservant les options personnalisées que vous avez sélectionnées lorsque vous l'avez créé en mode Rescue.

Procédure

1. Créez le fichier de configuration /etc/mdadm.conf pour la surveillance de la matrice en analysant les détails du RAID :

   # mdadm --detail --scan >> /etc/mdadm.conf

   Notez que ARRAY et MAILADDR sont des variables obligatoires.

2. Ouvrez le fichier de configuration /etc/mdadm.conf avec un éditeur de texte de votre choix et ajoutez la variable MAILADDR avec l'adresse de courrier électronique pour la notification. Par exemple, ajoutez une nouvelle ligne :

   MAILADDR example@example.com>

   Ici, example@example.com est une adresse électronique à laquelle vous souhaitez recevoir les alertes de la surveillance de la matrice.

3. Enregistrez les modifications dans le fichier /etc/mdadm.conf et fermez-le.

Procédure

1. Vérifiez le disque défaillant :

   1. Consulter les journaux du noyau :

      # journalctl -k -f

   2. Recherchez un message similaire au suivant :

      md/raid:md0: Disk failure on sdd, disabling device.
      
      md/raid:md0: Operation continuing on 3 devices.

   3. Appuyer sur Ctrl+C pour quitter le programme journalctl.

2. Marquer le disque défaillant comme défectueux :

   # mdadm --manage /dev/md0 --fail /dev/sdd

3. Facultatif : Vérifiez si le disque défaillant a été marqué correctement :

   # mdadm --detail /dev/md0

   À la fin de la sortie se trouve une liste de disques dans le RAID /dev/md0 où le disque /dev/sdd a le statut faulty:

   Number   Major   Minor   RaidDevice State
      0       8       16        0      active sync   /dev/sdb
      1       8       32        1      active sync   /dev/sdc
      -       0        0        2      removed
      3       8       64        3      active sync   /dev/sde
   
      2       8       48        -      faulty   /dev/sdd

4. Retirez le disque défaillant du RAID :

   # mdadm --manage /dev/md0 --remove /dev/sdd

   Avertissement

   Si votre RAID ne peut pas supporter une autre défaillance de disque, ne retirez aucun disque tant que le nouveau disque n'a pas l'état active sync. Vous pouvez surveiller la progression à l'aide de la commande watch cat /proc/mdstat.

5. Ajoutez le nouveau disque au RAID :

   # mdadm --manage /dev/md0 --add /dev/sdf

   Le RAID /dev/md0 comprend maintenant le nouveau disque /dev/sdf et le service mdadm commencera automatiquement à copier les données des autres disques vers ce disque.

Procédure

1. Vérifiez le comportement des disques défaillants dans la matrice :

   # echo check > /sys/block/md0/md/sync_action

   Cette opération vérifie le tableau et le fichier /sys/block/md0/md/sync_action montre l'action de synchronisation.

2. Ouvrez le fichier /sys/block/md0/md/sync_action avec l'éditeur de texte de votre choix et voyez s'il y a un message sur les échecs de synchronisation des disques.
3. Consultez le fichier /sys/block/md0/md/mismatch_cnt. Si le paramètre mismatch_cnt n'est pas 0, cela signifie que les disques RAID doivent être réparés.

4. Réparez les disques de la matrice :

   # echo repair > /sys/block/md0/md/sync_action

   Cette opération répare les disques de la matrice et écrit le résultat dans le fichier /sys/block/md0/md/sync_action.

5. Visualiser l'état d'avancement de la synchronisation :

   # cat /sys/block/md0/md/sync_action
   repair
   
   # cat /proc/mdstat
   Personalities : [raid0] [raid6] [raid5] [raid4] [raid1]
   md0 : active raid1 sdg[1] dm-3[0]
         511040 blocks super 1.2 [2/2] [UU]
   unused devices: <none>

Procédure

1. Démontez tous les systèmes de fichiers sur le périphérique que vous prévoyez de chiffrer, par exemple :

   # umount /dev/mapper/vg00-lv00

2. Libérez de l'espace pour stocker un en-tête LUKS. Utilisez l'une des options suivantes en fonction de votre scénario :

   • Dans le cas du chiffrement d'un volume logique, vous pouvez étendre le volume logique sans redimensionner le système de fichiers. Par exemple, il est possible d'étendre un volume logique sans redimensionner le système de fichiers :

     # lvextend -L 32M /dev/mapper/vg00-lv00

   • Étendez la partition en utilisant des outils de gestion de partition, tels que parted.
   • Réduisez le système de fichiers sur le périphérique. Vous pouvez utiliser l'utilitaire resize2fs pour les systèmes de fichiers ext2, ext3 ou ext4. Notez que vous ne pouvez pas réduire le système de fichiers XFS.

3. Initialiser le cryptage :

   # cryptsetup reencrypt --encrypt --init-only --reduce-device-size 32M /dev/mapper/vg00-lv00 lv00_encrypted
   
   /dev/mapper/lv00_encrypted is now active and ready for online encryption.

4. Monter l'appareil :

   # mount /dev/mapper/lv00_encrypted /mnt/lv00_encrypted

5. Ajouter une entrée pour un mappage persistant au fichier /etc/crypttab:

   1. Trouver le site luksUUID:

      # cryptsetup luksUUID /dev/mapper/vg00-lv00
      
      a52e2cc9-a5be-47b8-a95d-6bdf4f2d9325

   2. Ouvrez /etc/crypttab dans un éditeur de texte de votre choix et ajoutez un dispositif dans ce fichier :

      $ vi /etc/crypttab
      
      lv00_encrypted UUID=a52e2cc9-a5be-47b8-a95d-6bdf4f2d9325 none

      Remplacez a52e2cc9-a5be-47b8-a95d-6bdf4f2d9325 par le site luksUUID de votre appareil.

   3. Rafraîchir les initramfs avec dracut:

      $ dracut -f --regenerate-all

6. Ajouter une entrée pour un montage persistant au fichier /etc/fstab:

   1. Recherchez l'UUID du système de fichiers du périphérique bloc LUKS actif :

      $ blkid -p /dev/mapper/lv00_encrypted
      
      /dev/mapper/lv00-encrypted: UUID="37bc2492-d8fa-4969-9d9b-bb64d3685aa9" BLOCK_SIZE="4096" TYPE="xfs" USAGE="filesystem"

   2. Ouvrez /etc/fstab dans un éditeur de texte de votre choix et ajoutez un dispositif dans ce fichier, par exemple :

      $ vi /etc/fstab
      
      UUID=37bc2492-d8fa-4969-9d9b-bb64d3685aa9 /home auto rw,user,auto 0

      Remplacez 37bc2492-d8fa-4969-9d9b-bb64d3685aa9 par l'UUID de votre système de fichiers.

7. Reprendre le cryptage en ligne :

   # cryptsetup reencrypt --resume-only /dev/mapper/vg00-lv00
   
   Enter passphrase for /dev/mapper/vg00-lv00:
   Auto-detected active dm device 'lv00_encrypted' for data device /dev/mapper/vg00-lv00.
   Finished, time 00:31.130, 10272 MiB written, speed 330.0 MiB/s

Vérification

1. Vérifier si les données existantes ont été cryptées :

   # cryptsetup luksDump /dev/mapper/vg00-lv00
   
   LUKS header information
   Version: 2
   Epoch: 4
   Metadata area: 16384 [bytes]
   Keyslots area: 16744448 [bytes]
   UUID: a52e2cc9-a5be-47b8-a95d-6bdf4f2d9325
   Label: (no label)
   Subsystem: (no subsystem)
   Flags: (no flags)
   
   Data segments:
     0: crypt
   	offset: 33554432 [bytes]
   	length: (whole device)
   	cipher: aes-xts-plain64
   [...]

2. Affichez l'état du dispositif de bloc vierge crypté :

   # cryptsetup status lv00_encrypted
   
   /dev/mapper/lv00_encrypted is active and is in use.
     type:    LUKS2
     cipher:  aes-xts-plain64
     keysize: 512 bits
     key location: keyring
     device:  /dev/mapper/vg00-lv00

Procédure

1. Démonter tous les systèmes de fichiers sur l'appareil, par exemple :

   # umount /dev/nvme0n1p1

2. Initialiser le cryptage :

   # cryptsetup reencrypt --encrypt --init-only --header /home/header /dev/nvme0n1p1 nvme_encrypted
   
   WARNING!
   ========
   Header file does not exist, do you want to create it?
   
   Are you sure? (Type 'yes' in capital letters): YES
   Enter passphrase for /home/header:
   Verify passphrase:
   /dev/mapper/nvme_encrypted is now active and ready for online encryption.

   Remplacez /home/header par un chemin d'accès au fichier contenant un en-tête LUKS détaché. L'en-tête LUKS détaché doit être accessible pour déverrouiller ultérieurement le dispositif crypté.

3. Monter l'appareil :

   # mount /dev/mapper/nvme_encrypted /mnt/nvme_encrypted

4. Reprendre le cryptage en ligne :

   # cryptsetup reencrypt --resume-only --header /home/header /dev/nvme0n1p1
   
   Enter passphrase for /dev/nvme0n1p1:
   Auto-detected active dm device 'nvme_encrypted' for data device /dev/nvme0n1p1.
   Finished, time 00m51s,   10 GiB written, speed 198.2 MiB/s

Vérification

1. Vérifiez si les données existantes sur un périphérique de bloc utilisant LUKS2 avec un en-tête détaché sont chiffrées :

   # cryptsetup luksDump /home/header
   
   LUKS header information
   Version:       	2
   Epoch:         	88
   Metadata area: 	16384 [bytes]
   Keyslots area: 	16744448 [bytes]
   UUID:          	c4f5d274-f4c0-41e3-ac36-22a917ab0386
   Label:         	(no label)
   Subsystem:     	(no subsystem)
   Flags:       	(no flags)
   
   Data segments:
     0: crypt
   	offset: 0 [bytes]
   	length: (whole device)
   	cipher: aes-xts-plain64
   	sector: 512 [bytes]
   [...]

2. Affichez l'état du dispositif de bloc vierge crypté :

   # cryptsetup status nvme_encrypted
   
   /dev/mapper/nvme_encrypted is active and is in use.
     type:    LUKS2
     cipher:  aes-xts-plain64
     keysize: 512 bits
     key location: keyring
     device:  /dev/nvme0n1p1

Procédure

1. Configurer une partition en tant que partition LUKS chiffrée :

   # cryptsetup luksFormat /dev/nvme0n1p1
   
   WARNING!
   ========
   This will overwrite data on /dev/nvme0n1p1 irrevocably.
   Are you sure? (Type 'yes' in capital letters): YES
   Enter passphrase for /dev/nvme0n1p1:
   Verify passphrase:

2. Ouvrez une partition LUKS chiffrée :

   # cryptsetup open dev/nvme0n1p1 nvme0n1p1_encrypted
   
   Enter passphrase for /dev/nvme0n1p1:

   Cette commande déverrouille la partition et l'affecte à un nouveau périphérique en utilisant le mappeur de périphérique. Pour ne pas écraser les données chiffrées, cette commande avertit le noyau que le périphérique est un périphérique chiffré et qu'il est adressé par LUKS à l'aide de l'attribut /dev/mapper/device_mapped_name chemin.

3. Créez un système de fichiers pour écrire des données cryptées sur la partition, à laquelle il faut accéder par le nom mappé du périphérique :

   # mkfs -t ext4 /dev/mapper/nvme0n1p1_encrypted

4. Monter l'appareil :

   # mount /dev/mapper/nvme0n1p1_encrypted mount-point

Vérification

1. Vérifiez si le périphérique de blocage vierge est crypté :

   # cryptsetup luksDump /dev/nvme0n1p1
   
   LUKS header information
   Version:       	2
   Epoch:         	3
   Metadata area: 	16384 [bytes]
   Keyslots area: 	16744448 [bytes]
   UUID:          	34ce4870-ffdf-467c-9a9e-345a53ed8a25
   Label:         	(no label)
   Subsystem:     	(no subsystem)
   Flags:       	(no flags)
   
   Data segments:
     0: crypt
   	offset: 16777216 [bytes]
   	length: (whole device)
   	cipher: aes-xts-plain64
   	sector: 512 [bytes]
   [...]

2. Affichez l'état du dispositif de bloc vierge crypté :

   # cryptsetup status nvme0n1p1_encrypted
   
   /dev/mapper/nvme0n1p1_encrypted is active and is in use.
     type:    LUKS2
     cipher:  aes-xts-plain64
     keysize: 512 bits
     key location: keyring
     device:  /dev/nvme0n1p1
     sector size:  512
     offset:  32768 sectors
     size:    20938752 sectors
     mode:    read/write

Procédure

1. Créez un nouveau fichier playbook.yml avec le contenu suivant :

   - hosts: all
     vars:
       storage_volumes:
         - name: barefs
           type: disk
           disks:
            - sdb
           fs_type: xfs
           fs_label: label-name
           mount_point: /mnt/data
           encryption: true
           encryption_password: your-password
     roles:
      - rhel-system-roles.storage

   Vous pouvez également ajouter les autres paramètres de cryptage tels que encryption_key, encryption_cipher, encryption_key_size, et encryption_luks version dans le fichier playbook.yml.

2. Facultatif : Vérifier la syntaxe du playbook :

   # ansible-playbook --syntax-check playbook.yml

3. Exécutez le playbook sur votre fichier d'inventaire :

   # ansible-playbook -i inventory.file /path/to/file/playbook.yml

Vérification

1. Visualiser l'état du cryptage :

   # cryptsetup status sdb
   
   /dev/mapper/sdb is active and is in use.
   type: LUKS2
   cipher: aes-xts-plain64
   keysize: 512 bits
   key location: keyring
   device: /dev/sdb
   [...]

2. Vérifiez le volume crypté LUKS créé :

   # cryptsetup luksDump /dev/sdb
   
   Version:       	2
   Epoch:         	6
   Metadata area: 	16384 [bytes]
   Keyslots area: 	33521664 [bytes]
   UUID:          	a4c6be82-7347-4a91-a8ad-9479b72c9426
   Label:         	(no label)
   Subsystem:     	(no subsystem)
   Flags:       	allow-discards
   
   Data segments:
     0: crypt
   	offset: 33554432 [bytes]
   	length: (whole device)
   	cipher: aes-xts-plain64
   	sector: 4096 [bytes]
   [...]

3. Consultez les paramètres cryptsetup dans le fichier playbook.yml que le rôle storage prend en charge :

   # cat ~/playbook.yml
   
       - hosts: all
         vars:
           storage_volumes:
             - name: foo
               type: disk
               disks:
                - nvme0n1
               fs_type: xfs
               fs_label: label-name
               mount_point: /mnt/data
               encryption: true
               #encryption_password: passwdpasswd
               encryption_key: /home/passwd_key
               encryption_cipher: aes-xts-plain64
               encryption_key_size: 512
               encryption_luks_version: luks2
   
         roles:
          - rhel-system-roles.storage