Dell EMC VMAX iSCSI and FC drivers¶

Assumptions, Restrictions and Pre-Requisites¶

1. The host initiator IQN is required along with the credentials the host initiator will use to log into the storage array with. The same credentials should be used in a multi node system if connecting to the same array.

2. Enable one way CHAP authentication for the iscsi initiator on the storage array using SYMCLI. Template and example shown below. For the purpose of this setup, the credential/secret used would be my_username/my_password with iscsi initiator of iqn.1991-05.com.company.lcseb130

   # symaccess -sid <SymmID> -iscsi <iscsi> \
               {enable chap | disable chap | set chap} \
                -cred <Credential> -secret <Secret>
   
   # symaccess -sid 128 \
               -iscsi iqn.1991-05.com.company.lcseb130 \
               set chap -cred my_username -secret my_password
   

Settings and Configuration¶

1. Set the configuration in the VMAX backend group in cinder.conf using the following parameters and restart cinder.

   Configuration options	Value required for CHAP	Required for CHAP
   use_chap_auth	True	Yes
   chap_username	my_username	Yes
   chap_password	my_password	Yes

   [VMAX_ISCSI]
   volume_driver = cinder.volume.drivers.dell_emc.vmax.iscsi.VMAXISCSIDriver
   volume_backend_name = VMAX_ISCSI
   san_ip = 10.10.10.10
   san_login = my_u4v_username
   san_password = my_u4v_password
   vmax_srp = SRP_1
   vmax_array = 000123456789
   vmax_port_groups = [OS-ISCSI-PG]
   use_chap_auth = True
   chap_username = my_username
   chap_password = my_password
   

Usage¶

1. Using SYMCLI, enable CHAP authentication for a host initiator as described above, but do not set use_chap_auth, chap_username or chap_password in cinder.conf. Create a bootable volume.

   openstack volume create --size 1 \
                           --image <image_name> \
                           --type <volume_type> \
                           test
   

2. Boot instance named test_server using the volume created above:

   openstack server create --volume test \
                           --flavor m1.small \
                           --nic net-id=private \
                           test_server
   

3. Verify the volume operation succeeds but the boot instance fails as CHAP authentication fails.

4. Update the cinder.conf with use_chap_auth set to true and chap_username and chap_password set with the correct credentials.

5. Rerun openstack server create

6. Verify that the boot instance operation ran correctly and the volume is accessible.

7. Verify that both the volume and boot instance operations ran successfully and the user is able to access the volume.

USE CASE 1 - Default values¶

Prerequisites - VMAX

• Host I/O Limit (MB/Sec) - No Limit
• Host I/O Limit (IO/Sec) - No Limit
• Set Dynamic Distribution - N/A

1. Create QoS Specs with the prerequisite values above:

   $ openstack volume qos create --consumer back-end \
                                 --property total_iops_sec=500 \
                                 --property total_bytes_sec=104857600 \
                                 --property DistributionType=Always \
                                 my_qos
   

2. Associate QoS specs with specified volume type:

   $ openstack volume qos associate my_qos my_volume_type
   

3. Create volume with the volume type indicated above:

   $ openstack volume create --size 1 --type my_volume_type my_volume
   

Outcome - VMAX (storage group)

• Host I/O Limit (MB/Sec) - 100
• Host I/O Limit (IO/Sec) - 500
• Set Dynamic Distribution - Always

Outcome - Block Storage (Cinder)

Volume is created against volume type and QoS is enforced with the parameters above.

USE CASE 2 - Preset limits¶

Prerequisites - VMAX

• Host I/O Limit (MB/Sec) - 2000
• Host I/O Limit (IO/Sec) - 2000
• Set Dynamic Distribution - Never

1. Create QoS specifications with the prerequisite values above. The consumer in this case use case is both for front end and back end:

   $ openstack volume qos create --consumer back-end \
                                 --property total_iops_sec=500 \
                                 --property total_bytes_sec=104857600 \
                                 --property DistributionType=Always \
                                 my_qos
   

2. Associate QoS specifications with specified volume type:

   $ openstack volume qos associate my_qos my_volume_type
   

3. Create volume with the volume type indicated above:

   $ openstack volume create --size 1 --type my_volume_type my_volume
   

4. Attach the volume created in step 3 to an instance

   $ openstack server add volume my_volume my_instance
   

Outcome - VMAX (storage group)

• Host I/O Limit (MB/Sec) - 100
• Host I/O Limit (IO/Sec) - 500
• Set Dynamic Distribution - Always

Outcome - Block Storage (Cinder)

Volume is created against volume type and QoS is enforced with the parameters above.

Outcome - Hypervisor (Nova)

Libvirt includes an extra xml flag within the <disk> section called iotune that is responsible for rate limitation. To confirm that, first get the OS-EXT-SRV-ATTR:instance_name value of the server instance i.e. instance-00000003.

$ openstack server show <serverid>

+-------------------------------------+-----------------------------------------------------------------+
| Field                               | Value                                                           |
+-------------------------------------+-----------------------------------------------------------------+
| OS-DCF:diskConfig                   | AUTO                                                            |
| OS-EXT-AZ:availability_zone         | nova                                                            |
| OS-EXT-SRV-ATTR:host                | myhost                                                          |
| OS-EXT-SRV-ATTR:hypervisor_hostname | myhost                                                          |
| OS-EXT-SRV-ATTR:instance_name       | instance-00000003                                               |
| OS-EXT-STS:power_state              | Running                                                         |
| OS-EXT-STS:task_state               | None                                                            |
| OS-EXT-STS:vm_state                 | active                                                          |
| OS-SRV-USG:launched_at              | 2017-11-02T08:15:42.000000                                      |
| OS-SRV-USG:terminated_at            | None                                                            |
| accessIPv4                          |                                                                 |
| accessIPv6                          |                                                                 |
| addresses                           | private=fd21:99c2:73f3:0:f816:3eff:febe:30ed, 10.0.0.3          |
| config_drive                        |                                                                 |
| created                             | 2017-11-02T08:15:34Z                                            |
| flavor                              | m1.tiny (1)                                                     |
| hostId                              | e7b8312581f9fbb8508587d45c0b6fb4dc86102c632ed1f3a6a49d42        |
| id                                  | 0ef0ff4c-dbda-4dc7-b8ed-45d2fc2f31db                            |
| image                               | cirros-0.3.5-x86_64-disk (b7c220f5-2408-4296-9e58-fc5a41cb7e9d) |
| key_name                            | myhostname                                                      |
| name                                | myhosthame                                                      |
| progress                            | 0                                                               |
| project_id                          | bae4b97a0d8b42c28a5add483981e5db                                |
| properties                          |                                                                 |
| security_groups                     | name='default'                                                  |
| status                              | ACTIVE                                                          |
| updated                             | 2017-11-02T08:15:42Z                                            |
| user_id                             | 7bccf456740546799a7e20457f13c38b                                |
| volumes_attached                    |                                                                 |
+-------------------------------------+-----------------------------------------------------------------+

We then run the following command using the OS-EXT-SRV-ATTR:instance_name retrieved above.

$ virsh dumpxml instance-00000003 | grep -1 "total_bytes_sec\|total_iops_sec"

The output of the command contains the xml below. It is found between the <disk> start and end tag.

<iotune>
   <total_bytes_sec>104857600</total_bytes_sec>
   <total_iops_sec>500</total_iops_sec>
</iotune>

USE CASE 3 - Preset limits¶

Prerequisites - VMAX

• Host I/O Limit (MB/Sec) - 100
• Host I/O Limit (IO/Sec) - 500
• Set Dynamic Distribution - Always

1. Create QoS specifications with the prerequisite values above:

   $ openstack volume qos create --consumer back-end \
                                 --property total_iops_sec=500 \
                                 --property total_bytes_sec=104857600 \
                                 --property DistributionType=Always \
                                 my_qos
   

2. Associate QoS specifications with specified volume type:

   $ openstack volume qos associate my_qos my_volume
   

3. Create volume with the volume type indicated above:

   $ openstack volume create --size 1 --type my_volume_type my_volume
   

Outcome - VMAX (storage group)

• Host I/O Limit (MB/Sec) - 100
• Host I/O Limit (IO/Sec) - 500
• Set Dynamic Distribution - OnFailure

Outcome - Block Storage (Cinder)

Volume is created against volume type and QOS is enforced with the parameters above

USE CASE 4 - Default values¶

Prerequisites - VMAX

• Host I/O Limit (MB/Sec) - No Limit
• Host I/O Limit (IO/Sec) - No Limit
• Set Dynamic Distribution - N/A

1. Create QoS specifications with the prerequisite values above:

   $ openstack volume qos create --consumer back-end \
                                 --property DistributionType=Always \
                                 my_qos
   

2. Associate QoS specifications with specified volume type:

   $ openstack volume qos associate my_qos my_volume_type
   

3. Create volume with the volume type indicated above:

   $ openstack volume create --size 1 --type my_volume_type my_volume
   

Outcome - VMAX (storage group)

• Host I/O Limit (MB/Sec) - No Limit
• Host I/O Limit (IO/Sec) - No Limit
• Set Dynamic Distribution - N/A

Outcome - Block Storage (Cinder)

Volume is created against volume type and there is no QoS change.

Multipath configuration file¶

The multipath configuration file may be edited for better management and performance. Log in as a privileged user and make the following changes to /etc/multipath.conf on the Compute (Nova) node(s).

devices {
# Device attributed for EMC VMAX
    device {
            vendor "EMC"
            product "SYMMETRIX"
            path_grouping_policy multibus
            getuid_callout "/lib/udev/scsi_id --page=pre-spc3-83 --whitelisted --device=/dev/%n"
            path_selector "round-robin 0"
            path_checker tur
            features "0"
            hardware_handler "0"
            prio const
            rr_weight uniform
            no_path_retry 6
            rr_min_io 1000
            rr_min_io_rq 1
    }
}

You may need to reboot the host after installing the MPIO tools or restart iSCSI and multipath services.

On Ubuntu:

# service open-iscsi restart
# service multipath-tools restart

On openSUSE, SUSE Linux Enterprise Server, Red Hat Enterprise Linux, and CentOS:

# systemctl restart open-iscsi
# systemctl restart multipath-tools

$ lsblk
NAME                                       MAJ:MIN RM   SIZE RO TYPE  MOUNTPOINT
sda                                          8:0    0     1G  0 disk
..360000970000196701868533030303235 (dm-6) 252:6    0     1G  0 mpath
sdb                                          8:16   0     1G  0 disk
..360000970000196701868533030303235 (dm-6) 252:6    0     1G  0 mpath
vda                                        253:0    0     1T  0 disk

OpenStack configurations¶

On Compute (Nova) node, add the following flag in the [libvirt] section of /etc/nova/nova.conf and /etc/nova/nova-cpu.conf:

volume_use_multipath = True

On Cinder controller node, iSCSI MPIO can be set globally in the [DEFAULT] section or set individually in the VMAX backend stanza in /etc/cinder/cinder.conf:

use_multipath_for_image_xfer = True

Restart nova-compute and cinder-volume services after the change.

Verify you have multiple initiators available on the compute node for I/O¶

1. Create a 3GB VMAX volume.

2. Create an instance from image out of native LVM storage or from VMAX storage, for example, from a bootable volume

3. Attach the 3GB volume to the new instance:

   # multipath -ll
   mpath102 (360000970000196700531533030383039) dm-3 EMC,SYMMETRIX
   size=3G features='1 queue_if_no_path' hwhandler='0' wp=rw
   '-+- policy='round-robin 0' prio=1 status=active
   33:0:0:1 sdb 8:16 active ready running
   '- 34:0:0:1 sdc 8:32 active ready running
   

4. Use the lsblk command to see the multipath device:

   # lsblk
   NAME                                       MAJ:MIN RM   SIZE RO TYPE  MOUNTPOINT
   sdb                                          8:0    0     3G  0 disk
   ..360000970000196700531533030383039 (dm-6) 252:6    0     3G  0 mpath
   sdc                                          8:16   0     3G  0 disk
   ..360000970000196700531533030383039 (dm-6) 252:6    0     3G  0 mpath
   vda
   

Use case 1 - Compression disabled create, attach, detach, and delete volume¶

1. Create a new volume type called VMAX_COMPRESSION_DISABLED.
2. Set an extra spec volume_backend_name.
3. Set a new extra spec storagetype:disablecompression = True.
4. Create a new volume.
5. Check in Unisphere or symcli to see if the volume exists in storage group OS-<srp>-<servicelevel>-<workload>-CD-SG, and compression is disabled on that storage group.
6. Attach the volume to an instance. Check in Unisphere or symcli to see if the volume exists in storage group OS-<shorthostname>-<srp>-<servicelevel/workload>-<portgroup>-CD, and compression is disabled on that storage group.
7. Detach volume from instance. Check in Unisphere or symcli to see if the volume exists in storage group OS-<srp>-<servicelevel>-<workload>-CD-SG, and compression is disabled on that storage group.
8. Delete the volume. If this was the last volume in the OS-<srp>-<servicelevel>-<workload>-CD-SG storage group, it should also be deleted.

Use case 2 - Retype from compression disabled to compression enabled¶

1. Repeat steps 1-4 of Use case 1.
2. Create a new volume type. For example VMAX_COMPRESSION_ENABLED.
3. Set extra spec volume_backend_name as before.
4. Set the new extra spec’s compression as storagetype:disablecompression = False or DO NOT set this extra spec.
5. Retype from volume type VMAX_COMPRESSION_DISABLED to VMAX_COMPRESSION_ENABLED.
6. Check in Unisphere or symcli to see if the volume exists in storage group OS-<srp>-<servicelevel>-<workload>-SG, and compression is enabled on that storage group.

Architecture¶

In VMAX, A volume cannot belong to two or more FAST storage groups at the same time. To get around this limitation we leverage both cascaded storage groups and a temporary non FAST storage group.

A volume can remain ‘live’ if moved between masking views that have the same initiator group and port groups which preserves the host path.

During live migration, the following steps are performed by the VMAX plugin on the volume:

1. Within the originating masking view, the volume is moved from the FAST storage group to the non-FAST storage group within the parent storage group.
2. The volume is added to the FAST storage group within the destination parent storage group of the destination masking view. At this point the volume belongs to two storage groups.
3. One of two things happens:
   • If the connection to the destination instance is successful, the volume is removed from the non-FAST storage group in the originating masking view, deleting the storage group if it contains no other volumes.
   • If the connection to the destination instance fails, the volume is removed from the destination storage group, deleting the storage group, if empty. The volume is reverted back to the original storage group.

Live migration configuration¶

Please refer to the following for more information:

https://docs.openstack.org/nova/latest/admin/live-migration-usage.html

and

https://docs.openstack.org/nova/latest/admin/configuring-migrations.html

System configuration¶

NOVA-INST-DIR/instances/ (for example, /opt/stack/data/nova/instances) has to be mounted by shared storage. Ensure that NOVA-INST-DIR (set with state_path in the nova.conf file) is the same on all hosts.

1. Configure your DNS or /etc/hosts and ensure it is consistent across all hosts. Make sure that the three hosts can perform name resolution with each other. As a test, use the ping command to ping each host from one another.

   $ ping HostA
   $ ping HostB
   $ ping HostC
   

2. Export NOVA-INST-DIR/instances from HostA, and ensure it is readable and writable by the Compute user on HostB and HostC. Please refer to the relevant OS documentation for further details. e.g. https://help.ubuntu.com/lts/serverguide/network-file-system.html

3. On all compute nodes, enable the ‘execute/search’ bit on your shared directory to allow qemu to be able to use the images within the directories. On all hosts, run the following command:

   $ chmod o+x NOVA-INST-DIR/instances
   

Use case¶

For our use case shown below, we have three hosts with host names HostA, HostB and HostC. HostA is the compute node while HostB and HostC are the compute nodes. The following were also used in live migration.

• 2 gb bootable volume using the cirros image.
• Instance created using the 2gb volume above with a flavor m1.small using 2048 RAM, 20GB of Disk and 1 VCPU.

1. Create a bootable volume.

   $ openstack volume create --size 2 \
                             --image cirros-0.3.5-x86_64-disk \
                             --volume_lm_1
   

2. Launch an instance using the volume created above on HostB.

   $ openstack server create --volume volume_lm_1 \
                             --flavor m1.small \
                             --nic net-id=private \
                             --security-group default \
                             --availability-zone nova:HostB \
                             server_lm_1
   

3. Confirm on HostB has the instance created by running:

   $ openstack server show server_lm_1 | grep "hypervisor_hostname\|instance_name"
     | OS-EXT-SRV-ATTR:hypervisor_hostname | HostB
     | OS-EXT-SRV-ATTR:instance_name | instance-00000006
   

4. Confirm, through virsh using the instance_name returned in step 3 (instance-00000006), on HostB that the instance is created using:

   $ virsh list --all
   
   Id   Name                  State
   --------------------------------
   1    instance-00000006     Running
   

5. Migrate the instance from HostB to HostA with:

   $ openstack server migrate --live HostA \
                              server_lm_1
   

6. Run the command on step 3 above when the instance is back in available status. The hypervisor should be on Host A.

7. Run the command on Step 4 on Host A to confirm that the instance is created through virsh.

Multi-attach Architecture¶

In VMAX, a volume cannot belong to two or more FAST storage groups at the same time. This can cause issues when we are attaching a volume to multiple instances on different hosts. To get around this limitation, we leverage both cascaded storage groups and non-FAST storage groups (i.e. a storage group with no service level, workload, or SRP specified).

Example Use Case¶

Volume Multi-attach-Vol-1 (with a multi-attach capable volume type, and associated with a Diamond Service Level) is attached to Instance Multi-attach-Instance-A on HostA. We then issue the command to attach Multi-attach-Vol-1 to Multi-attach-Instance-B on HostB:

1. In the HostA masking view, the volume is moved from the FAST managed storage group to the non-FAST managed storage group within the parent storage group.
2. The volume is attached as normal on Host B – i.e., it is added to a FAST managed storage group within the parent storage group of the HostB masking view. The volume now belongs to two masking views, and is exposed to both HostA and HostB.

We then decide to detach the volume from ‘Multi-attach-Instance-B’ on HostB:

1. The volume is detached as normal from Host B – i.e., it is removed from the FAST managed storage group within the parent storage group of the HostB masking view – this includes cleanup of the associated elements if required. The volume now belongs to one masking view, and is no longer exposed to HostB.
2. In the HostA masking view, the volume is returned to the FAST managed storage group from the non-FAST managed storage group within the parent storage group. The non-FAST managed storage group is cleaned up, if required.

Configure the source and target arrays¶

1. Configure an SRDF group between the chosen source and target arrays for the VMAX Cinder driver to use. The source array must correspond with the ‘vmax_array’ entry in the cinder.conf.

2. Select both the director and the ports for the SRDF emulation to use on both sides. Bear in mind that network topology is important when choosing director endpoints. Supported modes are Synchronous, Asynchronous, and Metro.

   Note

   If the source and target arrays are not managed by the same Unisphere server (that is, the target array is remotely connected to server - for example, if you are using embedded management), in the event of a full disaster scenario (i.e. the primary array is completely lost and all connectivity to it is gone), the Unisphere server would no longer be able to contact the target array. In this scenario, the volumes would be automatically failed over to the target array, but administrator intervention would be required to either; configure the target (remote) array as local to the current Unisphere server (if it is a stand-alone server), or enter the details of a second Unisphere server to the cinder.conf, which is locally connected to the target array (for example, the embedded management Unisphere server of the target array), and restart the Cinder volume service.

   Note

   If you are setting up an SRDF/Metro configuration, it is recommended that you configure a Witness or vWitness for bias management. Please see https://www.emc.com/collateral/technical-documentation/h14556-vmax3-srdf-metro-overview-and-best-practices-tech-note.pdf

3. Enable replication in /etc/cinder/cinder.conf. To enable the replication functionality in VMAX Cinder driver, it is necessary to create a replication volume-type. The corresponding back-end stanza in the cinder.conf for this volume-type must then include a replication_device parameter. This parameter defines a single replication target array and takes the form of a list of key value pairs.

   enabled_backends = VMAX_FC_REPLICATION
   [VMAX_FC_REPLICATION]
   volume_driver = cinder.volume.drivers.dell_emc.vmax_fc.VMAXFCDriver
   san_ip = 10.10.10.10
   san_login = my_u4v_username
   san_password = my_u4v_password
   vmax_srp = SRP_1
   vmax_array = 000123456789
   vmax_port_groups = [OS-FC-PG]
   volume_backend_name = VMAX_FC_REPLICATION
   replication_device = target_device_id:000197811111,
                        remote_port_group:os-failover-pg,
                        remote_pool:SRP_1,
                        rdf_group_label: 28_11_07,
                        allow_extend:False,
                        mode:Metro,
                        metro_use_bias:False,
                        allow_delete_metro:False
   
   .. note::
   
      ``replication_device`` key value pairs will need to be on the same line
      (separated by commas) in cinder.conf.  They are displayed on separated lines
      above for readiblity.
   

   • target_device_id is a unique VMAX array serial number of the target array. For full failover functionality, the source and target VMAX arrays must be discovered and managed by the same U4V server.

   • remote_port_group is the name of a VMAX port group that has been pre-configured to expose volumes managed by this backend in the event of a failover. Make sure that this portgroup contains either all FC or all iSCSI port groups (for a given back end), as appropriate for the configured driver (iSCSI or FC).

   • remote_pool is the unique pool name for the given target array.

   • rdf_group_label is the name of a VMAX SRDF group that has been pre-configured between the source and target arrays.

   • allow_extend is a flag for allowing the extension of replicated volumes. To extend a volume in an SRDF relationship, this relationship must first be broken, both the source and target volumes are then independently extended, and then the replication relationship is re-established. If not explicitly set, this flag defaults to False.

     Note

     As the SRDF link must be severed, due caution should be exercised when performing this operation. If absolutely necessary, only one source and target pair should be extended at a time.

     Note

     It is not currently possible to extend SRDF/Metro protected volumes.

   • mode is the required replication mode. Options are ‘Synchronous’, ‘Asynchronous’, and ‘Metro’. This defaults to ‘Synchronous’.

   • metro_use_bias is a flag to indicate if ‘bias’ protection should be used instead of Witness. This defaults to False.

   • allow_delete_metro is a flag to indicate if metro devices can be deleted. All Metro devices in an RDF group need to be managed together, so in order to delete one of the pairings, the whole group needs to be first suspended. Because of this, we require this flag to be explicitly set. This flag defaults to False.

   Note

   Service Level and Workload: An attempt will be made to create a storage group on the target array with the same service level and workload combination as the primary. However, if this combination is unavailable on the target (for example, in a situation where the source array is a Hybrid, the target array is an All Flash, and an All Flash incompatible service level like Bronze is configured), no service level will be applied.

   Note

   The VMAX Cinder drivers can support a single replication target per back-end, that is we do not support Concurrent SRDF or Cascaded SRDF. Ensure there is only a single replication_device entry per back-end stanza.

4. Create a replication-enabled volume type. Once the replication_device parameter has been entered in the VMAX backend entry in the cinder.conf, a corresponding volume type needs to be created replication_enabled property set. See above Setup VMAX drivers for details.

   # openstack volume type set --property replication_enabled="<is> True" \
                         VMAX_FC_REPLICATION
   

Volume replication interoperability with other features¶

Most features are supported, except for the following:

• Replication Group operations are available for volumes in Synchronous mode only.

• Storage-assisted retype operations on replication-enabled VMAX volumes (moving from a non-replicated type to a replicated-type and vice-versa. Moving to another service level/workload combination, for example) are not supported.

• It is not currently possible to extend SRDF/Metro protected volumes. If a bigger volume size is required for a SRDF/Metro protected volume, this can be achieved by cloning the original volume and choosing a larger size for the new cloned volume.

• The image volume cache functionality is supported (enabled by setting image_volume_cache_enabled = True), but one of two actions must be taken when creating the cached volume:

  • The first boot volume created on a backend (which will trigger the cached volume to be created) should be the smallest necessary size. For example, if the minimum size disk to hold an image is 5GB, create the first boot volume as 5GB.
  • Alternatively, ensure that the allow_extend option in the replication_device parameter is set to True (Please note that it is not possible to extend SRDF/Metro protected volumes).

  This is because the initial boot volume is created at the minimum required size for the requested image, and then extended to the user specified size.

Failover host¶

In the event of a disaster, or where there is required downtime, upgrade of the primary array for example, the administrator can issue the failover host command to failover to the configured target:

# cinder failover-host cinder_host@VMAX_FC_REPLICATION

If the primary array becomes available again, you can initiate a failback using the same command and specifying --backend_id default:

# cinder failover-host cinder_host@VMAX_FC_REPLICATION --backend_id default

Asynchronous and Metro replication management groups¶

Asynchronous and Metro volumes in an RDF session, i.e. belonging to an SRDF group, must be managed together for RDF operations (although there is a consistency exempt option for creating and deleting pairs in an Async group). To facilitate this management, we create an internal RDF management storage group on the backend. It is crucial for correct management that the volumes in this storage group directly correspond to the volumes in the RDF group. For this reason, it is imperative that the RDF group specified in the cinder.conf is for the exclusive use by this Cinder backend.

Metro support¶

SRDF/Metro is a High Availabilty solution. It works by masking both sides of the RDF relationship to the host, and presenting all paths to the host, appearing that they all point to the one device. In order to do this, there needs to be multipath software running to manage writing to the multiple paths.

Known issues¶

Consistent group snapshot¶

To create a consistent group snapshot, set a group-spec, having the key consistent_group_snapshot_enabled set to <is> True on the group.

cinder --os-volume-api-version 3.11 group-type-key GROUP_TYPE set consistent_group_snapshot_enabled="<is> True"

Similarly the same key should be set on any volume type which is specified while creating the group.

# openstack volume type set --property replication_enabled="<is> True" /
                        VMAX_REPLICATION

If this key is not set on the group-spec or volume type, then the generic volume group will be created/managed by Cinder (not the VMAX plugin).

Replication groups¶

As with Consistent group snapshot consistent_group_snapshot_enabled should be set to true on the group and the volume type for replication groups. Only Synchronous replication is supported for use with Replication Groups. When a volume is created into a replication group, replication is on by default. The disable_replication api suspends I/O traffic on the devices, but does NOT remove replication for the group. The enable_replication api resumes I/O traffic on the RDF links. The “failover_group” api allows a group to be failed over and back without failing over the entire host. See below for usage.

Storage Group Names¶

Storage groups are created on the VMAX as a result of creation of generic volume groups. These storage groups follow a different naming convention and are of the following format depending upon whether the groups have a name.

TruncatedGroupName_GroupUUID or GroupUUID

Group type operations¶

• Create a group type

cinder --os-volume-api-version 3.11 group-type-create GROUP_TYPE

• Show a group type

cinder --os-volume-api-version 3.11 group-type-show GROUP_TYPE

• List group types

cinder --os-volume-api-version 3.11 group-type-list

• Delete group type

cinder --os-volume-api-version 3.11 group-type-delete GROUP_TYPE

• Set/unset a group spec

cinder --os-volume-api-version 3.11 group-type-key GROUP_TYPE set consistent_group_snapshot_enabled="<is> True"

• List group types and group specs:

cinder --os-volume-api-version 3.11 group-specs-list

Group operations¶

• Create a group:

cinder --os-volume-api-version 3.13 group-create --name GROUP GROUP_TYPE VOLUME_TYPE1,VOLUME_TYPE2

• Show a group:

cinder --os-volume-api-version 3.13 group-show GROUP

• List all groups:

cinder --os-volume-api-version 3.13 group-list

• Create a volume and add it to a group at the time of creation:

cinder --os-volume-api-version 3.13 create --volume-type VOLUME_TYPE1 --group-id GROUP_ID 1

• Modify a group to add or remove volumes:

cinder --os-volume-api-version 3.13 group-update --add-volumes UUID1,UUID2 --remove-volumes UUID3,UUID4 GROUP

• Delete a group

cinder --os-volume-api-version 3.13 group-delete --delete-volumes GROUP

Group snapshot operations¶

• Create a group snapshot:

cinder --os-volume-api-version 3.14 group-snapshot-create --name GROUP_SNAPSHOT GROUP

• Delete group snapshot(s):

cinder --os-volume-api-version 3.14 group-snapshot-delete GROUP_SNAPSHOT

• Create a group from a group snapshot:

$ cinder --os-volume-api-version 3.14 group-create-from-src --group-snapshot GROUP_SNAPSHOT --name GROUP

• Create a group from a source snapshot:

$ cinder --os-volume-api-version 3.14 group-create-from-src --source-group SOURCE_GROUP --name GROUP

Group replication operations¶

• Enable group replication

cinder --os-volume-api-version 3.38 group-enable-replication GROUP

• Disable group replication

cinder --os-volume-api-version 3.38 group-disable-replication GROUP

• Failover group

cinder --os-volume-api-version 3.38 group-failover-replication GROUP

• Failback group

cinder --os-volume-api-version 3.38 group-failover-replication GROUP /
    --secondary-backend-id default

Manage Volumes¶

With your pool name defined you can now manage the volume into OpenStack, this is possible with the CLI command cinder manage. The bootable parameter is optional in the command, if the volume to be managed into OpenStack is not bootable leave this parameter out. OpenStack will also determine the size of the value when it is managed so there is no need to specify the volume size.

Command format:

$ cinder manage --name <new_volume_name> --volume-type <vmax_vol_type> \
  --availability-zone <av_zone> <--bootable> <host> <identifier>

Command Example:

$ cinder manage --name vmax_managed_volume --volume-type VMAX_ISCSI_DIAMOND \
  --availability-zone nova demo@VMAX_ISCSI_DIAMOND#Diamond+SRP_1+111111111111 031D8

After the above command has been run, the volume will be available for use in the same way as any other OpenStack VMAX volume.

Managing Volumes with Replication Enabled¶

Whilst it is not possible to manage volumes into OpenStack that are part of a SRDF relationship, it is possible to manage a volume into OpenStack and enable replication at the same time. This is done by having a replication enabled VMAX volume type (for more information see section Volume Replication) during the manage volume process you specify the replication volume type as the chosen volume type. Once managed, replication will be enabled for that volume.

Unmanage Volume¶

Unmanaging a volume is not the same as deleting a volume. When a volume is deleted from OpenStack, it is also deleted from the VMAX at the same time. Unmanaging a volume is the process whereby a volume is removed from OpenStack but it remains for further use on the VMAX. The volume can also be managed back into OpenStack at a later date using the process discussed in the previous section. Unmanaging volume is carried out using the Cinder unmanage CLI command:

Command format:

$ cinder unmanage <volume_name/volume_id>

Command example:

$ cinder unmanage vmax_test_vol

Once unmanaged from OpenStack, the volume can still be retrieved using its device ID or OpenStack volume ID. Within Unisphere you will also notice that the ‘OS-‘ prefix has been removed, this is another visual indication that the volume is no longer managed by OpenStack.

Manage SnapVX Snapshot¶

It is possible to manage VMAX SnapVX snapshots into OpenStack, where the source volume from which the snapshot is taken already exists in, and is managed by OpenStack Cinder. The source volume may have been created in OpenStack Cinder, or it may have been managed in to OpenStack Cinder also. With the support of managing SnapVX snapshots included in OpenStack Queens, the restriction around managing SnapVX source volumes has been removed.

Requirements/Restrictions:

1. The SnapVX source volume must be present in and managed by Cinder.
2. The SnapVX snapshot name must not begin with OS-.
3. The SnapVX snapshot source volume must not be in a failed-over state.
4. Managing a SnapVX snapshot will only be allowed if the snapshot has no linked target volumes.

Command Structure:

1. Identify your SnapVX snapshot for management on the VMAX, note the name.
2. Ensure the source volume is already managed into OpenStack Cinder, note the device ID.
3. Using the Cinder CLI, use the following command structure to manage a Snapshot into OpenStack Cinder:

$ cinder snapshot-manage --id-type source-name
                         [--name <name>]
                         [--description <description>]
                         [--metadata [<key=value> [<key=value> ...]]]
                         <volume name/id> <identifier>

Positional arguments:

• <volume name/id> - Source OpenStack volume name
• <identifier> - Name of existing snapshot on VMAX backend

Optional arguments:

• –name <name> - Snapshot name (Default=None)
• –description <description> - Snapshot description (Default=None)
• –metadata [<key=value> [<key=value> …]] Metadata key=value pairs (Default=None)

Example:

$ cinder snapshot-manage --name SnapshotManaged \
                         --description "Managed Queens Feb18" \
                         0021A VMAXSnapshot

Where:

• The name in OpenStack after managing the SnapVX snapshot will be SnapshotManaged.
• The snapshot will have the description Managed Queens Feb18.
• The source volume device ID is 0021A.
• The name of the SnapVX snapshot on the VMAX backend is VMAXSnapshot.

Outcome:

After the process of managing the Snapshot has completed, the SnapVX snapshot on the VMAX backend will be prefixed by the letters OS-, leaving the snapshot in this example named OS-VMAXSnapshot. The associated snapshot managed by Cinder will be present for use under the name SnapshotManaged.

Unmanage Cinder Snapshot¶

Unmanaging a snapshot in Cinder is the process whereby the snapshot is removed from and no longer managed by Cinder, but it still exists on the storage backend. Unmanaging a SnapVX snapshot in OpenStack Cinder follows this behaviour, whereby after unmanaging a VMAX SnapVX snapshot from Cinder, the snapshot is removed from OpenStack but is still present for use on the VMAX backend.

Requirements/Restrictions:

• The SnapVX source volume must not be in a failed over state.

Command Structure:

Identify the SnapVX snapshot you want to unmanage from OpenStack Cinder, note the snapshot name or ID as specified by Cinder. Using the Cinder CLI use the following command structure to unmanage the SnapVX snapshot from Cinder:

$ cinder snapshot-unmanage <snapshot>

Positional arguments:

• <snapshot> - Cinder snapshot name or ID.

Example:

$ cinder snapshot-unmanage SnapshotManaged

Where:

• The SnapVX snapshot name in OpenStack Cinder is SnapshotManaged.

After the process of unmanaging the SnapVX snapshot in Cinder, the snapshot on the VMAX backend will have the OS- prefix removed to indicate it is no longer OpenStack managed. In the example above, the snapshot after unmanaging from OpenStack will be named VMAXSnapshot on the storage backend.

Manageable volumes¶

Volumes that can be managed by and imported into Openstack.

List manageable volume is filtered by:

• Volume size should be 1026MB or greater (1GB VMAX Cinder Vol = 1026 MB)
• Volume size should be a whole integer GB capacity
• Volume should not be a part of masking view.
• Volume status should be Ready
• Volume service state should be Normal
• Volume emulation type should be FBA
• Volume configuration should be TDEV
• Volume should not be a system resource.
• Volume should not be private
• Volume should not be encapsulated
• Volume should not be reserved
• Volume should not be a part of an RDF session
• Volume should not be a snapVX Target
• Volume identifier should not begin with OS-.

Manageable snaphots¶

Snapshots that can be managed by and imported into Openstack

List manageable snapshots is filtered by:

• The source volume should be marked as SnapVX source.
• The source volume should be 1026MB or greater
• The source volume should be a whole integer GB capacity.
• The source volume emulation type should be FBA.
• The source volume configuration should be TDEV.
• The source volume should not be private.
• The source volume should be not be a system resource.
• The snapshot identifier should not start with OS- or temp-.
• The snapshot should not be expired.
• The snapshot generation number should npt be greater than 0.