Chapter 7. Object Storage

In the previous chapter, we looked at managing block storage with Cinder. Block storage attaches directly to the instances, and the operating system on the instance writes to the filesystem. Object storage is an alternative storage option. Object storage is a simple form of storage that handles file operations on the instances by way of API calls. This decouples the operating system and the file storage. Swift is the object storage component in OpenStack. In this chapter, we are going to take a deeper look at what object storage is, how to use it, and some options available to use as the backend storage engine.

Use case

Object storage works by using a client to send and receive files to and from the object store. The files are stored with very little metadata and are treated as a whole entity. The object server does not work in partial pieces of an object the way block storage would work with file blocks. It is a very simple storage method focused on storing and retrieving the contents of the files with minimal overhead to the operating system while interacting with the storage server. The power of the Swift object storage engine is its robust software-defined storage backend. The Swift storage engine has distribution and replication capabilities across its storage nodes. First, let's take a look at the client side of using Swift, and later, we will look at the backend storage engine.

Architecture of a Swift cluster

Swift has a proxy layer and a storage layer. These layers are associated with each other by way of the ring. The ring is a catalog of the objects that are being stored in the cluster and where they are being stored. This information is replicated to every storage node to improve the performance of the cluster. The proxy layer is a service that presents an API interface to end users and communicates with the storage layer on behalf of the end user. The storage layer is not generally communicated with directly.

By default, Swift uses the Swift storage engine for its storage backend. The Swift storage is a storage engine designed specifically for the Swift object storage cluster that is distributed in nature and able to be replicated. The Swift storage engine has a few subcomponents to it: the account server, the object server, and the container server.

Swift can also be backed by storage engines other than the Swift storage engine. There are a few other storage...

Creating and using object storage

The two main concepts when using Swift are containers and objects. Containers are groups of files that contain objects. Objects are simply files and must exist inside of a container. Make sure that your overcloudrc file is sourced, then create a container and upload a file to the container. Let's use the release file from the etc directory as an example file to upload:

undercloud# openstack container create my_container
undercloud# openstack object create my_container /etc/redhat-release
undercloud# openstack container list
undercloud# openstack object list my_container

Once the container and the object are created, they can be listed with the respective list command. Next, upload the same file, but change to the etc directory first and reference it by just its filename, as follows:

undercloud# cd /etc
undercloud# openstack object create my_container redhat-release
undercloud# openstack object list my_container

Note the difference in how the object gets...

Object file management in the web interface

Now, let's take a look at managing containers and objects in the web interface. Once you have logged in, open the Object Store menu and select the Containers submenu. Click on the Create Container button. The following screenshot captures this step:

Now you will be presented with the following screenshot:

Once you have a container created, you will have two buttons to choose from to create objects in the container, Create Pseudo Folder and Upload Object. Start with uploading an object, as shown in the following screenshot:

The file that was chosen was /etc/redhat-release again. The web interface prepopulates the object name field with the file name chosen but not its path. Click Upload Object to complete the object creation. These actions are illustrated in the following screenshot:

A directory-structure-like name could have been given to the object when it was uploaded. To offer assistance with using a convention that would mock a file system's directory...

Using object storage on an instance

Now that we have seen how to get files in and out of Swift, let's look at installing the necessary client libraries on an instance to be able to interact with object storage on the instance. We will need to have the Swift client libraries installed so that the OpenStack command-line client can be executed on an instance. In this cluster, Swift is using Keystone for authentication. Swift can also use other authentication. It has a built-in authentication system and can also be used with other common authentication systems. Since Swift is configured to use Keystone for authentication, the Keystone client will also need to be installed. Let's install those clients now:

instance# sudo yum install -y https://www.rdoproject.org/repos/rdo-release.rpm
instance# sudo dnf install -y python-openstackclient

There will be a quite a few dependent packages that yum will install. Once those are installed, you will need to create a keystonerc file to source. Create a file...

Ring files

Ring files are a kind of catalog of the files that are stored within the Swift storage engine and where within the storage cluster they are stored. As content is written to the Swift object storage cluster, these ring files are updated across the storage cluster and on the proxy server. When alternative storage backends are used in place of the Swift object storage engine, they mock the ring file system that the proxy expects and map this ring file system to its storage engine. Because the Swift proxy service always expects a set of ring files to operate, it is important to know how these are generated and installed. Learning how to set up ring files for the Swift object storage engine will teach you the basics that will translate into object storage backed by alternative storage engines.

There are various ring files that must all be generated and copied to each of the servers that will use the ring files. These include the account, container, and object rings. To generate these...

Summary

In this chapter, we looked at using the Swift object storage and how to generate the ring files that the Swift storage engine uses to manage its storage. Now that we have covered the storage components in OpenStack, let's take a look at the Telemetry component that OpenStack uses to measure the usage of resources across the cluster.