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

Prerequisites:

  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

  • Log in to your OpenShift account as a super admin (so you have access to all the default projects).
  • Create a new project, fill in the name and other details for the project, and click Create.

    getting-started-kubernetes-openshift-image1

  • Click on “admin” (upper right corner) and then “Copy Login.”

    getting-started-kubernetes-openshift-image4

  • Paste the login command into your shell; it should look something like this:

    oc login https://your-cluster.acme.com –token=your$login$token
  • Next, verify that you are using the newly created project. Type:

    oc project <your project name>

This will shift to your project rather than the default project (you can verify the project you’re currently using with the oc project command).

Step 2: Get deployment files

Clone this repository, which contains the deployment files:

git clone https://github.com/RedisLabs/redis-enterprise-k8s-docs

Specifically for the custom resource (cr) yaml file, you may 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 the cluster’s security context constraints, which we will apply to our project later on. We strongly recommend not changing anything in this yaml file.

    Apply the file:

    oc apply -f scc.yaml

    You should receive the following response:

    securitycontextconstraints.security.openshift.io “redis-enterprise-scc” configured

    Now you need to bind the scc to your project by typing:

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

    (If you do not remember your project name, run “oc project”)

  • openshift.bundle.yaml -

    The bundle file includes several declarations:

    1. 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.
    2. crd declaration, creating a CustomResourceDefinition for your Redis Enterprise Cluster resource. This provides another API resource to be handled by the k8s API server and managed by the operator we will deploy next
    3. operator deployment declaration, creates the operator deployment, which 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.

    This yaml should be applied as-is, without changes. To apply it:

    kubectl apply -f openshift.bundle.yaml

    You should receive the following response:

    role.rbac.authorization.k8s.io/redis-enterprise-operator created
    serviceaccount/redis-enterprise-operator created
    rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator created
    customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com configured
    deployment.apps/redis-enterprise-operator created
  1. Now, verify that your redis-enterprise-operator deployment is running:

    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’re deploying 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.

    We strongly recommend not changing anything in this yaml file.

    To apply it, run:

    kubectl apply -f sb_rbac.yaml

    You should receive the following response:

    clusterrole.rbac.authorization.k8s.io/redis-enterprise-operator-sb configured
    clusterrolebinding.rbac.authorization.k8s.io/redis-enterprise-operator configured
  • The redis-enterprise-cluster_rhel yaml defines the configuration of the newly created resource: Redis Enterprise Cluster. This yaml could be renamed your_cluster_name.yaml to keep things tidy, but this isn’t a mandatory step.

    This yaml can be edited to the required use case, however, the sample provided can be used for test/dev and quick start purposes. Here are the main fields you may review and edit:

    • name: “your_cluster_name” (e.g. “demo-cluster”)
    • nodes: number_of_nodes_in_the_cluster (Must be an uneven number of at least 3 or greater—here’s why)
    • 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 your nodes’ persistent disks. 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 max resources for a Redis node

    • requests – specifies the minimum resources for a Redis node

      For example:

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

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

      Note -
      Resource limits should equal requests (Learn why).
    • serviceBrokerSpec –

    • enabled: <false/true>

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

      persistentSpec: storageClassName: “gp2“

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

      imagePullPolicy: IfNotPresent Repository: redislabs/redis versionTag: 5.2.10-22

      The version tag, as it appears on your repository (e.g. on DockerHub).

Step 4: Create your Cluster

Once you have your_cluster_name yaml set, you need to apply it to create your Redis Enterprise Cluster:

kubectl apply -f your_cluster_name.yaml

Run kubectl get rec and verify that creation was successful (rec is a shortcut for “RedisEnterpriseClusters”).

You should receive a response similar to the following:

NAME AGE

Your_cluster_name 17s

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

To check the cluster status, type the following:

kubectl get pod

You should receive a response similar to the following:

NAME READY STATUS RESTARTS AGE
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

In order to create your database, we will log in to the Redis Enterprise UI.

  • First, 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. You may 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.

  • Open a browser window and navigate to localhost:8443

    getting-started-kubernetes-openshift-image5

  • In order to retrieve your password, navigate to the OpenShift management console, select your project name, go to Resources->Secrets->your_cluster_name

  • Retrieve your password by selecting “Reveal Secret.”

    Warning -
    Do not change the default admin user password in the Redis Enterprise web UI. Changing the admin password impacts the proper operation of the K8s deployment.

    getting-started-kubernetes-openshift-image3

  • Follow the interface’s instructions to create your database.

Note -
In order to conduct the Ping test through Telnet, you can create a new route to the newly created database port in the same way 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. You will see two newly created services representing the database along with their IP and port information, similar to the screenshot below.

getting-started-kubernetes-openshift-image6