Orchestration with Kubernetes (Insecure)

On this page

On top of CockroachDB's built-in automation, you can use a third-party orchestration system to simplify and automate even more of your operations, from deployment to scaling to overall cluster management.

This page demonstrates a basic integration with the open-source Kubernetes orchestration system. Using either the CockroachDB Helm chart or a few configuration files, you'll quickly create a 3-node local cluster. You'll run some SQL commands against the cluster and then simulate node failure, watching how Kubernetes auto-restarts without the need for any manual intervention. You'll then scale the cluster with a single command before shutting the cluster down, again with a single command.

Limitations

Kubernetes version

To deploy CockroachDB v22.2, Kubernetes 1.18 or higher is required. Cockroach Labs strongly recommends that you use a Kubernetes version that is eligible for patch support by the Kubernetes project.

Kubernetes Operator

• The CockroachDB Kubernetes Operator currently deploys clusters in a single region. For multi-region deployments using manual configs, see Orchestrate CockroachDB Across Multiple Kubernetes Clusters.

• Using the Operator, you can give a new cluster an arbitrary number of labels. However, a cluster's labels cannot be modified after it is deployed. To track the status of this limitation, refer to #993 in the Operator project's issue tracker.

Helm version

The CockroachDB Helm chart requires Helm 3.0 or higher. If you attempt to use an incompatible Helm version, an error like the following occurs:

Error: UPGRADE FAILED: template: cockroachdb/templates/tests/client.yaml:6:14: executing "cockroachdb/templates/tests/client.yaml" at <.Values.networkPolicy.enabled>: nil pointer evaluating interface {}.enabled

The CockroachDB Helm chart is currently not under active development, and no new features are planned. However, Cockroach Labs remains committed to fully supporting the Helm chart by addressing defects, providing security patches, and addressing breaking changes due to deprecations in Kubernetes APIs.

A deprecation notice for the Helm chart will be provided to customers a minimum of 6 months in advance of actual deprecation.

Network

Service Name Indication (SNI) is an extension to the TLS protocol which allows a client to indicate which hostname it is attempting to connect to at the start of the TCP handshake process. The server can present multiple certificates on the same IP address and TCP port number, and one server can serve multiple secure websites or API services even if they use different certificates.

Due to its order of operations, the PostgreSQL wire protocol's implementation of TLS is not compatible with SNI-based routing in the Kubernetes ingress controller. Instead, use a TCP load balancer for CockroachDB that is not shared with other services.

Resources

When starting Kubernetes, select machines with at least 4 vCPUs and 16 GiB of memory, and provision at least 2 vCPUs and 8 Gi of memory to CockroachDB per pod. These minimum settings are used by default in this deployment guide, and are appropriate for testing purposes only. On a production deployment, you should adjust the resource settings for your workload. For details, see Resource management.

Storage

At this time, orchestrations of CockroachDB with Kubernetes use external persistent volumes that are often replicated by the provider. Because CockroachDB already replicates data automatically, this additional layer of replication is unnecessary and can negatively impact performance. High-performance use cases on a private Kubernetes cluster may want to consider using local volumes.

Before you begin

Before getting started, it's helpful to review some Kubernetes-specific terminology:

Step 1. Start Kubernetes

1. Follow Kubernetes' documentation to install minikube, the tool used to run Kubernetes locally, for your OS. This includes installing a hypervisor and kubectl, the command-line tool used to manage Kubernetes from your local workstation.

   Note:

   Make sure you install minikube version 0.21.0 or later. Earlier versions do not include a Kubernetes server that supports the maxUnavailability field and PodDisruptionBudget resource type used in the CockroachDB StatefulSet configuration.

2. Start a local Kubernetes cluster:

   $ minikube start
   

Step 2. Start CockroachDB

To start your CockroachDB cluster, you can either use our StatefulSet configuration and related files directly, or you can use the Helm package manager for Kubernetes to simplify the process.

Step 3. Use the built-in SQL client

1. Launch a temporary interactive pod and start the built-in SQL client inside it:

   $ kubectl run cockroachdb -it \
   --image=cockroachdb/cockroach:v22.2.19 \
   --rm \
   --restart=Never \
   -- sql \
   --insecure \
   --host=cockroachdb-public
   

   $ kubectl run cockroachdb -it \
   --image=cockroachdb/cockroach:v22.2.19 \
   --rm \
   --restart=Never \
   -- sql \
   --insecure \
   --host=my-release-cockroachdb-public
   

2. Run some basic CockroachDB SQL statements:

   > CREATE DATABASE bank;
   

   > CREATE TABLE bank.accounts (
       id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
         balance DECIMAL
     );
   

   > INSERT INTO bank.accounts (balance)
     VALUES
         (1000.50), (20000), (380), (500), (55000);
   

   > SELECT * FROM bank.accounts;
   

                      id                  | balance
   +--------------------------------------+---------+
     6f123370-c48c-41ff-b384-2c185590af2b |     380
     990c9148-1ea0-4861-9da7-fd0e65b0a7da | 1000.50
     ac31c671-40bf-4a7b-8bee-452cff8a4026 |     500
     d58afd93-5be9-42ba-b2e2-dc00dcedf409 |   20000
     e6d8f696-87f5-4d3c-a377-8e152fdc27f7 |   55000
   (5 rows)
   

3. Exit the SQL shell and delete the temporary pod:

   > \q
   

Step 4. Access the DB Console

To access the cluster's DB Console:

1. In a new terminal window, port-forward from your local machine to the cockroachdb-public service:

   $ kubectl port-forward service/cockroachdb-public 8080
   

   $ kubectl port-forward service/cockroachdb-public 8080
   

   $ kubectl port-forward service/my-release-cockroachdb-public 8080
   

   Forwarding from 127.0.0.1:8080 -> 8080
   

   Note:

   The port-forward command must be run on the same machine as the web browser in which you want to view the DB Console. If you have been running these commands from a cloud instance or other non-local shell, you will not be able to view the UI without configuring kubectl locally and running the above port-forward command on your local machine.

2. Go to http://localhost:8080.

3. In the UI, verify that the cluster is running as expected:

   • View the Node List to ensure that all nodes successfully joined the cluster.
   • Click the Databases tab on the left to verify that bank is listed.

Step 5. Simulate node failure

Based on the replicas: 3 line in the StatefulSet configuration, Kubernetes ensures that three pods/nodes are running at all times. When a pod/node fails, Kubernetes automatically creates another pod/node with the same network identity and persistent storage.

To see this in action:

1. Terminate one of the CockroachDB nodes:

   $ kubectl delete pod cockroachdb-2
   

   pod "cockroachdb-2" deleted
   

   $ kubectl delete pod cockroachdb-2
   

   pod "cockroachdb-2" deleted
   

   $ kubectl delete pod my-release-cockroachdb-2
   

   pod "my-release-cockroachdb-2" deleted
   

2. In the DB Console, the Cluster Overview will soon show one node as Suspect. As Kubernetes auto-restarts the node, watch how the node once again becomes healthy.

3. Back in the terminal, verify that the pod was automatically restarted:

   $ kubectl get pod cockroachdb-2
   

   NAME            READY     STATUS    RESTARTS   AGE
   cockroachdb-2   1/1       Running   0          12s
   

   $ kubectl get pod cockroachdb-2
   

   NAME            READY     STATUS    RESTARTS   AGE
   cockroachdb-2   1/1       Running   0          12s
   

   $ kubectl get pod my-release-cockroachdb-2
   

   NAME                       READY     STATUS    RESTARTS   AGE
   my-release-cockroachdb-2   1/1       Running   0          44s
   

Step 6. Add nodes

1. Use the kubectl scale command to add a pod for another CockroachDB node:

   $ kubectl scale statefulset cockroachdb --replicas=4
   

   statefulset "cockroachdb" scaled
   

   $ kubectl scale statefulset my-release-cockroachdb --replicas=4
   

   statefulset "my-release-cockroachdb" scaled
   

2. Verify that the pod for a fourth node, cockroachdb-3, was added successfully:

   $ kubectl get pods
   

   NAME                      READY     STATUS    RESTARTS   AGE
   cockroachdb-0             1/1       Running   0          28m
   cockroachdb-1             1/1       Running   0          27m
   cockroachdb-2             1/1       Running   0          10m
   cockroachdb-3             1/1       Running   0          5s
   example-545f866f5-2gsrs   1/1       Running   0          25m
   

   NAME                                 READY     STATUS    RESTARTS   AGE
   my-release-cockroachdb-0             1/1       Running   0          28m
   my-release-cockroachdb-1             1/1       Running   0          27m
   my-release-cockroachdb-2             1/1       Running   0          10m
   my-release-cockroachdb-3             1/1       Running   0          5s
   example-545f866f5-2gsrs              1/1       Running   0          25m
   

Step 7. Remove nodes

To safely remove a node from your cluster, you must first decommission the node and only then adjust the spec.replicas value of your StatefulSet configuration to permanently remove it. This sequence is important because the decommissioning process lets a node finish in-flight requests, rejects any new requests, and transfers all range replicas and range leases off the node.

1. Launch a temporary interactive pod and use the cockroach node status command to get the internal IDs of nodes:

   $ kubectl run cockroachdb -it \
   --image=cockroachdb/cockroach:v22.2.19 \
   --rm \
   --restart=Never \
   -- node status \
   --insecure \
   --host=cockroachdb-public
   

     id |               address                                     | build  |            started_at            |            updated_at            | is_available | is_live
   +----+---------------------------------------------------------------------------------+--------+----------------------------------+----------------------------------+--------------+---------+
      1 | cockroachdb-0.cockroachdb.default.svc.cluster.local:26257 | v22.2.19 | 2018-11-29 16:04:36.486082+00:00 | 2018-11-29 18:24:24.587454+00:00 | true         | true
      2 | cockroachdb-2.cockroachdb.default.svc.cluster.local:26257 | v22.2.19 | 2018-11-29 16:55:03.880406+00:00 | 2018-11-29 18:24:23.469302+00:00 | true         | true
      3 | cockroachdb-1.cockroachdb.default.svc.cluster.local:26257 | v22.2.19 | 2018-11-29 16:04:41.383588+00:00 | 2018-11-29 18:24:25.030175+00:00 | true         | true
      4 | cockroachdb-3.cockroachdb.default.svc.cluster.local:26257 | v22.2.19 | 2018-11-29 17:31:19.990784+00:00 | 2018-11-29 18:24:26.041686+00:00 | true         | true
   (4 rows)
   

   $ kubectl run cockroachdb -it \
   --image=cockroachdb/cockroach:v22.2.19 \
   --rm \
   --restart=Never \
   -- node status \
   --insecure \
   --host=my-release-cockroachdb-public
   

     id |                                     address                                     | build  |            started_at            |            updated_at            | is_available | is_live
   +----+---------------------------------------------------------------------------------+--------+----------------------------------+----------------------------------+--------------+---------+
      1 | my-release-cockroachdb-0.my-release-cockroachdb.default.svc.cluster.local:26257 | v22.2.19 | 2018-11-29 16:04:36.486082+00:00 | 2018-11-29 18:24:24.587454+00:00 | true         | true
      2 | my-release-cockroachdb-2.my-release-cockroachdb.default.svc.cluster.local:26257 | v22.2.19 | 2018-11-29 16:55:03.880406+00:00 | 2018-11-29 18:24:23.469302+00:00 | true         | true
      3 | my-release-cockroachdb-1.my-release-cockroachdb.default.svc.cluster.local:26257 | v22.2.19 | 2018-11-29 16:04:41.383588+00:00 | 2018-11-29 18:24:25.030175+00:00 | true         | true
      4 | my-release-cockroachdb-3.my-release-cockroachdb.default.svc.cluster.local:26257 | v22.2.19 | 2018-11-29 17:31:19.990784+00:00 | 2018-11-29 18:24:26.041686+00:00 | true         | true
   (4 rows)
   

2. Note the ID of the node with the highest number in its address (in this case, the address including cockroachdb-3) and use the cockroach node decommission command to decommission it:

   Note:

   It's important to decommission the node with the highest number in its address because, when you reduce the replica count, Kubernetes will remove the pod for that node.

   $ kubectl run cockroachdb -it \
   --image=cockroachdb/cockroach:v22.2.19 \
   --rm \
   --restart=Never \
   -- node decommission <node ID> \
   --insecure \
   --host=cockroachdb-public
   

   $ kubectl run cockroachdb -it \
   --image=cockroachdb/cockroach:v22.2.19 \
   --rm \
   --restart=Never \
   -- node decommission <node ID> \
   --insecure \
   --host=my-release-cockroachdb-public
   

   You'll then see the decommissioning status print to stderr as it changes:

     id | is_live | replicas | is_decommissioning |   membership    | is_draining
   -----+---------+----------+--------------------+-----------------+--------------
      4 |  true   |       73 |        true        | decommissioning |    false    
   

   Once the node has been fully decommissioned, you'll see a confirmation:

     id | is_live | replicas | is_decommissioning |   membership    | is_draining
   -----+---------+----------+--------------------+-----------------+--------------
      4 |  true   |        0 |        true        | decommissioning |    false    
   (1 row)
   
   No more data reported on target nodes. Please verify cluster health before removing the nodes.
   

3. Once the node has been decommissioned, remove a pod from your StatefulSet:

   $ kubectl scale statefulset cockroachdb --replicas=3
   

   statefulset "cockroachdb" scaled
   

   $ helm upgrade \
   my-release \
   cockroachdb/cockroachdb \
   --set statefulset.replicas=3 \
   --reuse-values
   

Step 8. Stop the cluster

• If you plan to restart the cluster, use the minikube stop command. This shuts down the minikube virtual machine but preserves all the resources you created:

  $ minikube stop
  

  Stopping local Kubernetes cluster...
  Machine stopped.
  

  You can restore the cluster to its previous state with minikube start.

• If you do not plan to restart the cluster, use the minikube delete command. This shuts down and deletes the minikube virtual machine and all the resources you created, including persistent volumes:

  $ minikube delete
  

  Deleting local Kubernetes cluster...
  Machine deleted.
  

  Tip:

  To retain logs, copy them from each pod's stderr before deleting the cluster and all its resources. To access a pod's standard error stream, run kubectl logs <podname>.

See also

Explore other core CockroachDB benefits and features:

• Replication & Rebalancing
• Fault Tolerance & Recovery
• Low Latency Multi-Region Deployment
• Serializable Transactions
• Cross-Cloud Migration
• Orchestration
• JSON Support

You might also want to learn how to orchestrate a production deployment of CockroachDB with Kubernetes.

Was this helpful?