Chapter 35. Managing storage devices

Procedure

1. Install packages that provide the Stratis service and command-line utilities:

   # dnf install stratisd stratis-cli

2. To start the stratisd service and enable it to launch at boot:

   # systemctl enable --now stratisd

Procedure

1. Erase any file system, partition table, or RAID signatures that exist on each block device that you want to use in the Stratis pool:

   # wipefs --all block-device

   The block-device value is the path to the block device; for example, /dev/sdb.

2. Create the new unencrypted Stratis pool on the selected block device:

   # stratis pool create my-pool block-device

   The block-device value is the path to an empty or wiped block device.

   You can also specify multiple block devices on a single line by using the following command:

   # stratis pool create my-pool block-device-1 block-device-2

Procedure

1. Log in to the RHEL 8 web console.

   For details, see Logging in to the web console.

2. Click Storage.
3. In the Storage table, click the menu button and select Create Stratis pool.
4. In the Name field, enter a name for the Stratis pool.
5. Select the Block devices from which you want to create the Stratis pool.
6. Optional: If you want to specify the maximum size for each file system that is created in the pool, select Manage filesystem sizes.
7. Click Create.

Procedure

1. Erase any file system, partition table, or RAID signatures that exist on each block device that you want to use in the Stratis pool:

   # wipefs --all block-device

   The block-device value is the path to the block device; for example, /dev/sdb.

2. If you have not set a key already, run the following command and follow the prompts to create a key set to use for the encryption:

   # stratis key set --capture-key key-description

   The key-description is a reference to the key that gets created in the kernel keyring. You will be prompted to enter a key value at the command-line. You can also place the key value in a file and use the --keyfile-path option instead of the --capture-key option.

3. Create the encrypted Stratis pool and specify the key description to use for the encryption:

   # stratis pool create --key-desc key-description my-pool block-device

   key-description

   References the key that exists in the kernel keyring, which you created in the previous step.

   my-pool

   Specifies the name of the new Stratis pool.

   block-device

   Specifies the path to an empty or wiped block device.

   You can also specify multiple block devices on a single line by using the following command:

   # stratis pool create --key-desc key-description my-pool block-device-1 block-device-2

Procedure

1. Log in to the RHEL 8 web console.

   For details, see Logging in to the web console.

2. Click Storage.
3. In the Storage table, click the menu button and select Create Stratis pool.
4. In the Name field, enter a name for the Stratis pool.
5. Select the Block devices from which you want to create the Stratis pool.

6. Select the type of encryption, you can use a passphrase, a Tang keyserver, or both:

   • Passphrase:

     1. Enter a passphrase.
     2. Confirm the passphrase.

   • Tang keyserver:

     1. Enter the keyserver address. For more information, see Deploying a Tang server with SELinux in enforcing mode.
7. Optional: If you want to specify the maximum size for each file system that is created in pool, select Manage filesystem sizes.
8. Click Create.

Procedure

1. Log in to the RHEL 8 web console.

   For details, see Logging in to the web console.

2. Click Storage.
3. In the Storage table, click the Stratis pool you want to rename.
4. On the Stratis pool page, click edit next to the Name field.
5. In the Rename Stratis pool dialog box, enter a new name.
6. Click Rename.

1. Create a pool from one or more block devices:

   # stratis pool create pool-name /dev/sdb

2. Set overprovisioning mode in the existing pool:

   # stratis pool overprovision pool-name <yes|no>

   • If set to "yes", you enable overprovisioning to the pool. This means that the sum of the logical sizes of the Stratis file systems, supported by the pool, can exceed the amount of available data space. If the pool is overprovisioned and the sum of the logical sizes of all the file systems exceeds the space available on the pool, then the system cannot turn off overprovisioning and returns an error.

Verification

1. View the full list of Stratis pools:

   # stratis pool list
   
   Name       Total Physical                    Properties    UUID                                  Alerts
   pool-name  1.42 TiB / 23.96 MiB / 1.42 TiB  ~Ca,~Cr,~Op    cb7cb4d8-9322-4ac4-a6fd-eb7ae9e1e540

2. Check if there is an indication of the pool overprovisioning mode flag in the stratis pool list output. The " ~ " is a math symbol for "NOT", so ~Op means no-overprovisioning.

3. Optional: Check overprovisioning on a specific pool:

   # stratis pool overprovision pool-name yes
   
   # stratis pool list
   
   Name          Total Physical                    Properties     UUID                                   Alerts
   pool-name     1.42 TiB / 23.96 MiB / 1.42 TiB   ~Ca,~Cr,~Op    cb7cb4d8-9322-4ac4-a6fd-eb7ae9e1e540

Procedure

1. Re-create the key set using the same key description that was used previously:

   # stratis key set --capture-key key-description

   key-description references the key that exists in the kernel keyring, which was generated when you created the encrypted Stratis pool.

2. Verify that the Stratis pool is visible:

   # stratis pool list

Procedure

1. Create a Stratis file system on a pool:

   # stratis filesystem create --size number-and-unit my-pool my-fs

   number-and-unit

   Specifies the size of a file system. The specification format must follow the standard size specification format for input, that is B, KiB, MiB, GiB, TiB or PiB.

   my-pool

   Specifies the name of the Stratis pool.

   my-fs

   Specifies an arbitrary name for the file system.

   For example:

   Example 35.1. Creating a Stratis file system

   # stratis filesystem create --size 10GiB pool1 filesystem1

Procedure

1. Log in to the RHEL 8 web console.

   For details, see Logging in to the web console.

2. Click Storage.
3. Click the Stratis pool on which you want to create a file system.
4. On the Stratis pool page, scroll to the Stratis filesystems section and click Create new filesystem.
5. Enter a name for the file system.
6. Enter a mount point for the file system.
7. Select the mount option.
8. In the At boot drop-down menu, select when you want to mount your file system.

9. Create the file system:

   • If you want to create and mount the file system, click Create and mount.
   • If you want to only create the file system, click Create only.

Procedure

1. Log in to the RHEL 8 web console.

   For details, see Logging in to the web console.

2. Click Storage.
3. In the Storage table, click the Stratis pool to which you want to add a block device.
4. On the Stratis pool page, click Add block devices and select the Tier where you want to add a block device as data or cache.
5. If you are adding the block device to a Stratis pool that is encrypted with a passphrase, enter the passphrase.
6. Under Block devices, select the devices you want to add to the pool.
7. Click Add.

Procedure

1. Log in to the RHEL 8 web console.
2. Click Storage.

3. In the Storage table, click the Stratis pool you want to view.

   The Stratis pool page displays all the information about the pool and the file systems that you created in the pool.

Procedure

1. Optional: Back up the current state of the file system to be able to access it later:

   # stratis filesystem snapshot my-pool my-fs my-fs-backup

2. Unmount and remove the original file system:

   # umount /dev/stratis/my-pool/my-fs
   # stratis filesystem destroy my-pool my-fs

3. Create a copy of the snapshot under the name of the original file system:

   # stratis filesystem snapshot my-pool my-fs-snapshot my-fs

4. Mount the snapshot, which is now accessible with the same name as the original file system:

   # mount /dev/stratis/my-pool/my-fs mount-point

Procedure

1. Unmount the snapshot:

   # umount /dev/stratis/my-pool/my-fs-snapshot

2. Destroy the snapshot:

   # stratis filesystem destroy my-pool my-fs-snapshot

Procedure

1. Unmount the file system:

   # umount /dev/stratis/my-pool/my-fs

2. Destroy the file system:

   # stratis filesystem destroy my-pool my-fs

Procedure

1. Log in to the RHEL 8 web console.

   For details, see Logging in to the web console.

2. Click Storage.
3. In the Storage table, click the Stratis pool from which you want to delete a file system.
4. On the Stratis pool page, scroll to the Stratis filesystems section and click the menu button ⋮ for the file system you want to delete.
5. From the drop-down menu, select Delete.
6. In the Confirm deletion dialog box, click Delete.

Procedure

1. List file systems on the pool:

   # stratis filesystem list my-pool

2. Unmount all file systems on the pool:

   # umount /dev/stratis/my-pool/my-fs-1 \
            /dev/stratis/my-pool/my-fs-2 \
            /dev/stratis/my-pool/my-fs-n

3. Destroy the file systems:

   # stratis filesystem destroy my-pool my-fs-1 my-fs-2

4. Destroy the pool:

   # stratis pool destroy my-pool

Procedure

1. Log in to the RHEL 8 web console.

   For details, see Logging in to the web console.

2. Click Storage.
3. In the Storage table, click the menu button ⋮ for the Stratis pool you want to delete.
4. From the drop-down menu, select Delete pool.
5. In the Permanently delete pool dialog box, click Delete.

Procedure

1. Create the LVM2 logical volume of size 2 GB:

   # lvcreate VolGroup00 -n LogVol02 -L 2G

2. Format the new swap space:

   # mkswap /dev/VolGroup00/LogVol02

3. Add the following entry to the /etc/fstab file:

   /dev/VolGroup00/LogVol02 none swap defaults 0 0

4. Regenerate mount units so that your system registers the new configuration:

   # systemctl daemon-reload

5. Activate swap on the logical volume:

   # swapon -v /dev/VolGroup00/LogVol02

Procedure

1. Determine the size of the new swap file in megabytes and multiply by 1024 to determine the number of blocks. For example, the block size of a 64 MB swap file is 65536.

2. Create an empty file:

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

   Replace 65536 with the value equal to the required block size.

3. Set up the swap file with the command:

   # mkswap /swapfile

4. Change the security of the swap file so it is not world readable.

   # chmod 0600 /swapfile

5. Edit the /etc/fstab file with the following entries to enable the swap file at boot time:

   /swapfile none swap defaults 0 0

   The next time the system boots, it activates the new swap file.

6. Regenerate mount units so that your system registers the new /etc/fstab configuration:

   # systemctl daemon-reload

7. Activate the swap file immediately:

   # swapon /swapfile

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Create a disk device with swap
     hosts: managed-node-01.example.com
     roles:
       - rhel-system-roles.storage
     vars:
       storage_volumes:
         - name: swap_fs
           type: disk
           disks:
             - /dev/sdb
           size: 15 GiB
           fs_type: swap

   The volume name (swap_fs in the example) is currently arbitrary. The storage role identifies the volume by the disk device listed under the disks: attribute.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. Disable swapping for the associated logical volume:

   # swapoff -v /dev/VolGroup00/LogVol01

2. Resize the LVM2 logical volume by 2 GB:

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

3. Format the new swap space:

   # mkswap /dev/VolGroup00/LogVol01

4. Enable the extended logical volume:

   # swapon -v /dev/VolGroup00/LogVol01

Procedure

1. Disable swapping for the associated logical volume:

   # swapoff -v /dev/VolGroup00/LogVol01

2. Clean the swap signature:

   # wipefs -a /dev/VolGroup00/LogVol01

3. Reduce the LVM2 logical volume by 512 MB:

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

4. Format the new swap space:

   # mkswap /dev/VolGroup00/LogVol01

5. Activate swap on the logical volume:

   # swapon -v /dev/VolGroup00/LogVol01

Procedure

1. Disable swapping for the associated logical volume:

   # swapoff -v /dev/VolGroup00/LogVol02

2. Remove the LVM2 logical volume:

   # lvremove /dev/VolGroup00/LogVol02

3. Remove the following associated entry from the /etc/fstab file:

   /dev/VolGroup00/LogVol02 none swap defaults 0 0

4. Regenerate mount units to register the new configuration:

   # systemctl daemon-reload

Procedure

1. Disable the /swapfile swap file:

   # swapoff -v /swapfile

2. Remove its entry from the /etc/fstab file accordingly.

3. Regenerate mount units so that your system registers the new configuration:

   # systemctl daemon-reload

4. Remove the actual file:

   # rm /swapfile

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Manage local storage
     hosts: managed-node-01.example.com
     tasks:
       - name: Create an XFS file system on a block device
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.storage
         vars:
           storage_volumes:
             - name: barefs
               type: disk
               disks:
                 - sdb
               fs_type: xfs

   The setting specified in the example playbook include the following:

   name: barefs

   The volume name (barefs in the example) is currently arbitrary. The storage role identifies the volume by the disk device listed under the disks attribute.

   fs_type: <file_system>

   You can omit the fs_type parameter if you want to use the default file system XFS.

   disks: <list_of_disks_and_volumes>

   A YAML list of disk and LV names. To create the file system on an LV, provide the LVM setup under the disks attribute, including the enclosing volume group. For details, see Creating or resizing a logical volume by using the storage RHEL system role.

   Do not provide the path to the LV device.

   For details about all variables used in the playbook, see the /usr/share/ansible/roles/rhel-system-roles.storage/README.md file on the control node.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Manage local storage
     hosts: managed-node-01.example.com
     tasks:
       - name: Persistently mount a file system
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.storage
         vars:
           storage_volumes:
             - name: barefs
               type: disk
               disks:
                 - sdb
               fs_type: xfs
               mount_point: /mnt/data
               mount_user: somebody
               mount_group: somegroup
               mount_mode: 0755

   For details about all variables used in the playbook, see the /usr/share/ansible/roles/rhel-system-roles.storage/README.md file on the control node.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Manage local storage
     hosts: managed-node-01.example.com
     tasks:
       - name: Create logical volume
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.storage
         vars:
           storage_pools:
             - name: myvg
               disks:
                 - sda
                 - sdb
                 - sdc
               volumes:
                 - name: mylv
                   size: 2G
                   fs_type: ext4
                   mount_point: /mnt/data

   The settings specified in the example playbook include the following:

   size: <size>

   You must specify the size by using units (for example, GiB) or percentage (for example, 60%).

   For details about all variables used in the playbook, see the /usr/share/ansible/roles/rhel-system-roles.storage/README.md file on the control node.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Manage local storage
     hosts: managed-node-01.example.com
     tasks:
       - name: Enable online block discard
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.storage
         vars:
           storage_volumes:
             - name: barefs
               type: disk
               disks:
                 - sdb
               fs_type: xfs
               mount_point: /mnt/data
               mount_options: discard

   For details about all variables used in the playbook, see the /usr/share/ansible/roles/rhel-system-roles.storage/README.md file on the control node.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Manage local storage
     hosts: managed-node-01.example.com
     tasks:
       -name: Create and mount a file system
       ansible.builtin.include_role:
           name: redhat.rhel_system_roles.storage
       vars:
         storage_volumes:
           - name: barefs
             type: disk
             disks:
               - sdb
             fs_type: ext4
             fs_label: label-name
             mount_point: /mnt/data

   The setting specified in the example playbook include the following:

   disks: <list_of_devices>

   A YAML list of device names that the role uses when it creates the volume.

   fs_type: <file_system>

   Specifies the file system the role should set on the volume. You can select xfs, ext3, ext4, swap, or unformatted.

   label-name: <file_system_label>

   Optional: sets the label of the file system.

   mount_point: <directory>

   Optional: if the volume should be automatically mounted, set the mount_point variable to the directory to which the volume should be mounted.

   For details about all variables used in the playbook, see the /usr/share/ansible/roles/rhel-system-roles.storage/README.md file on the control node.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Manage local storage
     hosts: managed-node-01.example.com
     tasks:
       - name: Create a RAID on sdd, sde, sdf, and sdg
         ansible.builtin.include_role:
           name: redhat.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

   For details about all variables used in the playbook, see the /usr/share/ansible/roles/rhel-system-roles.storage/README.md file on the control node.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Manage local storage
     hosts: managed-node-01.example.com
     tasks:
       - name: Configure LVM pool with RAID
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.storage
         vars:
           storage_safe_mode: false
           storage_pools:
             - name: my_pool
               type: lvm
               disks: [sdh, sdi]
               raid_level: raid1
               volumes:
                 - name: my_volume
                   size: "1 GiB"
                   mount_point: "/mnt/app/shared"
                   fs_type: xfs
                   state: present

   For details about all variables used in the playbook, see the /usr/share/ansible/roles/rhel-system-roles.storage/README.md file on the control node.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Manage local storage
     hosts: managed-node-01.example.com
     tasks:
       - name: Configure stripe size for RAID LVM volumes
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.storage
         vars:
           storage_safe_mode: false
           storage_pools:
             - name: my_pool
               type: lvm
               disks: [sdh, sdi]
               volumes:
                 - name: my_volume
                   size: "1 GiB"
                   mount_point: "/mnt/app/shared"
                   fs_type: xfs
                   raid_level: raid0
                   raid_stripe_size: "256 KiB"
                   state: present

   For details about all variables used in the playbook, see the /usr/share/ansible/roles/rhel-system-roles.storage/README.md file on the control node.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Manage local storage
     hosts: managed-node-01.example.com
     tasks:
       - name: Create LVM-VDO volume under volume group 'myvg'
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.storage
         vars:
           storage_pools:
             - name: myvg
               disks:
                 - /dev/sdb
               volumes:
                 - name: mylv1
                   compression: true
                   deduplication: true
                   vdo_pool_size: 10 GiB
                   size: 30 GiB
                   mount_point: /mnt/app/shared

   The settings specified in the example playbook include the following:

   vdo_pool_size: <size>

   The actual size that the volume takes on the device. You can specify the size in human-readable format, such as 10 GiB. If you do not specify a unit, it defaults to bytes.

   size: <size>

   The virtual size of VDO volume.

   For details about all variables used in the playbook, see the /usr/share/ansible/roles/rhel-system-roles.storage/README.md file on the control node.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. Store your sensitive variables in an encrypted file:

   1. Create the vault:

      $ ansible-vault create ~/vault.yml
      New Vault password: <vault_password>
      Confirm New Vault password: <vault_password>

   2. After the ansible-vault create command opens an editor, enter the sensitive data in the <key>: <value> format:

      luks_password: <password>

   3. Save the changes, and close the editor. Ansible encrypts the data in the vault.

2. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Manage local storage
     hosts: managed-node-01.example.com
     vars_files:
       - ~/vault.yml
     tasks:
       - name: Create and configure a volume encrypted with LUKS
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.storage
         vars:
           storage_volumes:
             - name: barefs
               type: disk
               disks:
                 - sdb
               fs_type: xfs
               fs_label: <label>
               mount_point: /mnt/data
               encryption: true
               encryption_password: "{{ luks_password }}"

   For details about all variables used in the playbook, see the /usr/share/ansible/roles/rhel-system-roles.storage/README.md file on the control node.

3. Validate the playbook syntax:

   $ ansible-playbook --ask-vault-pass --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

4. Run the playbook:

   $ ansible-playbook --ask-vault-pass ~/playbook.yml

Verification

1. Find the luksUUID value of the LUKS encrypted volume:

   # ansible managed-node-01.example.com -m command -a 'cryptsetup luksUUID /dev/sdb'
   
   4e4e7970-1822-470e-b55a-e91efe5d0f5c

2. View the encryption status of the volume:

   # ansible managed-node-01.example.com -m command -a 'cryptsetup status luks-4e4e7970-1822-470e-b55a-e91efe5d0f5c'
   
   /dev/mapper/luks-4e4e7970-1822-470e-b55a-e91efe5d0f5c is active and is in use.
     type:    LUKS2
     cipher:  aes-xts-plain64
     keysize: 512 bits
     key location: keyring
     device:  /dev/sdb
   ...

3. Verify the created LUKS encrypted volume:

   # ansible managed-node-01.example.com -m command -a 'cryptsetup luksDump /dev/sdb'
   
   LUKS header information
   Version:        2
   Epoch:          3
   Metadata area:  16384 [bytes]
   Keyslots area:  16744448 [bytes]
   UUID:           4e4e7970-1822-470e-b55a-e91efe5d0f5c
   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]
   ...

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Manage local storage
     hosts: managed-node-01.example.com
     become: true
     tasks:
       - name: Create shared LVM device
         ansible.builtin.include_role:
           name: redhat.rhel_system_roles.storage
         vars:
           storage_pools:
             - name: vg1
               disks: /dev/vdb
               type: lvm
               shared: true
               state: present
               volumes:
                 - name: lv1
                   size: 4g
                   mount_point: /opt/test1
           storage_safe_mode: false
           storage_use_partitions: true

   For details about all variables used in the playbook, see the /usr/share/ansible/roles/rhel-system-roles.storage/README.md file on the control node.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml