Orchestrate CockroachDB with Kubernetes (Insecure)

On this page

This page shows you how to orchestrate the deployment and management of an insecure 3-node CockroachDB cluster with Kubernetes, using the StatefulSet feature.

Before You Begin

Before getting started, it's helpful to review some Kubernetes-specific terminology and current limitations.

Kubernetes Terminology

Limitations

Kubernetes version

Kubernetes 1.18 or higher is required in order to use our most up-to-date configuration files. Earlier Kubernetes releases do not support some of the options used in our configuration files. If you need to run on an older version of Kubernetes, we have kept around configuration files that work on older Kubernetes releases in the versioned subdirectories of https://github.com/cockroachdb/cockroach/tree/master/cloud/kubernetes (e.g., v1.7).

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.

Step 1. Choose your deployment environment

Choose whether you want to orchestrate CockroachDB with Kubernetes using the hosted Google Kubernetes Engine (GKE) service or manually on Google Compute Engine (GCE) or AWS. The instructions below will change slightly depending on your choice.

Step 2. Start Kubernetes

Step 3. Start CockroachDB nodes

1. From your local workstation, use our cockroachdb-statefulset.yaml file to create the StatefulSet that automatically creates 3 pods, each with a CockroachDB node running inside it:

   $ kubectl create -f https://raw.githubusercontent.com/cockroachdb/cockroach/master/cloud/kubernetes/cockroachdb-statefulset.yaml
   

   service "cockroachdb-public" created
   service "cockroachdb" created
   poddisruptionbudget "cockroachdb-budget" created
   statefulset "cockroachdb" created
   

2. Confirm that three pods are Running successfully. Note that they will not be considered Ready until after the cluster has been initialized:

   $ kubectl get pods
   

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

3. Confirm that the persistent volumes and corresponding claims were created successfully for all three pods:

   $ kubectl get persistentvolumes
   

   NAME                                       CAPACITY   ACCESSMODES   RECLAIMPOLICY   STATUS    CLAIM                           REASON    AGE
   pvc-52f51ecf-8bd5-11e6-a4f4-42010a800002   1Gi        RWO           Delete          Bound     default/datadir-cockroachdb-0             26s
   pvc-52fd3a39-8bd5-11e6-a4f4-42010a800002   1Gi        RWO           Delete          Bound     default/datadir-cockroachdb-1             27s
   pvc-5315efda-8bd5-11e6-a4f4-42010a800002   1Gi        RWO           Delete          Bound     default/datadir-cockroachdb-2             27s
   

Step 4. Initialize the cluster

1. Use our cluster-init.yaml file to perform a one-time initialization that joins the nodes into a single cluster:

   $ kubectl create -f https://raw.githubusercontent.com/cockroachdb/cockroach/master/cloud/kubernetes/cluster-init.yaml
   

   job "cluster-init" created
   

2. Confirm that cluster initialization has completed successfully. The job should be considered successful and the CockroachDB pods should soon be considered Ready:

   $ kubectl get job cluster-init
   

   NAME           DESIRED   SUCCESSFUL   AGE
   cluster-init   1         1            2m
   

   $ kubectl get pods
   

   NAME            READY     STATUS    RESTARTS   AGE
   cockroachdb-0   1/1       Running   0          3m
   cockroachdb-1   1/1       Running   0          3m
   cockroachdb-2   1/1       Running   0          3m
   

Step 5. Test the cluster

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

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

2. Run some basic CockroachDB SQL statements:

   > CREATE DATABASE bank;
   

   > CREATE TABLE bank.accounts (id INT PRIMARY KEY, balance DECIMAL);
   

   > INSERT INTO bank.accounts VALUES (1, 1000.50);
   

   > SELECT * FROM bank.accounts;
   

   +----+---------+
   | id | balance |
   +----+---------+
   |  1 |  1000.5 |
   +----+---------+
   (1 row)
   

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

   > \q
   

Step 6. Monitor the cluster

To access the cluster's Admin UI:

1. Port-forward from your local machine to one of the pods:

   $ kubectl port-forward cockroachdb-0 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 Admin UI. 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:

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

Step 7. 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
   

2. In the Admin UI, the Summary panel 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
   

Step 8. Scale the cluster

The Kubernetes cluster we created contains 3 nodes that pods can be run on. To ensure that you do not have two pods on the same node (as recommended in our production best practices), you need to add a new node and then edit your StatefulSet configuration to add another pod.

1. Add a worker node:

   • On GKE, resize your cluster.
   • On GCE, resize your Managed Instance Group.
   • On AWS, resize your Auto Scaling Group.

2. Use the kubectl scale command to add a pod to your StatefulSet:

   $ kubectl scale statefulset cockroachdb --replicas=4
   

   statefulset "cockroachdb" scaled
   

3. Verify that a fourth pod was added successfully:

   $ kubectl get pods
   

   NAME            READY     STATUS    RESTARTS   AGE
   cockroachdb-0   1/1       Running   0          2h
   cockroachdb-1   1/1       Running   0          2h
   cockroachdb-2   1/1       Running   0          9m
   cockroachdb-3   1/1       Running   0          46s
   

Step 9. Upgrade the cluster

As new versions of CockroachDB are released, it's strongly recommended to upgrade to newer versions in order to pick up bug fixes, performance improvements, and new features. The general CockroachDB upgrade documentation provides best practices for how to prepare for and execute upgrades of CockroachDB clusters, but the mechanism of actually stopping and restarting processes in Kubernetes is somewhat special.

Kubernetes knows how to carry out a safe rolling upgrade process of the CockroachDB nodes. When you tell it to change the Docker image used in the CockroachDB StatefulSet, Kubernetes will go one-by-one, stopping a node, restarting it with the new image, and waiting for it to be ready to receive client requests before moving on to the next one. For more information, see the Kubernetes documentation.

1. All that it takes to kick off this process is changing the desired Docker image. To do so, pick the version that you want to upgrade to, then run the following command, replacing "VERSION" with your desired new version:

   $ kubectl patch statefulset cockroachdb --type='json' -p='[{"op": "replace", "path": "/spec/template/spec/containers/0/image", "value":"cockroachdb/cockroach:VERSION"}]'
   

   statefulset "cockroachdb" patched
   

2. If you then check the status of your cluster's pods, you should see one of them being restarted:

   $ kubectl get pods
   

   NAME            READY     STATUS        RESTARTS   AGE
   cockroachdb-0   1/1       Running       0          2m
   cockroachdb-1   1/1       Running       0          2m
   cockroachdb-2   1/1       Running       0          2m
   cockroachdb-3   0/1       Terminating   0          1m
   

3. This will continue until all of the pods have restarted and are running the new image. To check the image of each pod to determine whether they've all be upgraded, run:

   $ kubectl get pods -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.spec.containers[0].image}{"\n"}'
   

   cockroachdb-0   cockroachdb/cockroach:v1.1.9
   cockroachdb-1   cockroachdb/cockroach:v1.1.9
   cockroachdb-2   cockroachdb/cockroach:v1.1.9
   cockroachdb-3   cockroachdb/cockroach:v1.1.9
   

4. If this was an upgrade between minor or major versions (e.g., between v1.0.x and v1.1.y or between v1.1.y and v2.0.z), then you'll want to finalize the upgrade if you're happy with the new version. Assuming you upgraded to the v1.1 minor version, you'd run:

   $ kubectl exec -it cockroachdb-0 -- ./cockroach sql --insecure -e "SET CLUSTER SETTING version = '1.1';"
   

   SET CLUSTER SETTING
   

Step 10. Stop the cluster

To shut down the CockroachDB cluster:

1. Delete all of the resources you created, including the logs and remote persistent volumes:

   $ kubectl delete pods,statefulsets,services,persistentvolumeclaims,persistentvolumes,poddisruptionbudget,jobs \
   -l app=cockroachdb
   

   pod "cockroachdb-0" deleted
   pod "cockroachdb-1" deleted
   pod "cockroachdb-2" deleted
   pod "cockroachdb-3" deleted
   statefulset "cockroachdb" deleted
   service "cockroachdb" deleted
   service "cockroachdb-public" deleted
   persistentvolumeclaim "datadir-cockroachdb-0" deleted
   persistentvolumeclaim "datadir-cockroachdb-1" deleted
   persistentvolumeclaim "datadir-cockroachdb-2" deleted
   persistentvolumeclaim "datadir-cockroachdb-3" deleted
   poddisruptionbudget "cockroachdb-budget" deleted
   

2. Stop Kubernetes:

   $ gcloud container clusters delete cockroachdb
   

   $ cluster/kube-down.sh
   

   $ cluster/kube-down.sh
   

   Warning:

   If you stop Kubernetes without first deleting the persistent volumes, they will still exist in your cloud project.

See Also

• Kubernetes Performance Guide
• Production Checklist
• Manual Deployment
• Orchestrated Deployment
• Monitoring and Alerting
• Local Deployment

Was this helpful?