These are the steps required to set up a Redis Enterprise Software Cluster with OpenShift.


  1. An OpenShift cluster installed (3.x or 4.x) with at least three nodes (each meeting the minimum requirements for a development installation
  2. The kubectl package installed at version 1.9 or higher
  3. The OpenShift cli installed

Step 1: Login

  1. Log in to your OpenShift account as a super admin so that you have access to all the default projects.

  2. Create a new project, fill in the name and other details for the project, and click Create.


  3. Click on admin (upper right corner) and then Copy Login.


  4. Paste the login command into your shell, for example:

    oc login –token=your$login$token
  5. To verify that you are using the newly created project, run:

    oc project <your project name>

This shifts to your project rather than the default project. You can confirm that you are in the correct project with oc project.

Step 2: Get deployment files

Clone Kubernetes docs repository to get the deployment files:

git clone

Specifically for the custom resource (cr) yaml file, you can also download and edit one of the files in the example folder.

Step 3: Prepare your yaml files

Let’s look at each yaml file to see what requires editing:

  • scc.yaml

    The scc (Security Context Constraint) yaml defines security context constraints for the cluster for our project. We strongly recommend that you not change anything in this yaml file.

    1. Apply the file:

      oc apply -f scc.yaml

      You should receive the following response: “redis-enterprise-scc” configured
    2. To bind the scc to your project, run:

      oc adm policy add-scc-to-group redis-enterprise-scc  system:serviceaccounts:your_project_name

      You can see the name of your project with oc project.

  • openshift.bundle.yaml -

    The bundle file includes several declarations:

    • rbac (Role-Based Access Control) defines who can access which resources. The Operator application requires these definitions to deploy and manage the entire Redis Enterprise deployment (all cluster resources within a namespace). These include declaration of rules, role and rolebinding.
    • crd declaration creates a CustomResourceDefinition for your Redis Enterprise Cluster resource. This provides another API resource that the k8s API server can use and the operator can manage in other deployments.
    • operator deployment declaration creates the operator deployment that is responsible for managing the k8s deployment and lifecycle of a Redis Enterprise Cluster. Among many other responsibilities, it creates a stateful set that runs the Redis Enterprise nodes as pods. The yaml contains the latest image tag representing the latest Operator version available.
    Warning -
    Changes to this file can cause unexpected results.
    1. Apply the yaml file with:

      kubectl apply -f openshift.bundle.yaml

      The command returns a confirmation response such as: created
      serviceaccount/redis-enterprise-operator created created configured
      deployment.apps/redis-enterprise-operator created
    2. To verify that your redis-enterprise-operator deployment is running, run:

      kubectl get deployment -l name=redis-enterprise-operator

      A typical response will look like this:

      NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
      redis-enterprise-operator   1/1     1            1           0m36s
  • sb_rbac.yaml

    If you deploy a service broker, also apply the sb_rbac.yaml file. The sb_rbac (Service Broker Role-Based Access Control) yaml defines the access permissions of the Redis Enterprise Service Broker.

    Warning -
    Changes to this file can cause unexpected results.
    • Apply the yaml file with:
    kubectl apply -f sb_rbac.yaml

    The command returns a confirmation response such as: configured configured
  • The redis-enterprise-cluster_rhel yaml defines the configuration of the newly created resource: Redis Enterprise Cluster. You can rename the file to your_cluster_name.yaml, but it is not required.

    You can edit this yaml file for your requirements, but you can use the sample provided for testing, developement and quick start deployments. Here are the main fields you to review and edit:

    • name: “your_cluster_name” - For example “demo-cluster”

    • nodes: number_of_nodes_in_the_cluster - Must be an uneven number of 3 or more

    • uiServiceType: service_type - Service type value can be either ClusterIP or LoadBalancer. This is an optional configuration based on k8s service types. The default is ClusterIP.

    • storageClassName: “gp2“ - This specifies the StorageClass used for the persistent disks in your nodes. For example, AWS uses “gp2” as a default, GKE uses “standard”, and Azure uses “default”.

    • redisEnterpriseNodeResources: The compute resources required for each node.

    • limits – Specifies the maximum resources for a Redis node.

    • requests – Specifies the minimum resources for a Redis node.

      For example:

      cpu: “4000m”
      memory: 4Gi
      cpu: “4000m”
      memory: 4Gi

      The default is 4 cores (4000m) and 4GB (4Gi).

    • serviceBrokerSpec –

    • enabled: <false/true>

      This specifies persistence for the Service Broker with an “enabled/disabled” flag. The default is “false.”

      storageClassName: “gp2“
    • redisEnterpriseImageSpec: This configuration controls the Redis Enterprise version used, and where it is fetched from. This is an optional field. The Operator automatically uses the matching RHEL image version for the release.

      Repository: redislabs/redis
      versionTag: 5.2.10-22

      The version tag must be as it appears on your repository, such as on DockerHub.

Step 4: Create your Cluster

After you set up the your_cluster_name yaml:

  1. Apply it to create your Redis Enterprise Cluster:

    kubectl apply -f your_cluster_name.yaml
  2. Run kubectl get rec and verify that creation succeeded. (rec is a shortcut for “RedisEnterpriseClusters”).

    The command returns a confirmation response such as:

    Your_cluster_name 17s

Your Cluster will be ready shortly, typically within a few minutes.

To check the cluster status, run:

kubectl get pod

You should receive a response similar to the following:

your_cluster_name-0 2/2 Running 0 1m
your_cluster_name-1 2/2 Running 0 1m
your_cluster_name-2 2/2 Running 0 1m
your_cluster_name-controller-x-x 1/1 Running 0 1m
Redis-enterprise-operator-x-x 1/1 Running 0 5m

Next, create your databases.

Step 5: Create a database

To create your database:

  1. Apply port forwarding to your Cluster:

    kubectl port-forward your_cluster_name-0 8443:8443
    Note -
    • your_cluster_name-0 is one of your cluster pods. Consider running the port-forward command in the background.
    • The Openshift UI provides tools for creating additional routing options, including external routes. These are covered in RedHat Openshift documentation.

    Next, create your database.

  2. Open a browser window and navigate to the Redis Enterprise web UI at: localhost:8443


  3. To get your password from the OpenShift management console, go Resources > Secrets > your_cluster_name, select your project name, and select Reveal Secret.

    Warning -
    Do not change the default admin user password in the Redis Enterprise web UI. Changing the admin password can cause unextpected results in your K8s deployment.


  4. Continue with the instructions to create your database.

Note -
To conduct the Ping test through Telnet, you can create a new route to the new database port as described above for the UI port. After you create your database, go to the Openshift management console, select your project name, and go to Applications > Services. Two new services are shown that represent the database along with their IP and port information, similar to the screenshot below.