Deploying CockroachDB on Kubernetes using OpenEBS LocalPV

Published: 2021-05-31 12:22:31

CockroachDB is a cloud-native SQL database that features both scalability and consistency. The database is designed to withstand data center failures by deploying multiple instances of symmetric nodes in a cluster consisting of several machines, disks, and data centers. Kubernetes’ built-in capabilities to scale and survive node failures make it well suited to orchestrate CockroachDB’s databases. This is particularly for the reason that Kubernetes simplifies cluster management and helps maintain high-availability by replicating data across independent nodes. 

This guide focuses on how OpenEBS LocalPV devices can be used to persist storage for Kubernetes-Hosted CockroachDB clusters. 

##Introduction to Distributed, Scaled-out Databases

Ever growing demands for resilience, performance, scalability and ease of use have led to an explosion of choices for developers and data scientists in search of an open source database to address their needs. Databases are often characterized as either SQL databases, noted for their consistency guarantees with PostgreSQL and MariaDB considered to be ACID compliant **(Atomic, Consistent, Isolated, Durable)**, or NoSQL databases which have been noted for their scalability and flexibility however not considered to be either ACID compliant or completely compatible with SQL. More recently **Distributed, Scaled-out Databases** were introduced that promise to avoid the trade-offs between SQL and NoSQL databases, allowing for the scalability of NoSQL DBs along with the **ACID (Atomic, Consistent, Isolated, Durable)** transactions, strong consistency, and relational schemas of SQL DBs. 

CockroachDB is a distributed database that is built on top of **RocksDB** as its **transactional** and **key-value store**. Cockroach DB supports both **ACID transactions** and **vertical & horizontal scalability**. With extensive geographical distribution, CockroachDB can maintain availability with controlled latency in case of disk, machine or even a data center failure. 

##How CockroachDB works:

CockroachDB is deployed in clusters consisting of multiple **nodes**. Each node is divided into five layers: 

* The **SQL Layer** converts client queries to key-value entities by first parsing them against a YACC file then converting them into an abstract syntax tree. With this tree, the database will generate a network of plan nodes containing a key-value code. When the plan nodes are executed, they initiate communication with the transaction layer.

* The **Transaction Layer** then uses two-phase commits to implement the semantics of ACID transactions. These commits are executed across all nodes in the cluster.  The commit involves posting write extents and transaction records, then executing read operations.

* Once a commit has been made at the transaction layer, a request is made to the respective node’s **Distribution Layer**. This layer then identifies the destination node for the request and forwards the request to its replication layer.

* The **Replication Layer’s** primary responsibility is creating multiple copies of data across cluster nodes. It also uses a raft algorithm to ensure consensus between different nodes holding similar copies of data.

* The **Storage Layer** uses RocksDB to store data as key-value pairs.

Although CockroachDB can run on Mac, Linux, and Windows OS, production instances of CockroachDB are typically run on Linux Virtual machines or containers. The database can be orchestrated either on cloud or on-premises setup. For running stateful applications, orchestration tools like Kubernetes are considered perfect. 

## Orchestrating CockroachDB with Kubernetes Clusters:

**Before we begin**

To understand how CockroachDB is orchestrated on Kubernetes, here are some Kubernetes terminology applicable to storage and stateful applications:

A **StatefulSet** is a collection of Kubernetes PODs viewed as a single stateful unit with its own network identity. A StatefulSet is a stable Kubernetes object that always binds to the same persistent storage when it restarts. 

A **Persistent Volume** is a block-storage-based file system that is bound to a POD. A volume’s lifecycle is not tied to the POD to which it is attached, and every CockroachDB node can attach to the same persistent volume every time it restarts. 

A **Certificate Signing Request** is a request by a client to have their TLS certificate signed by the Certificate Authority built into Kubernetes by default. 

**Role-Based Access Control (RBAC)** is the system used by Kubernetes to administer access permissions in the cluster. Roles allow users to access certain resources within the cluster.

To use the most up-to-date files, Kubernetes version 1.15 or higher is required to run CockroachDB clusters. The database can be deployed on any Kubernetes distribution, including a Local cluster (such as Minikube), Amazon AWS, EKS, Google GKE and GCE, among others. For persistence and replication, CockroachDB relies on external persistent volumes such as **OpenEBS LocalPV.**  

## Installing CockroachDB Operators on OpenEBS LocalPV Devices

When using OpenEBS with CockroachDB, a LocalPV is provisioned on the node where a CockroachDB POD is attached. The volume uses an unattached block device, which is used to store data. 

OpenEBS Dynamic LocalPV provisioner can create Kubernetes Local Persistent Volumes using **block devices** available on the node to persist data, hereafter referred to as **OpenEBS LocalPV Device volumes.** When compared to native Kubernetes Local Persistent Volumes, OpenEBS LocalPV Device volumes have the following advantages.

* Dynamic Volume provisioner as opposed to a Static Provisioner.

* Better management of the block devices used for creating LocalPVs by OpenEBS NDM. NDM provides capabilities like discovering block device properties, setting up device filters, metrics collection and the ability to detect if the block devices have moved across nodes.

Once a volume claims a block device, no other application can use the device for storage.  If there are limited block devices in other nodes, **nodeSelectors** can be used to provision storage for applications on particular cluster nodes. The recommended configuration for CockroachDB clusters is at least three nodes with one unclaimed Local SSD per node. 

![image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p7bb4gf26eghzw09nkev.png)

This [solution guide](https://mayadata.io/assets/pdf/deploying-cockroachdb-using-openebs.pdf) takes you through installing CockroachDB Kubernetes operators, and then configuring the cluster to use Local OpenEBS devices as the storage engines. The guide also highlights how to access the database for SQL queries, and finally demonstrates how to monitor the database using **Prometheus** and **Grafana.**  

Let us know how you use CockroachDB in production and if you have an interesting use case to share. Also, please check out other OpenEBS deployment guides on common Kubernetes stateful workloads at:

* [Deploying Kafka on Kubernetes](https://mayadata.io/workloads/kafka-on-kubernetes)

* [Deploying Elasticsearch on Kubernetes](https://mayadata.io/assets/pdf/deploying-elasticsearch-using-openebs-localpv.pdf)

* [Deploying WordPress on DigitalOcean Kubernetes](https://mayadata.io/assets/pdf/wordpress-deployment-mayadata-solution-docs.pdf)

* [Deploying Magento on Kubernetes](https://mayadata.io/workloads/magento-on-kubernetes)

* [Deploying Percona on Kubernetes](https://mayadata.io/workloads/percona-on-kubernetes-kubera)

* [Deploying Cassandra on Kubernetes](https://mayadata.io/workloads/cassandra-on-kubernetes-kubera)

* [Deploying MinIO on Kubernetes](https://mayadata.io/workloads/minio-on-kubernetes-kubera)

* [Deploying Prometheus on Kubernetes](https://mayadata.io/workloads/prometheus-on-kubernetes)

*This article has already been published on https://blog.mayadata.io/deploying-cockroachdb-on-kubernetes-using-openebs-localpv and authorised by MayaData for a republish.*