Getting started

The S1 storage engine is designed to manage storage space for various applications, including ESX servers, web servers, and databases. The purpose of this page is to get you started using the S1 engine for provisioning and managing storage. To provision storage on the S1 storage engine, follow this scheme:

Set up one or more storage pools by assigning physical drives to them.
Create an application instance, which acts as a namespace for volumes.
Create a volume within the application instance.
Use the volume for a file system, object, or block level storage.

Managing and creating pools

To add physical drives to a storage pool, you need to specify which drives you want to include. You can view a list of all available appliance resources, including physical drives, by using the following command:

resources list --resourceType=<resource-name> [--node=<node-name>] [--errors] [--details] [--sensors] [--ids=<numbers...>]

To list available physical drives, replace <resource-name> with HDD or SSD.

	resources list --resourceType SSD

Creating a pool

To use physical storage drive, you must first create a pool and include physical drives in it. This pool is then used to provide storage for a logical volume, rather than accessing the physical storage drive directly. To create a pool, use the command:

resources drives pools create --name=<name>

The <name> argument is mandatory and specifies the name of the pool. You need to replace <name> with a name of your choosing.

Approving drives to be used by a pool

To list all pools, you can use the command resources drives pools list. To see the full description of this command, see Listing pools.
To list all available drives, you can use the command resources drive list. For a full description, see Listing drives. The output of this command also includes the id number for each drive.

To approve drives for a pool, use the command:

resources drives approve (--driveIds=<numbers…>|--all) [--manualPool=<name> --force]

(--driveIds=<numbers…>|--all): Specifies which drives to approve. You can either specify drive id numbers using --driveIds=<numbers…> (separate drives with a comma or space), or you can use the --all option to approve all drives.
--manualPool=<name> Specifies the name of the pool for which drives should be approved.
[--manualPool=<name> --force]: Optional. The --force option prevents the system from asking for your approval.

Example:

To approve all drives in the list for a pool myp, run
```
resources drives approve --all ---manualPool myp
```
To approve specific drives for an existing pool:
1. To view all available pools, run the command resources drives pools list. For this example, the list includes a pool called myp1.
2. To view all available drives and their ID numbers, run the resources drives list. For this example, the list includes drives with ID numbers 2, 5, 8.
3. To approve drives with ID numbers 2 and 5 for the pool myp1, use the following command:
```
resources drives approve --ids 2 5 --manualPool myp1
```

The StorOne system allows you to add (approve) or remove (disapprove) drives from a pool. For a full description see the “resources pool” command.

Creating application instances

To create volumes or consistency groups, you must associate them with an application instance. An application instance is simply a namespace for consistency groups and their volumes. To create an application instance, use the command:

applications create --application=<name> [--template=<name>] [--description=<text>]

Example:

To create application instance sales, run:

applications create --application sales  --description "This namespace is for the sales department."

Creating new volumes and consistency groups

To create a new volume, use

applications volumes create --application=<app_name> --volume=<vol_name> --capacity=<capacity> --pools=<pname…> --n=<n> --k=<k>  [--groupedVolume=<name> | --cgid=<numbers> | (--encryptionKey=<encryptionKey> [--saveEncryptedRecoveryKey])]

This is a short version of the applications volumes create command, for a full description please refer to the Creating a logical volume.

Required:

--application=<app_name>: Specify an existing application instance name for the new volume.
--volume=<vol_name>: Specify a name for the newly created volume. You may replace <vol_name> with a any unique (within the application instance) name of your choice.
--capacity=<capacity>: Specify storage capacity for the newly created volume. Replace <capacity> with a number appended by capacity storage units (MB, GB, TB, etc.).
--pools=<pname…> Specify one or more pools, separated by spaces, where the volume should be hosted.
--n: Specify the number of data fragments for the logical volume. Replace <n> with the number of fragments; the value <n> must be in powers of two, namely 1,2,4,8,…
--k: Specify redundancy level, namely, the number of simultaneous drive failures that the logical volume can sustain before losing data. Replace <k> with a numerical value for the redundancy level.

Optional:

To specify an existing consistency group for a newly created volume, use one of the following options:

Option	Description
`--groupedVolume=<name>`	Use this option to add the volume to an existing consistency group.
`--cgid=<numbers>`	Use this option to specify the ID of the existing consistency group to which the volume should be added.

Note that when using one of these options, the system does not create a new consistency group for the volume. Instead, the volume is mapped to the consistency group that was specified.

If you do not map the volume to an existing consistency group, the system will create a new consistency group for the volume. In this case, you have the option to encrypt the new consistency group. Please note that encrypting the consistency group is a permanent operation. To encrypt the new consistency group, you must use the --encryptionKey option, the --saveEncryptedRecoveryKey is optional.
- --encryptionKey=<encryptionKey>: Specify an encryption key for the consistency group. Replace <encryptionKey> with an encryption password of your choice.
- --saveEncryptedRecoveryKey: This is an optional feature. StorOne gives you the option to store your volume encryption key securely with StorONE. This way, we can assist you in recovering a volume encryption key if necessary. When you use the --saveEncryptedRecoveryKey option, your encryption key will be encrypted using StorOne’s public key and stored in your S1 management relay station database.

Examples:

To create a volume videos on application instance training with a capacity of 500GB over a pool sales with n=16 data fragments and k=3 data redundancy, run:
```
applications volumes create --application training --volume videos  --capacity 500GB --pools sales --n=16 --k=3 
```
S1 creates a new consistency group for the newly created volume videos.
To create a volume with the same parameters as in example 1, but with an encrypted consistency group using the key pwd123, run the following command:
```
applications volumes create --application training --volume videos  --capacity 500GB --pools sales --n=16 --k=3 --encryptionKey
```
To create a volume named videos on the application instance training mapped to the consistency group BEST with a capacity of 500GB over the pools sales and HR, with n=16 data fragments and k=3 data redundancy, run the following command:
```
applications volumes create --application training --volume videos  --capacity 500GB --pools sales HR --n=16 --k=3 --groupedVolume BEST
```

What to do next:
After creating a volume, map it to a Storage Area Network (SAN) or add a filesystem to the volume.

Mapping a volume to a SAN

To map a logical volume to a storage area network (SAN) using the S1 system, you must first configure a hostname in the system by using the hosts create command. Once the hostname has been configured, use the following command to map the volume to the SAN.

applications mappings add --application=<app_name> [(--volumes=<vol_name…> --lunid=<lun_id…>)] --hosts=<name…>

Options:

--application=<app_name>: Specify the application instance of the volume. Replace <app_name> with an application instance.
--volumes=<vol_name…>: To select a list of volumes from the application instance to be mapped to hostnames. Replace <vol_name…> with a list of volumes. If you do not use this option, all volumes in the application instance are mapped to the hostnames.
--lunid=<lun_id…>: To list logical unit identifiers (LUNid) that correspond to the list of volumes. Replace <lun_id…> with a list of LUN identifiers, where each LUN identifier corresponds to a volume in the <vol_name…> list.
--hosts=<name…>: List hostnames for the mapped volumes. Replace <name…> with a list of hosts.

Examples:
To map volumes volume1 (LUN id 1) and volume2 (LUN id 2) on applications instance pack1 to hosts h1 h2 h3, run:

applications mapped add --application pack1 --volumes volume1 volume2 --lunid 1 2 --hosts h1 h2 h3

Adding a filesystem

In order to access the files stored on a logical volume, the volume must have a filesystem. Without a filesystem, the operating system is not able to recognize the volume and cannot access the contents.
To add a filesystem to a logical volume, use the command

applications filesystems add --application=<name> --volumes=<name…>

This is a shortened version of the command. For more detailed information, refer to Adding filesystems.

Required:

--application=<name>: Specify the name of the application instance containing the volumes that you want to create a file system from. Replace <name> with the name of the app instance.
--volumes=<name…>: Specify the name of the volumes that you want to create a filesystems from. Replace <name…> with a list of existing volumes. Each volume has only one filesystem. If you list n volumes, the command creates n different filesystems.

Examples:
To create a filesystem on volumes v1, v2, v3 that are mapped to application instance HR, run

applications filesystems add --application HR --volumes v1 v2 v3

Creating an object

Creating an Object-based filesystem requires the following:

Logical volume with a filesystem. Use the applications filesystem add command to add a filesystem to the volume.
Create at least one floating IP.
Obtain at least one access key.

To create an object-based filesystem, use the command

applications objects stores create --application=<app_name> --volume=<vol_name> --floatingIp=<name> --port=<port> --accessKeys=<text…> [--enableUseSsl]

Options:

--application=<app_name>: Specify the app instance of the volume. Replace <app_name> with the name of the application instance.
--volume=<vol_name>: Specify the volume where the object file system is to be created. Replace <vol_name> with the name of the volume.
--floatingIp=<name>: Specify the floating IP which will be used for this object. Replace <name> with the floating IP name.
--port=<port>: Specify the TCP port for the object-based filesystem.
--accessKeys=<text…> Specify the access keys to grant users permission to access the object-based filesystem. Replace <text…> with a list of access keys.
--enableUseSsl To enable communication through a secure socket layer (SSL).

Creating a share on a NAS

Creating a share requires a Network Attached Server (NAS). Please note:

The volume that you want to share must have a filesystem.
A volume cannot have two different shares on the same path.

Any directory path of a volume can be shared through the network file system (NFS) protocol or server message block (SMB) protocol. To share a volume directory path, use the command:

applications shares add --application=<app_inst> --volume=<vol_name> --share=<name> (--smb | --nfs) [-- path=<path>] [--browsable] [--allowedsubnets=<subnets>] [--readonlyaccess]

Options:

--application=<app_inst>: Specify the name of the app instance. Replace <app_inst> with the application instance of the volume.
--volume=<vol_name>: Specify the name of the volume to which you want to add the share. Replace <vol_name> with the name of the volume.
--share=<name>: Specify a name for the share. Replace <name> with a name of your choice.
--smb: Use the server message block (SMB) protocol to share the directory path.
or
--nfs: Use the network file system (NFS) protocol to share the directory path.
- --path=<path>: To specify the directory path (in the volume) you want to share. If you don’t specify a path, the root directory becomes the share directory path.
--browsable: To enable directory browsing; relevant only when using SMB protocol. Allow clients to browse the share directory path.
--allowedsubnets=<subnets>: To limit access. Only specified IP addresses can access the share. Replace <subnet> with a list of IP/mask addresses separated by semi-colon. For example, to allow access to the share from IP addresses 192.168.20.x and IP addresses 10.1.x.x, set --allowedsubnets 192.168.20.0/255.255.255.0;10.1.0.0/255.25.0.0. The --allowedsubnets option is optional. Notice: if the list is empty or it contains a wildcard, any IP can gain access to the shared directory path.
--readonlyaccess To limit access to the shared directory path, clients can be granted read-only permission by using the --readonlyaccess option. If this option is not specified, all clients will have read and write permission.

Examples:

To add an SMB share netStar with the following parameters
- Application instance: sales
- Volume name: interSales
- Path on volume sales: \usr\intS
- Make the share browsable run:
```
applications shares add --application sales --volume interSales --share netStar --smb --path \usr\intS --browsable
```
To add an NFS share and name MM with the following parameters
- Application instance: research
- Volume name: figures
- Path on volume sales: /home/R-team/Documents/results
  - Only IP addresses 10.0.0.x and 192.168.x.x allowed. (where x can be any number between 0-255).
- Clients granted read-only permission. run:
```
applications shares add --application research --volume figures --share MM --nfs --path /home/R-team/Documents/results --allowsubnets 10.0.0.0/255.255.255.0;192.168.0.0/255.255.0.0
```

Last updated on 27 Dec 2022
Published on 27 Dec 2022