diff --git a/content/operate/kubernetes/architecture/_index.md b/content/operate/kubernetes/architecture/_index.md index d7658d9b3f..d2d72f0615 100644 --- a/content/operate/kubernetes/architecture/_index.md +++ b/content/operate/kubernetes/architecture/_index.md @@ -5,44 +5,155 @@ categories: - docs - operate - kubernetes -description: This section provides an overview of the architecture and considerations - for Redis Enterprise for Kubernetes. +description: Overview of the architecture and components of Redis Enterprise for Kubernetes. hideListLinks: true linkTitle: Architecture -weight: 11 +weight: 1 +aliases: [operate/platforms/kubernetes/kubernetes-architecture/] --- -Redis bases its Kubernetes architecture on several vital concepts. -## Layered architecture +Redis Enterprise for Kubernetes gives you the speed and durability of [Redis Enterprise](https://redis.io/redis-enterprise/advantages/), with the flexibility and ease of [Kubernetes (K8s)](https://kubernetes.io/). Redis Enterprise for Kubernetes uses the Kubernetes operator pattern and custom controllers to bring the best of Redis Enterprise to the Kubernetes platform. -Kubernetes is an excellent orchestration tool, but it was not designed to deal with all the nuances associated with operating Redis Enterprise. Therefore, it can fail to react accurately to internal Redis Enterprise edge cases or failure conditions. Also, Kubernetes orchestration runs outside the Redis Cluster deployment and may fail to trigger failover events, for example, in split network scenarios. +## Lifecycle -To overcome these issues, Redis created a layered architecture approach that splits responsibilities between operations Kubernetes does well, procedures Redis Enterprise Cluster excels at, and the processes both can orchestrate together. The figure below illustrated this layered orchestration architecture: +Kubernetes is a rapidly evolving platform with a short release cycle (around 4 months). This frequent influx of new features, enhancements and bug fixes means Kubernetes distributions move in and out of support quickly. Redis Enterprise is also a fast-moving product, and is compatible and tested only on distributions listed as [supported distributions.]({{}}) -{{< image filename="/images/k8s/kubernetes-overview-layered-orchestration.png" >}} +Each version of Redis Enterprise for Kubernetes is tested to ensure the version of Redis Enterprise works with the [supported Kubernetes distributions]({{}}) at the time. Both the Kubernetes version and the Redis Enterprise version must be supported for the operator to function correctly. We encourage you to upgrade Redis Enterprise for Kubernetes frequently, not only to get the benefit of enhancements and bug fixes, but to keep your software supported. -## Operator based deployment +Supported platforms are listed in the [release notes]({{}}) and in the [supported platforms reference.]({{}}) -Operator allows Redis to maintain a unified deployment solution across various Kubernetes environments, i.e., RedHat OpenShift, VMware Tanzu (Tanzu Kubernetes Grid, and Tanzu Kubernetes Grid Integrated Edition, formerly known as PKS), Google Kubernetes Engine (GKE), Azure Kubernetes Service (AKS), and vanilla (upstream) Kubernetes. Statefulset and anti-affinity guarantee that each Redis Enterprise node resides on a Pod that is hosted on a different VM or physical server. See this setup shown in the figure below: +## Architecture -{{< image filename="/images/k8s/kubernetes-overview-unified-deployment.png" >}} +The image below illustrates the components of a single namespace, three node deployment. -## Network-attached persistent storage {#networkattached-persistent-storage} +{{< image filename="/images/k8s/k8s-arch-v4.png" >}} -Kubernetes and cloud-native environments require that storage volumes be network-attached to the compute instances, to guarantee data durability. Otherwise, if using local storage, data may be lost in a Pod failure event. See the figure below: +## Operator -{{< image filename="/images/k8s/kubernetes-overview-network-attached-persistent-storage.png" >}} +An [operator](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/) is a custom extension of the Kubernetes API designed to manage complex, stateful applications and their components. This operator pattern is commonly used by databases and other applications to extend the cluster's behavior without changing its underlying code. Kubernetes.io/docs has a great explanation of the [operator pattern](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/). -On the left-hand side (marked #1), Redis Enterprise uses local ephemeral storage for durability. When a Pod fails, Kubernetes launches another Pod as a replacement, but this Pod comes up with empty local ephemeral storage, and the data from the original Pod is now lost. +The operator is a deployment that runs within a [namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/) and uses [controllers](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#custom-controllers) to manage [custom resources (CRs)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/), ensuring these resources are continuously monitored and maintained. -On the right-hand side of the figure (marked #2), Redis Enterprise uses network-attached storage for data durability. In this case, when a Pod fails, Kubernetes launches another Pod and automatically connects it to the storage device used by the failed Pod. Redis Enterprise then instructs the Redis Enterprise database instance/s running on the newly created node to load the data from the network-attached storage, which guarantees a durable setup. +When the operator is installed, the following resources are created: -Redis Enterprise is not only great as an in-memory database but also extremely efficient in the way it uses persistent storage, even when the user chooses to configure Redis Enterprise to write every change to the disk. Compared to a disk-based database that requires multiple interactions (in most cases) with a storage device for every read or write operation, Redis Enterprise uses a single IOPS, in most cases, for a write operation and zero IOPS for a read operation. As a result, significant performance improvements are seen in typical Kubernetes environments, as illustrated in the figures below: +- [service account](https://kubernetes.io/docs/concepts/security/service-accounts/) under which the operator will run +- set of [roles](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#role-and-clusterrole) to define the privileges necessary for the operator to perform its tasks +- set of [role bindings](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#rolebinding-and-clusterrolebinding) to authorize the service account +- [CustomResourceDefinition (CRD)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) for each Redis Enterprise custom resource +- the operator deployment -{{< image filename="/images/k8s/kubernetes-overview-performance-improvements-read.png" >}}{{< image filename="/images/k8s/kubernetes-overview-performance-improvements-write.png" >}} +## Namespace -## Multiple services on each pod +The Redis Enterprise [operator](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/) is deployed within a [namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/). Each namespace can host only one operator and one [RedisEnterpriseCluster (REC)](#redisenterprisecluster-rec). Namespaces create logical boundaries between resources, allowing organization and security. Some resources are limited to a namespace, while others are cluster-wide. -Each Pod includes multiple Redis Enterprise instances (multiple services). We found that the traditional method of deploying a Redis Enterprise database over Kubernetes, in which each Pod includes only a single Redis Enterprise instance while preserving a dedicated CPU, is notably inefficient. Redis Enterprise is exceptionally fast and in many cases can use just a fraction of the CPU resources to deliver the requested throughput. Furthermore, when running a Redis Enterprise Cluster with multiple Redis Enterprise instances across multiple Pods, the Kubernetes network, with its multiple vSwitches, can quickly become the deployment’s bottleneck. Therefore, Redis took a different approach to managing Redis Enterprise over the Kubernetes environment. Deploying multiple Redis Enterprise database instances on a single Pod allows us to better utilize the hardware resources used by the Pod such as CPU, memory, and network while keeping the same level of isolation. See the figure below: +Redis Enterprise for Kubernetes also supports [multi-namespace deployments]({{}}), meaning the operator can monitor other namespaces (that host applications) for custom resources and apply any changes. -{{< image filename="/images/k8s/kubernetes-overview-multiple-services-per-pod.png" >}} +## Custom resources + +Kubernetes [custom resources (CRs)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/) are commonly used by databases and other applications to extend the cluster's behavior without changing its underlying code. [Custom resources (CRs)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/) extend the Kubernetes API, enabling users to manage Redis databases the Kubernetes way. Custom resources are created and managed using YAML configuration files. + +This [declarative configuration approach](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/declarative-config/) allows you to specify the desired state for your resources, and the operator makes the necessary changes to achieve that state. This simplifies [installation]({{}}), [upgrades]({{}}), and [scaling]({{}}) both vertically and horizontally. + +The operator continuously monitors CRs for changes, automatically reconciling any differences between the desired state you specified in your YAML configuration file, and the actual state of your resources. Custom resources can also reside in separate namespaces from the operator managing them, such as in [multi-namespace installations]({{}}). + +## Custom resource definitions + +A [custom resource definition (CRD)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) is a cluster-wide resource that specifies which settings can be configured via custom resource files. Any setting not defined by the CRD is not managed by the operator. You can still make changes to these unmanaged settings using standard Redis Enterprise Software methods. + +For settings managed by the operator, any changes made outside of the CR YAML files (e.g., through the management UI) will be overwritten by the operator. Ensure that all operator-managed settings are updated using the CR YAML files to prevent conflicts. + +## RedisEnterpriseCluster REC + +A Redis Enterprise cluster is a set of Redis Enterprise nodes pooling resources. Each node is capable of running multiple Redis instances ([shards]({{}})). + +{{< image filename="/images/k8s/k8s-node-arch.png">}} + +A Redis cluster is created and managed by the [RedisEnterpriseCluster (REC)]({{}}) [custom resource](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/). Changes to the REC configuration file prompt the operator to make changes to the cluster. The REC is required for both standard databases ([REDB](#redisenterprisedatabase-redb)) and Active-Active databases ([REAADB](#redisenterpriseactiveactivedatabase-reaadb)). + +See the [RedisEnterpriseCluster API Reference]({{}}) for a full list of fields and settings. + +## RedisEnterpriseDatabase REDB + +A Redis Enterprise database is a logical entity that manages your entire dataset across multiple Redis instances. A Redis instance is a single-threaded database process ([commonly referred to as a shard]({{}})). + +Redis databases are created and managed by the [RedisEnterpriseDatabase (REDB)]({{}}) [custom resource (CR)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/). Changes to the REDB YAML configuration file prompt the operator to make changes to the database. + +An operator can manage a database in the same namespace, or a different namespace. See ["Flexible deployment"]({{}}) options and ["Manage databases in multiple namespaces"]({{}}) for more information. + +See the [RedisEnterpriseDatabase (REDB) API Reference]({{}}) for a full list of fields and settings. + +## Security + +Redis Enterprise for Kubernetes uses [secrets](https://kubernetes.io/docs/concepts/configuration/secret/) to manage your cluster credentials, cluster certificates, and client certificates. You can configure [LDAP]({{}}) and [internode encryption]({{}}) using the [RedisEnterpriseCluster (REC)](#redisenterprisecluster-rec) spec. + +### REC credentials + +Redis Enterprise for Kubernetes uses the [RedisEnterpriseCluster (REC)]({{}}) [custom resource](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/) to create a Redis Enterprise cluster. During creation it generates random credentials for the operator to use. The credentials are saved in a Kubernetes (K8s) [secret](https://kubernetes.io/docs/concepts/configuration/secret/). The secret name defaults to the name of the cluster. + +See [Manage REC credentials]({{}}) for more details. + +### REC certificates + +By default, Redis Enterprise Software for Kubernetes generates TLS certificates for the cluster during creation. These self-signed certificates are generated on the first node of each Redis Enterprise cluster (REC) and are copied to all other nodes in the cluster. + +See [Manage REC certificates]({{}}) for more details. + +### Client certificates + +For each client certificate you want to use, you need to create a [Kubernetes secret](https://kubernetes.io/docs/concepts/configuration/secret/) to hold it. You can then reference that secret in your [Redis Enterprise database (REDB)](#redisenterprisedatabase-redb) custom resource. + +See [Add client certificates]({{}}) for more details. + +## Storage + +[Persistent storage is mandatory for Redis Enterprise.]({{}}) Redis Enterprise for Kubernetes [requires network-attached storage](https://en.wikipedia.org/wiki/Network-attached_storage). + +Redis Enterprise for Kubernetes uses [PersistentVolumeClaims (PVC)](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#expanding-persistent-volumes-claims) to manage storage resources. The PVC is an abstract representation of the [PersistentVolume (PV)](https://kubernetes.io/docs/concepts/storage/persistent-volumes) resources used by your Redis pods. PVCs are created by the Redis Enterprise operator and used by the [RedisEnterpriseCluster (REC)](#redisenterprisecluster-rec). + +PVCs are created with a specific size and [can be expanded](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#expanding-persistent-volumes-claims), if the underlying [storage class](https://kubernetes.io/docs/concepts/storage/storage-classes/) supports it. + +### Auto Tiering + +Redis Enterprise Software for Kubernetes supports [Auto Tiering]({{}}) (previously known as Redis on Flash), which extends your node memory to use both RAM and flash storage. SSDs (solid state drives) can store infrequently used (warm) values while your keys and frequently used (hot) values are still stored in RAM. This improves performance and lowers costs for large datasets. + +NVMe (non-volatile memory express) SSDs are strongly recommended to achieve the best performance. + +## Networking + +By default, Kubernetes doesn't allow you to access your Redis database from outside your K8s cluster. Redis Enterprise for Kubernetes supports several ways to route external traffic to your [Redis Enterprise cluster (REC)](#redisenterprisecluster-rec): + +- Ingress controllers [HAProxy](https://haproxy-ingress.github.io/) and [NGINX](https://kubernetes.github.io/ingress-nginx/) require an `ingress` API resource. +- [Istio](https://istio.io/latest/docs/setup/getting-started/) requires `Gateway` and `VirtualService` API resources. +- OpenShift uses [routes]({{< relref "/operate/kubernetes/networking/routes.md" >}}) to route external traffic. + +The [Active-Active databases](#active-active-databases) require one of above routing methods to be configured in the REC with the [ingressOrRouteSpec field]({{}}). + +## Services Rigger + +The services rigger is responsible for creating and updating services related to database objects. It identifies database objects within the cluster and creates services in accordance with [`redisEnterpriseCluster.Spec.servicesRiggerSpec` setting]({{}}) to allow access to those databases. By default, each database has two services, a `cluster_ip` Service with the same name as the database and a `headless` Service with the same name as the database suffixed with `-headless`. It also creates other types of Services such as Ingress Services or OpenshiftRoutes (defined in `redisEnterpriseCluster.Spec.ingressOrRouteSpec`) meant to provide access to REAADB objects. + +You can view a list of services with the `kubectl get services` command. + +Kubernetes is a dynamic environment, with nodes and pods changing as needed. The services rigger monitors the cluster for these changes and updates the database services to ensure reliable communication with the databases. + +## Active-Active databases + +On Kubernetes, Redis Enterprise [Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) databases provide read and write access to the same dataset from different Kubernetes clusters. Creating an Active-Active database requires routing [network access]({{< relref "/operate/kubernetes/networking/" >}}) between two Redis Enterprise clusters residing in different Kubernetes clusters. Without the proper access configured for each cluster, syncing between the databases instances will fail.The admission controller is also required for Active-Active databases on Kubernetes, to validate changes to the custom resources. + +For more details and installation information, see [Active-Active databases]({{}}). For more general information about Active-Active, see the [Redis Enterprise Software docs]({{< relref "/operate/rs/databases/active-active/" >}}). + +## RedisEnterpriseRemoteCluster RERC + +The [RedisEnterpriseRemoteCluster (RERC)]({{}}) contains details allowing the REC to link to the RedisEnterpriseActiveActiveDatabase (REAADB). The RERC resource is listed in the [REAADB](#redisenterpriseactiveactivedatabase-reaadb) resource to become a participating cluster for the Active-Active database. + +See the [RERC API reference]({{}}) for a full list of fields and settings. + +## RedisEnterpriseActiveActiveDatabase REAADB + +The RedisEnterpriseActiveActiveDatabase (REAADB) resource creates and manages a database that spans more than one Kubernetes cluster. An REAADB requires [external routing](#networking), at least two [RECs](#redisenterprisecluster-rec), and at least two [RERCs](#redisenterpriseremotecluster-rerc). + +See the [REAADB API reference]({{}}) for a full list of fields and settings. + +## Metrics + +To collect metrics data from your databases and Redis Enterprise cluster (REC), you can [connect your Prometheus]({{}}) server to an endpoint exposed on your REC. Redis Enterprise for Kubernetes creates a dedicated service to expose the `prometheus` port (8070) for data collection. A custom resource called `ServiceMonitor` allows the [Prometheus operator](https://github.com/prometheus-operator/prometheus-operator/tree/main/Documentation) to connect to this port and collect data from Redis Enterprise. diff --git a/content/operate/kubernetes/deployment/deployment-options.md b/content/operate/kubernetes/architecture/deployment-options.md similarity index 94% rename from content/operate/kubernetes/deployment/deployment-options.md rename to content/operate/kubernetes/architecture/deployment-options.md index 4efc469083..c7e48212e2 100644 --- a/content/operate/kubernetes/deployment/deployment-options.md +++ b/content/operate/kubernetes/architecture/deployment-options.md @@ -9,17 +9,17 @@ description: Redis Enterprise for Kubernetes allows you to deploy to multiple na This article describes flexible deployment options you can use to meet your specific needs. linkTitle: Deployment options +aliases: [ /operate/kubernetes/architecture/deployment-options/, ] weight: 12 --- You can deploy Redis Enterprise for Kubernetes in several different ways depending on your database needs. -Multiple Redis Enterprise database resources (REDB) can be associated with single Redis Enterprise cluster resource (REC) even if they reside in different namespaces. +Multiple RedisEnterpriseDatabase (REDB) resources can be associated with a single Redis Enterprise cluster resource (REC) even if they reside in different namespaces. The Redis Enterprise cluster (REC) custom resource must reside in the same namespace as the Redis Enterprise operator. {{}} Multi-namespace installations don't support Active-Active databases (REEADB). Only databases created with the REDB resource are supported in multi-namespace deployments at this time.{{}} - ## Single REC and single namespace (one-to-one) The standard and simplest deployment deploys your Redis Enterprise databases (REDB) in the same namespace as the Redis Enterprise cluster (REC). No additional configuration is required for this, since there is no communication required to cross namespaces. See [Deploy Redis Enterprise for Kubernetes]({{< relref "/operate/kubernetes/deployment/quick-start.md" >}}). diff --git a/content/operate/kubernetes/architecture/operator.md b/content/operate/kubernetes/architecture/operator.md deleted file mode 100644 index 7c7d6c6902..0000000000 --- a/content/operate/kubernetes/architecture/operator.md +++ /dev/null @@ -1,71 +0,0 @@ ---- -Title: Redis Enterprise for Kubernetes operator-based architecture -alwaysopen: false -categories: -- docs -- operate -- kubernetes -description: This section provides a description of the design of Redis Enterprise - for Kubernetes. -linkTitle: What is an operator? -weight: 30 ---- -Redis Enterprise is the fastest, most efficient way to -deploy and maintain a Redis Enterprise cluster in Kubernetes. - -## What is an operator? - -An operator is a [Kubernetes custom controller](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#custom-controllers) which extends the native K8s API. - -Operators were developed to handle sophisticated, stateful applications -that the default K8s controllers aren’t able to handle. While stock -Kubernetes controllers—for example, -[StatefulSets](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/)—are -ideal for deploying, maintaining and scaling simple stateless -applications, they are not equipped to handle access to stateful -resources, upgrade, resize and backup of more elaborate, clustered -applications such as databases. - -## What does an operator do? - -In abstract terms, Operators encode human operational knowledge into -software that can reliably manage an application in an extensible, -modular way and do not hinder the basic primitives that comprise the K8s -architecture. - -Redis created an operator that deploys and manages the lifecycle of a Redis Enterprise Cluster. - -The Redis Enterprise operator acts as a custom controller for the custom -resource RedisEnterpriseCluster, or ‘rec’, which is defined through K8s -CRD ([custom resource definition](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#custom-resources)) -and deployed with a yaml file. - -The operator functions include: - -- Validating the deployed Cluster spec (for example, requiring the -deployment of an odd number of nodes) -- Implementing a reconciliation loop to monitor all the applicable -resources -- Logging events -- Enabling a simple mechanism for editing the Cluster spec - -The Redis Enterprise operator functions as the logic “glue” between the -K8s infrastructure and the Redis Enterprise Cluster. - -The operator creates the following resources: - -- Service account -- Service account role -- Service account role binding -- Secret – holds the cluster username, password, and license -- Statefulset – holds Redis Enterprise nodes -- The Services Manager deployment – exposes databases and tags nodes -- The Redis UI service -- The service that runs the REST API + Sentinel -- Pod Disruption Budget -- Optionally: a deployment for the Service Broker, including services and a PVC - -The following diagram shows the high-level architecture of the Redis -Enterprise operator: - -{{< image filename="/images/k8s/k8-high-level-architecture-diagram-of-redis-enterprise.png" >}} diff --git a/content/operate/kubernetes/deployment/_index.md b/content/operate/kubernetes/deployment/_index.md index c9e7da5d93..5aee514767 100644 --- a/content/operate/kubernetes/deployment/_index.md +++ b/content/operate/kubernetes/deployment/_index.md @@ -15,23 +15,6 @@ weight: 11 This section lists the different ways to set up and run Redis Enterprise for Kubernetes. You can deploy on variety of Kubernetes distributions both on-prem and in the cloud via our Redis Enterprise operator for Kubernetes. -## Operator overview {#overview} - -Redis Enterprise for Kubernetes uses [custom resource definitions](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) (CRDs) to create and manage Redis Enterprise clusters (REC) and Redis Enterprise databases (REDB). - -The operator is a deployment that runs within a given namespace. These operator pods must run with sufficient privileges to create the Redis Enterprise cluster resources within that namespace. - -When the operator is installed, the following resources are created: - -* a service account under which the operator will run -* a set of roles to define the privileges necessary for the operator to perform its tasks -* a set of role bindings to authorize the service account for the correct roles (see above) -* the CRD for a Redis Enterprise cluster (REC) -* the CRD for a Redis Enterprise database (REDB) -* the operator itself (a deployment) - -The operator currently runs within a single namespace and is scoped to operate only on the Redis Enterprise cluster in that namespace. - ## Compatibility Before installing, check [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) to see which Redis Enterprise operator version supports your Kubernetes distribution. diff --git a/content/operate/kubernetes/faqs/_index.md b/content/operate/kubernetes/faqs/_index.md index 7e9f38196a..da1bd6ff62 100644 --- a/content/operate/kubernetes/faqs/_index.md +++ b/content/operate/kubernetes/faqs/_index.md @@ -7,6 +7,7 @@ categories: - kubernetes description: null hideListLinks: true +hidden: true linkTitle: FAQs weight: 100 --- @@ -14,7 +15,7 @@ Here are some frequently asked questions about Redis Enterprise on integration p ## What is an Operator? -An operator is a [Kubernetes custom controller](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources#custom-controllers) which extends the native K8s API. Refer to the article [Redis Enterprise K8s Operator-based deployments – Overview]({{< relref "/operate/kubernetes/architecture/operator.md" >}}). +An operator is a [Kubernetes custom controller](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources#custom-controllers) which extends the native K8s API. Refer to the article [Redis Enterprise K8s Operator-based deployments – Overview]({{< relref "/operate/kubernetes/architecture/" >}}). ## Does Redis Enterprise operator support multiple RECs per namespace? diff --git a/content/operate/kubernetes/re-clusters/multi-namespace.md b/content/operate/kubernetes/re-clusters/multi-namespace.md index 23161d62e5..0a72edf9cd 100644 --- a/content/operate/kubernetes/re-clusters/multi-namespace.md +++ b/content/operate/kubernetes/re-clusters/multi-namespace.md @@ -14,7 +14,7 @@ weight: 17 Multiple Redis Enterprise database resources (REDBs) can be associated with a single Redis Enterprise cluster resource (REC) even if they reside in different namespaces. -To learn more about designing a multi-namespace Redis Enterprise cluster, see [flexible deployment options]({{< relref "/operate/kubernetes/deployment/deployment-options.md" >}}). +To learn more about designing a multi-namespace Redis Enterprise cluster, see [flexible deployment options]({{< relref "/operate/kubernetes/architecture/deployment-options.md" >}}). {{}} Multi-namespace installations don't support Active-Active databases (REEADB). Only databases created with the REDB resource are supported in multi-namespace deployments at this time.{{}} diff --git a/content/operate/kubernetes/re-databases/db-controller.md b/content/operate/kubernetes/re-databases/db-controller.md index 88dd6605cf..487d091a37 100644 --- a/content/operate/kubernetes/re-databases/db-controller.md +++ b/content/operate/kubernetes/re-databases/db-controller.md @@ -32,7 +32,7 @@ If the database [custom resource is deleted]({{< relref "/operate/kubernetes/del Databases in multiple namespaces can be managed by the same operator. To learn more, see [Manage databases in multiple namespaces]({{}}). -To learn more about designing a multi-namespace Redis Enterprise cluster, see [flexible deployment options]({{< relref "/operate/kubernetes/deployment/deployment-options.md" >}}). +To learn more about designing a multi-namespace Redis Enterprise cluster, see [flexible deployment options]({{< relref "/operate/kubernetes/architecture/deployment-options.md" >}}). ## Create a database diff --git a/static/images/k8s/k8s-arch-v4.png b/static/images/k8s/k8s-arch-v4.png new file mode 100644 index 0000000000..20eab398b9 Binary files /dev/null and b/static/images/k8s/k8s-arch-v4.png differ diff --git a/static/images/k8s/k8s-node-arch.png b/static/images/k8s/k8s-node-arch.png new file mode 100644 index 0000000000..c476cee319 Binary files /dev/null and b/static/images/k8s/k8s-node-arch.png differ