5.4.10-8 (#100)

* 5.4.10-8

* Many many many changes to merge the old docs repo with the new auto-generated one.

* Update to reflect support for K8s 1.9 and above

Co-authored-by: Amiram Mizne <[email protected]>

Author: Roey Prat

README.md

@@ -1,153 +1,146 @@
+<!-- omit in toc -->
+# Deploying Redis Enterprise K8s using an operator (custom controller)
 
-
-### Deploying Redis Enterprise K8s using an operator (custom controller)
-### Table of Contents
-
-
+* [Documentation](#documentation)
+* [Quickstart Guide](#quickstart-guide)
 * [Prerequisites](#prerequisites)
-* [Deployment](#deployment)
+* [Basic installation](#basic-installation)
+* [OpenShift](#openshift)
 * [Configuration Options](#configuration)
 * [Private Repositories](#private-repositories)
 * [Pull Secrets](#pull-secrets)
 * [IPV4 enforcement](#ipv4-enforcement)
 
+>Note: Please see the release notes for what's new in the latest release.
 
-#### Prerequisites:
-* A minimum of 3 nodes which support the following [requirements][]
-* A kubernetes version of 1.8 or higher
-* For service broker - a k8s distribution that supports service catalog (see also: [service-catalog][])
-* Access to DockerHub, RedHat Container Catalog or a private repository that can serve the required images
-> Note: For RHEL based images and/or deployments on OpenShift, please use redis-enterprise-cluster_rhel.yaml and operator_rhel.yaml.
-For Service Broker, please see examples/with_service_broker_rhel.yaml. RedHat certified images are available on: https://access.redhat.com/containers/#/product/71f6d1bb3408bd0d
-
-The following are the images and tags for this release:
-
-Redis Enterprise    -   `redislabs/redis:5.4.6-18` or `redislabs/redis:5.4.6-18.rhel7-openshift`
-
-Operator            -   `redislabs/operator:5.4.6-1186` or `redislabs/operator:5.4.6-1186b.rhel7`
+## Additional Documentation
 
-Services Rigger     -   `redislabs/k8s-controller:5.4.6-1186` or `redislabs/k8s-controller:5.4.6-1186b.rhel7`
+- [Advanced Topics](docs/topics.md)
+- [Resource Specification Reference](docs/operator.md)
 
-Service Broker      -   `redislabs/service-broker:78_4b9b17f` or `redislabs/service-broker:78_4b9b17f.rhel7`
+## Quickstart Guide
 
+### Prerequisites
 
+- A minimum of 3 nodes which support the following requirements
+- A Kubernetes cluster (server) version of 1.9 or higher
+- A Kubernetes client (kubectl) with a matching version. For OpenShift, an OpenShift client (oc).
+- For service broker - a k8s distribution that supports service catalog (see also: service-catalog)
+- Access to DockerHub, RedHat Container Catalog or a private repository that can serve the required images
 
-#### Deployment:
-Clone (or download) this repository, which contains the deployment files:
-```
-git clone https://github.com/RedisLabs/redis-enterprise-k8s-docs.git
-```
-
-1) Create a namespace / project.
+For Service Broker, please see examples/with_service_broker_rhel.yaml. RedHat certified images are available on: https://access.redhat.com/containers/#/product/71f6d1bb3408bd0d
 
-    For non-OpenShift deployments, create a new namespace:
+The following are the images and tags for this release:
 
-    ```
-    kubectl create namespace demo
-    ```
+Redis Enterprise    -   `redislabs/redis:5.4.10-22` or `redislabs/redis:5.4.6-22b.rhel7-openshift`
 
-    For OpenShift deployments, create a new project (you can substitute `oc` for `kubectl` in the rest of these instructions):
+Operator            -   `redislabs/operator:5.4.10-8` or `redislabs/operator:5.4.6-8.rhel7`
 
-    ```
-    oc new-project my-project
-    ```
+Services Rigger     -   `redislabs/k8s-controller:5.4.10-8` or `redislabs/k8s-controller:5.4.10-8b.rhel7`
 
-    > For either deployment, switch context to operate within the newly created namespace:
-    ```
-    kubectl config set-context --current --namespace=demo
-    ```
+Service Broker      -   `redislabs/service-broker:78_4b9b17f` or `redislabs/service-broker:78_4b9b17f.rhel7`
 
-2) If you are not running OpenShift, skip to the next step.  For OpenShift, perform the following commands (you need admin permissions for your cluster):
+## Basic installation
+The "Basic" installations deploys the operator from the current release with the default Ubuntu/Alpine base OS images from DockerHub and default settings.
+This is the fastest way to get up and running with a new cluster in most environments.
+Other Kubernetes distributions setup process as well as other custom configurations are referenced in this repository.
 
-    ```
-    oc apply -f scc.yaml
-    ```
-      > You should receive the following response:
+1. Create a new namespace:
 
-    `securitycontextconstraints.security.openshift.io "redis-enterprise-scc" configured`
+```bash
+kubectl create namespace demo
+```
 
-    Provide the operator permissions for pods (substitute your project for "my-project"):
-    ```
-    oc adm policy add-scc-to-group redis-enterprise-scc system:serviceaccounts:my-project
-    ```
+Switch context to the newly created namespace:
 
-    If you're deploying a service broker, also apply the sb_rbac.yaml file:
-    ```
-    oc apply -f sb_rbac.yaml
-    ```
+```bash
+kubectl config set-context --current --namespace=demo
+```
 
-    > You should receive the following response:
+2. To deploy the default installation with `kubectl`, the following command will deploy a bundle of all the yaml declarations required for the operator:
 
-    `clusterrole "redis-enterprise-operator-sb" configured`
+```bash
+kubectl apply -f bundle.yaml
+```
 
-    Bind the Cluster Service Broker role to the operator service account (in the current namespace):
+Alternatively, to run each of the declarations of the bundle individually, run the following commands *instead* of the bundle:
 
-     ```
-    oc adm policy add-cluster-role-to-user redis-enterprise-operator-sb --serviceaccount redis-enterprise-operator --rolebinding-name=redis-enterprise-operator-sb
-     ```
-    > You should receive the following response:
+```bash
+kubectl apply -f role.yaml
+kubectl apply -f role_binding.yaml
+kubectl apply -f service_account.yaml
+kubectl apply -f crds/app_v1_redisenterprisecluster_crd.yaml
+kubectl apply -f operator.yaml
+```
+> Note: The rbac.yaml file used in previous releases has been broken down into three distinct files:
+role.yaml, role_binding.yaml and service_account.yaml.
+The crd.yaml file was renamed to redisenterprisecluster_crd.yaml, with the API version prepended to the filename.
 
-    `cluster role "redis-enterprise-operator-sb" added: "redis-enterprise-operator"`
+3. Run `kubectl get deployment` and verify redis-enterprise-operator deployment is running.
 
-3) You can optionally use pod security policy.
-    ```
-    kubectl apply -f psp.yaml
-    ```
-    If you use this option, you should add the policy name to REC configuration, in redis-enterprise-cluster.yaml.
-    ```
-    podSecurityPolicyName: "redis-enterprise-psp"
-    ```
+A typical response may look like this:
 
+```bash
+|NAME                     |DESIRED | CURRENT  | UP-TO-DATE | AVAILABLE | AGE|
+|-------------------------|-------------------------------------------------|
+|redis-enterprise-operator|1	   | 1        |  1         | 1         | 2m |
+```
 
-4) The next step applies rbac.yaml, creating a service account, role, and role-binding to allow resources access control (provides permissions to create and manage resources):
+4. Create A Redis Enterprise Cluster using the default configuration, which is suitable for development type deployments and works in typical scenarios. For more advanced deployment options you may choose the configuration relevant for you - see the index at the top for documentation references that cover many scenarios and the examples in the example folder.
 
-    ```
-    kubectl apply -f rbac.yaml
-    ```
+```bash
+kubectl apply -f crds/app_v1_redisenterprisecluster_cr.yaml
+```
 
-    > You should receive the following response:
+> Note: The redis-enterprise-cluster.yaml file was renamed to redisenterprisecluster_cr.yaml, with the API version prepended to the filename.
 
-    `clusterrolebinding.rbac.authorization.k8s.io/redis-enterprise-operator configured`
+5. Run ```kubectl get rec``` and verify creation was successful. "rec" is a shortcut for RedisEnterpriseCluster.
+A typical response may look like this:
+```bash
+|NAME               |AGE
+|redis-enterprise   |5m
+```
 
-5) The next step applies crd.yaml, creating a CustomResourceDefinition for redis enterprise cluster resource.
-This creates another API resource to be handled by the k8s API server and managed by the operator we will deploy next.
-    ```
-    kubectl apply -f crd.yaml
-    ```
+### OpenShift
 
-    > You should receive the following response:
+The "OpenShift" installations deploys the operator from the current release with the RHEL image from DockerHub and default OpenShift settings.
+This is the fastest way to get up and running with a new cluster on OpenShift 3.x.
+For OpenShift 4.x, you may choose to use OLM deployment from within your OpenShift cluster or follow the steps below.
+Other custom configurations are referenced in this repository.
+> Note: you will need to replace `<my-project>` with your project name
 
-    `customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com configured`
+1. Create a new project:
 
-6) Create the operator deployment: a deployment 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).
+```bash
+oc new-project my-project
+```
 
-    Before applying, edit the tag according to the relevant operator version: `image: redislabs/operator:tag`
-    ```
-    kubectl apply -f operator.yaml
-    ```
+2. Perform the following commands (you need cluster admin permissions for your Kubernetes cluster):
 
-    > You should receive the following response:
+```bash
+oc apply -f openshift/scc.yaml
+```
 
-    `deployment.apps/redis-enterprise-operator created`
+You should receive the following response:
+`securitycontextconstraints.security.openshift.io "redis-enterprise-scc" configured`
 
-7) Run `kubectl get Deployment` and verify redis-enterprise-operator deployment is running.
+3. Provide the operator permissions for pods (substitute your project for "my-project"):
 
-    A typical response may look like this:
-    ```
-    |NAME                     |DESIRED | CURRENT  | UP-TO-DATE | AVAILABLE | AGE|
-    |-------------------------|-------------------------------------------------|
-    |redis-enterprise-operator|1	   | 1        |  1         | 1         | 2m |
-    ```
+```bash
+oc adm policy add-scc-to-group redis-enterprise-scc system:serviceaccounts:my-project
+```
 
-8)  Create A Redis Enterprise Cluster.  Choose the configuration relevant for you (see next section).  There are additional examples in the examples folder. Note that you need to specify an image tag if you'd like to pull a RHEL image.
+4. Deploy the OpenShift operator bundle:
 
-    ```
-    kubectl apply -f redis-enterprise-cluster.yaml
-    ```
+```bash
+kubectl apply -f openshift.bundle.yaml
+```
 
-9) Run ```kubectl get rec``` and verify creation was successful. "rec" is a shortcut for RedisEnterpriseClusters.
+Apply the `RedisEnterpriseCluster` resource with RHEL7 based images
 
+```bash
+kubectl apply -f openshift/redis-enterprise-cluster_rhel.yaml
+```
 
 #### Configuration:
 The operator deploys with default configurations values, but those can be customized:
@@ -157,7 +150,7 @@ Redis Image
   redisEnterpriseImageSpec:
     imagePullPolicy:  IfNotPresent
     repository:       redislabs/redis
-    versionTag:       5.4.6-18
+    versionTag:       5.4.10-22
 ```
 
 Persistence
@@ -270,21 +263,21 @@ For example:
   redisEnterpriseImageSpec:
     imagePullPolicy:  IfNotPresent
     repository:       harbor.corp.local/redisenterprise/redis
-    versionTag:       5.4.6-18
+    versionTag:       5.4.10-22
 ```
 
 ```yaml
   redisEnterpriseServicesRiggerImageSpec:
     imagePullPolicy:  IfNotPresent
     repository:       harbor.corp.local/redisenterprise/k8s-controller
-    versionTag:       5.4.6-1186
+    versionTag:       5.4.10-8
 ```
 
 ```yaml
   bootstrapperImageSpec:
     imagePullPolicy:  IfNotPresent
     repository:       harbor.corp.local/redisenterprise/operator
-    versionTag:       5.4.6-1186
+    versionTag:       5.4.10-8
 ```
 
 In Operator Deployment spec (operator.yaml):
@@ -297,7 +290,7 @@ spec:
     spec:
       containers:
         - name: redis-enterprise-operator
-          image: harbor.corp.local/redisenterprise/operator:5.4.6-1186
+          image: harbor.corp.local/redisenterprise/operator:5.4.10-8
 ```
 
 Image specification follow the [K8s Container schema](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.10/#container-v1-core).