Redis Enterprise Software on Kubernetes deployment with OpenShift CLI tools

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

Prerequisites:

1. An OpenShift cluster installed at version 4.6 or higher, 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 command.

   

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

   oc login --token=<yourToken> --server=https://<cluster FQDN:PORT>
   

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 https://github.com/RedisLabs/redis-enterprise-k8s-docs

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 redis-enterprise-k8s-docs/openshift/scc.yaml
     

     You should receive the following response:

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

  2. To bind the scc to your project, replace <your_project_name> with the project name, and 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:

     oc apply -f openshift.bundle.yaml
     

     The command returns a confirmation response such as:

     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.redis.com configured
     deployment.apps/redis-enterprise-operator created
     

  2. To verify that your redis-enterprise-operator deployment is running, run:

     oc get deployment
     

     A typical response will look like this:

     NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
     redis-enterprise-operator   1/1     1            1           0m36s
     

• The rec_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:

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

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

    Note:

    Resource limits should equal requests.

    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 automatically uses the matching RHEL image version for the release.

    imagePullPolicy: IfNotPresent
    repository: redislabs/redis
    versionTag: 6.0.20-97
    

    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:

   oc apply -f your_cluster_name.yaml
   

2. Run oc get rec and verify that creation succeeded. (rec is a shortcut for “RedisEnterpriseClusters”).

   The command returns a confirmation response such as:

   NAME AGE
   
   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:

Next, create your databases.

Step 5: Create a database

To create your database:

1. Apply port forwarding to your Cluster:

   oc 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 admin console at: localhost:8443

   

3. To get your password from the OpenShift management console, go Workloads > 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 admin console. Changing the admin password can cause unextpected results in your K8s deployment.

   

4. Continue with the instructions to create your database.