The storage devices used for Swift are automatically detected when you deploy the Swift service to a storage node. To detect the disks, the disks must be partitioned with a fixed partition label. For performance reasons, it is recommended that you do not enable RAID on any of the storage devices.

To prepare the disks, create a GUID Partition Table (GPT) partition on each disk and label each partition with the same partition label. By default, the partition label is KOLLA_SWIFT_DATA (the label is configurable). For example, to create a partition on the /dev/sdb disk with the default partition label, use the following command:

# parted /dev/sdb -s -- mklabel gpt mkpart KOLLA_SWIFT_DATA 1 -1

After creating the partition, create an XFS file system in the partition. The following command creates an XFS file system in the /dev/sdb1 partition:

# mkfs.xfs -f /dev/sdb1

The following is an example script that partitions three disks and creates the XFS file systems:

#!/usr/bin/env bash
for d in sdb sdc sdd; do
    parted /dev/${d} -s -- mklabel gpt mkpart KOLLA_SWIFT_DATA 1 -1
    mkfs.xfs -f /dev/${d}1
done

The Swift storage devices are automatically mounted under /srv/node. Create this mount point manually on each storage node:

# mkdir -p /srv/node

If the mlocate package is installed on the storage nodes, it is recommended that you add /srv/node to the PRUNEPATHS entry in /etc/updatedb.conf to prevent updatedb from indexing directories below /srv/node.

More information about preparing disks and file systems for Swift, see the Swift Deployment Guide at http://docs.openstack.org/developer/swift/deployment_guide.html.

You need to create the Swift rings so that each storage node knows where to store the objects. The path to an object stored in Swift consists of an account (tenant or project), a container, and the object itself. Accounts and containers are the means by which objects are organized and replicated in the storage. Swift rings are databases, as follows:

Swift storage is organized into regions (for geographical separation), which contain zones (for availability, such as a building, a data center, or a server rack), which contain storage servers, and disks (inside or attached to the storage servers).

For more information about the Swift rings and how storage is organized, see the OpenStack Swift documentation:

Before you deploy Swift services, you build the initial Swift rings manually on the master node, using the swift-ring-builder utility. To avoid any issues with software versions, it is best to run the swift-ring-builder utility in a Docker container using the ol-openstack-swift-base image that is included with the Oracle OpenStack for Oracle Linux images. To do this:

For ease of management, it is recommended that you use a script to create the Swift rings. An example script is included in this section. The user that runs the script must be a member of the Docker group (so that they can run Docker commands). It is best that this user is also a member of the kolla group.

If you are using the Oracle Container Registry, you might need to sign in at https://container-registry.oracle.com before you can run the swift-ring-builder utility. After you accept the terms, you also need to register your login credentials for the Oracle Container Registry with Docker so that you can pull (download) images:

$ docker login -u user-name container-registry.oracle.com
Password:
Login Succeeded

The Swift rings are created as custom configuration files in the /etc/kolla/config/swift directory on the master node. When you deploy the Swift service, the rings are copied to the storage nodes. You have to manually create the /etc/kolla/config/swift directory on the master node:

# mkdir -p /etc/kolla/config/swift

The example script creates the following files:

You must use these file names in your own scripts.

#!/usr/bin/env bash

REGISTRY=registry_hostname:registry_port
NAMESPACE=namespace
TAG=openstack_release

STORAGE[1]=node_IP
STORAGE[2]=node_IP
STORAGE[3]=node_IP

# Create the object ring
docker run --rm \
  -v /etc/kolla/config/swift/:/etc/kolla/config/swift/ \
  ${REGISTRY}/${NAMESPACE}/ol-openstack-swift-base:${TAG} \
  swift-ring-builder /etc/kolla/config/swift/object.builder create 10 3 1

for NODE in 1 2 3; do
  echo "object.builder: Adding ${STORAGE[$NODE]} to zone z${NODE}"
  docker run --rm \
    -v /etc/kolla/config/swift/:/etc/kolla/config/swift/ \
    ${REGISTRY}/${NAMESPACE}/ol-openstack-swift-base:${TAG} swift-ring-builder \
    /etc/kolla/config/swift/object.builder add z${NODE}-${STORAGE[$NODE]}:6000/sdb1 1
done

# Create the account ring
docker run --rm \
  -v /etc/kolla/config/swift/:/etc/kolla/config/swift/ \
  ${REGISTRY}/${NAMESPACE}/ol-openstack-swift-base:${TAG} \
  swift-ring-builder /etc/kolla/config/swift/account.builder create 10 3 1

for NODE in 1 2 3; do
  echo "account.builder: Adding ${STORAGE[$NODE]} to zone z${NODE}"
  docker run --rm \
    -v /etc/kolla/config/swift/:/etc/kolla/config/swift/ \
    ${REGISTRY}/oracle/ol-openstack-swift-base:${TAG} swift-ring-builder \
    /etc/kolla/config/swift/account.builder add z${NODE}-${STORAGE[$NODE]}:6001/sdb1 1
done

# Create the container ring
docker run --rm \
  -v /etc/kolla/config/swift/:/etc/kolla/config/swift/ \
  ${REGISTRY}/${NAMESPACE}/ol-openstack-swift-base:${TAG} \
  swift-ring-builder /etc/kolla/config/swift/container.builder create 10 3 1

for NODE in 1 2 3; do
  echo "container.builder: Adding ${STORAGE[$NODE]} to zone z${NODE}"
  docker run --rm \
    -v /etc/kolla/config/swift/:/etc/kolla/config/swift/ \
    ${REGISTRY}/${NAMESPACE}/ol-openstack-swift-base:${TAG} swift-ring-builder \
    /etc/kolla/config/swift/container.builder add z${NODE}-${STORAGE[$NODE]}:6002/sdb1 1
done

# Rebalance the rings
for ring in object account container; do
  docker run --rm \
    -v /etc/kolla/config/swift/:/etc/kolla/config/swift/ \
    ${REGISTRY}/${NAMESPACE}/ol-openstack-swift-base:${TAG} swift-ring-builder \
    /etc/kolla/config/swift/${ring}.builder rebalance
done

Perform the following steps on the master node.