Deploy CockroachDB in a Single Kubernetes Cluster

Install the Operator

1. Apply the custom resource definition (CRD) for the Operator:

   $ kubectl apply -f https://raw.githubusercontent.com/cockroachdb/cockroach-operator/v2.15.1/install/crds.yaml
   

   customresourcedefinition.apiextensions.k8s.io/crdbclusters.crdb.cockroachlabs.com created
   

2. By default, the Operator is configured to install in the cockroach-operator-system namespace and to manage CockroachDB instances for all namespaces on the cluster.

   If you'd like to change either of these defaults:

   1. Download the Operator manifest:

      $ curl -O https://raw.githubusercontent.com/cockroachdb/cockroach-operator/v2.15.1/install/operator.yaml
      

   2. To use a custom namespace, edit all instances of namespace: cockroach-operator-system with your desired namespace.

   3. To limit the namespaces that will be monitored, set the WATCH_NAMESPACE environment variable in the Deployment pod spec. This can be set to a single namespace, or a comma-delimited set of namespaces. When set, only those CrdbCluster resources in the supplied namespace(s) will be reconciled.

   4. Instead of using the command below, apply your local version of the Operator manifest to the cluster:

      $ kubectl apply -f operator.yaml
      

   If you want to use the default namespace settings:

   $ kubectl apply -f https://raw.githubusercontent.com/cockroachdb/cockroach-operator/v2.15.1/install/operator.yaml
   

   clusterrole.rbac.authorization.k8s.io/cockroach-database-role created
   serviceaccount/cockroach-database-sa created
   clusterrolebinding.rbac.authorization.k8s.io/cockroach-database-rolebinding created
   role.rbac.authorization.k8s.io/cockroach-operator-role created
   clusterrolebinding.rbac.authorization.k8s.io/cockroach-operator-rolebinding created
   clusterrole.rbac.authorization.k8s.io/cockroach-operator-role created
   serviceaccount/cockroach-operator-sa created
   rolebinding.rbac.authorization.k8s.io/cockroach-operator-default created
   deployment.apps/cockroach-operator created
   

3. Set your current namespace to the one used by the Operator. For example, to use the Operator's default namespace:

   $ kubectl config set-context --current --namespace=cockroach-operator-system
   

4. Validate that the Operator is running:

   $ kubectl get pods
   

   NAME                                  READY   STATUS    RESTARTS   AGE
   cockroach-operator-6f7b86ffc4-9ppkv   1/1     Running   0          54s
   

Initialize the cluster

1. Download example.yaml, a custom resource that tells the Operator how to configure the Kubernetes cluster.

   $ curl -O https://raw.githubusercontent.com/cockroachdb/cockroach-operator/v2.15.1/examples/example.yaml
   

   Note:

   By default, this custom resource specifies CPU and memory resources that are appropriate for the virtual machines used in this deployment example. On a production cluster, you should substitute values that are appropriate for your machines and workload. For details on configuring your deployment, see Configure the Cluster.

   Note:

   By default, the Operator will generate and sign 1 client and 1 node certificate to secure the cluster. This means that if you do not provide a CA, a cockroach-generated CA is used. If you want to authenticate using your own CA, specify the generated secrets in the custom resource before proceeding to the next step.

2. Apply example.yaml:

   $ kubectl apply -f example.yaml
   

   The Operator will create a StatefulSet and initialize the nodes as a cluster.

   crdbcluster.crdb.cockroachlabs.com/cockroachdb created
   

3. Check that the pods were created:

   $ kubectl get pods
   

   NAME                                  READY   STATUS    RESTARTS   AGE
   cockroach-operator-6f7b86ffc4-9t9zb   1/1     Running   0          3m22s
   cockroachdb-0                         1/1     Running   0          2m31s
   cockroachdb-1                         1/1     Running   0          102s
   cockroachdb-2                         1/1     Running   0          46s
   

   Each pod should have READY status soon after being created.

Configure the cluster

1. Download and modify our StatefulSet configuration:

   $ curl -O https://raw.githubusercontent.com/cockroachdb/cockroach/master/cloud/kubernetes/bring-your-own-certs/cockroachdb-statefulset.yaml
   

2. Update secretName with the name of the corresponding node secret.

   The secret names depend on your method for generating secrets. For example, if you follow the below steps using cockroach cert, use this secret name:

   secret:
     secretName: cockroachdb.node
   

3. The StatefulSet configuration deploys CockroachDB into the default namespace. To use a different namespace, search for kind: RoleBinding and change its subjects.namespace property to the name of the namespace. Otherwise, a failed to read secrets error occurs when you attempt to follow the steps in Initialize the cluster.

Create certificates

1. Create two directories:

   $ mkdir certs my-safe-directory
   

   Directory	Description
   certs	You'll generate your CA certificate and all node and client certificates and keys in this directory.
   my-safe-directory	You'll generate your CA key in this directory and then reference the key when generating node and client certificates.

2. Create the CA certificate and key pair:

   $ cockroach cert create-ca \
   --certs-dir=certs \
   --ca-key=my-safe-directory/ca.key
   

3. Create a client certificate and key pair for the root user:

   $ cockroach cert create-client \
   root \
   --certs-dir=certs \
   --ca-key=my-safe-directory/ca.key
   

4. Upload the client certificate and key to the Kubernetes cluster as a secret:

   $ kubectl create secret \
   generic cockroachdb.client.root \
   --from-file=certs
   

   secret/cockroachdb.client.root created
   

5. Create the certificate and key pair for your CockroachDB nodes:

   $ cockroach cert create-node \
   localhost 127.0.0.1 \
   cockroachdb-public \
   cockroachdb-public.default \
   cockroachdb-public.default.svc.cluster.local \
   *.cockroachdb \
   *.cockroachdb.default \
   *.cockroachdb.default.svc.cluster.local \
   --certs-dir=certs \
   --ca-key=my-safe-directory/ca.key
   

6. Upload the node certificate and key to the Kubernetes cluster as a secret:

   $ kubectl create secret \
   generic cockroachdb.node \
   --from-file=certs
   

   secret/cockroachdb.node created
   

7. Check that the secrets were created on the cluster:

   $ kubectl get secrets
   

   NAME                      TYPE                                  DATA   AGE
   cockroachdb.client.root   Opaque                                3      41m
   cockroachdb.node          Opaque                                5      14s
   default-token-6qjdb       kubernetes.io/service-account-token   3      4m
   

Initialize the cluster

1. Use the config file you downloaded to create the StatefulSet that automatically creates 3 pods, each running a CockroachDB node:

   $ kubectl create -f cockroachdb-statefulset.yaml
   

   serviceaccount/cockroachdb created
   role.rbac.authorization.k8s.io/cockroachdb created
   rolebinding.rbac.authorization.k8s.io/cockroachdb created
   service/cockroachdb-public created
   service/cockroachdb created
   poddisruptionbudget.policy/cockroachdb-budget created
   statefulset.apps/cockroachdb created
   

2. Initialize the CockroachDB cluster:

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

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

      $ kubectl get pv
      

      NAME                                       CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                           STORAGECLASS   REASON   AGE
      pvc-9e435563-fb2e-11e9-a65c-42010a8e0fca   100Gi      RWO            Delete           Bound    default/datadir-cockroachdb-0   standard                51m
      pvc-9e47d820-fb2e-11e9-a65c-42010a8e0fca   100Gi      RWO            Delete           Bound    default/datadir-cockroachdb-1   standard                51m
      pvc-9e4f57f0-fb2e-11e9-a65c-42010a8e0fca   100Gi      RWO            Delete           Bound    default/datadir-cockroachdb-2   standard                51m
      

   3. Run cockroach init on one of the pods to complete the node startup process and have them join together as a cluster:

      $ kubectl exec -it cockroachdb-0 \
      -- /cockroach/cockroach init \
      --certs-dir=/cockroach/cockroach-certs
      

      Cluster successfully initialized
      

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

      $ 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
      

The CockroachDB Helm chart is compatible with Kubernetes versions 1.22 and earlier.

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.

1. Install the Helm client (version 3.0 or higher) and add the cockroachdb chart repository:

   $ helm repo add cockroachdb https://charts.cockroachdb.com/
   

   "cockroachdb" has been added to your repositories
   

2. Update your Helm chart repositories to ensure that you're using the latest CockroachDB chart:

   $ helm repo update
   

3. The cluster configuration is set in the Helm chart's values file.

   Note:

   By default, the Helm chart specifies CPU and memory resources that are appropriate for the virtual machines used in this deployment example. On a production cluster, you should substitute values that are appropriate for your machines and workload. For details on configuring your deployment, see Configure the Cluster.

   Before deploying, modify some parameters in our Helm chart's values file:

   1. Create a local YAML file (e.g., my-values.yaml) to specify your custom values. These will be used to override the defaults in values.yaml.

   2. To avoid running out of memory when CockroachDB is not the only pod on a Kubernetes node, you must set memory limits explicitly. This is because CockroachDB does not detect the amount of memory allocated to its pod when run in Kubernetes. We recommend setting conf.cache and conf.max-sql-memory each to 1/4 of the memory allocation specified in statefulset.resources.requests and statefulset.resources.limits.

      Tip:

      For example, if you are allocating 8Gi of memory to each CockroachDB node, allocate 2Gi to cache and 2Gi to max-sql-memory.

      conf:
        cache: "2Gi"
        max-sql-memory: "2Gi"
      

      The Helm chart defaults to a secure deployment by automatically setting tls.enabled to true.

      Note:

      By default, the Helm chart will generate and sign 1 client and 1 node certificate to secure the cluster. To authenticate using your own CA, see Certificate management.

4. Install the CockroachDB Helm chart, specifying your custom values file.

   Provide a "release" name to identify and track this particular deployment of the chart, and override the default values with those in my-values.yaml.

   Note:

   This tutorial uses my-release as the release name. If you use a different value, be sure to adjust the release name in subsequent commands.

   Warning:

   To allow the CockroachDB pods to deploy successfully, do not set the --wait flag when using Helm commands.

   $ helm install my-release --values {custom-values}.yaml cockroachdb/cockroachdb
   

   Behind the scenes, this command uses our cockroachdb-statefulset.yaml file to create the StatefulSet that automatically creates 3 pods, each with a CockroachDB node running inside it, where each pod has distinguishable network identity and always binds back to the same persistent storage on restart.

5. Confirm that CockroachDB cluster initialization has completed successfully, with the pods for CockroachDB showing 1/1 under READY and the pod for initialization showing COMPLETED under STATUS:

   $ kubectl get pods
   

   NAME                                READY     STATUS      RESTARTS   AGE
   my-release-cockroachdb-0            1/1       Running     0          8m
   my-release-cockroachdb-1            1/1       Running     0          8m
   my-release-cockroachdb-2            1/1       Running     0          8m
   my-release-cockroachdb-init-hxzsc   0/1       Completed   0          1h
   

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

   $ kubectl get pv
   

   NAME                                       CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS    CLAIM                                      STORAGECLASS   REASON    AGE
   pvc-71019b3a-fc67-11e8-a606-080027ba45e5   100Gi      RWO            Delete           Bound     default/datadir-my-release-cockroachdb-0   standard                 11m
   pvc-7108e172-fc67-11e8-a606-080027ba45e5   100Gi      RWO            Delete           Bound     default/datadir-my-release-cockroachdb-1   standard                 11m
   pvc-710dcb66-fc67-11e8-a606-080027ba45e5   100Gi      RWO            Delete           Bound     default/datadir-my-release-cockroachdb-2   standard                 11m
   

$ kubectl create \
-f https://raw.githubusercontent.com/cockroachdb/cockroach-operator/v2.15.1/examples/client-secure-operator.yaml

1. Get a shell into the pod and start the CockroachDB built-in SQL client:

   $ kubectl exec -it cockroachdb-client-secure \
   -- ./cockroach sql \
   --certs-dir=/cockroach/cockroach-certs \
   --host=cockroachdb-public
   

   # Welcome to the CockroachDB SQL shell.
   # All statements must be terminated by a semicolon.
   # To exit, type: \q.
   #
   # Server version: CockroachDB CCL v21.1.0 (x86_64-unknown-linux-gnu, built 2021/04/23 13:54:57, go1.13.14) (same version as client)
   # Cluster ID: a96791d9-998c-4683-a3d3-edbf425bbf11
   #
   # Enter \? for a brief introduction.
   #
   root@cockroachdb-public:26257/defaultdb>
   

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.50
   (1 row)
   

3. Create a user with a password:

   > CREATE USER roach WITH PASSWORD 'Q7gc8rEdS';
   

   You will need this username and password to access the DB Console later.

4. Exit the SQL shell and pod:

   > \q
   

$ kubectl create \
-f https://raw.githubusercontent.com/cockroachdb/cockroach/master/cloud/kubernetes/bring-your-own-certs/client.yaml

pod/cockroachdb-client-secure created

1. Get a shell into the pod and start the CockroachDB built-in SQL client:

   $ kubectl exec -it cockroachdb-client-secure \
   -- ./cockroach sql \
   --certs-dir=/cockroach-certs \
   --host=cockroachdb-public
   

   # Welcome to the cockroach SQL interface.
   # All statements must be terminated by a semicolon.
   # To exit: CTRL + D.
   #
   # Client version: CockroachDB CCL v19.1.0 (x86_64-unknown-linux-gnu, built 2019/04/29 18:36:40, go1.11.6)
   # Server version: CockroachDB CCL v19.1.0 (x86_64-unknown-linux-gnu, built 2019/04/29 18:36:40, go1.11.6)
   
   # Cluster ID: 256a8705-e348-4e3a-ab12-e1aba96857e4
   #
   # Enter \? for a brief introduction.
   #
   root@cockroachdb-public:26257/defaultdb>
   

   Tip:

   This pod will continue running indefinitely, so any time you need to reopen the built-in SQL client or run any other cockroach client commands (e.g., cockroach node), repeat step 2 using the appropriate cockroach command.

   If you'd prefer to delete the pod and recreate it when needed, run kubectl delete pod cockroachdb-client-secure.

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.50
   (1 row)
   

3. Create a user with a password:

   > CREATE USER roach WITH PASSWORD 'Q7gc8rEdS';
   

   You will need this username and password to access the DB Console later.

4. Exit the SQL shell and pod:

   > \q
   

From your local workstation, use our client-secure.yaml file to launch a pod and keep it running indefinitely.

1. Download the file:

   $ curl -OOOOOOOOO \
   https://raw.githubusercontent.com/cockroachdb/helm-charts/master/examples/client-secure.yaml
   

2. In the file, set the following values:

   • spec.serviceAccountName: my-release-cockroachdb
   • spec.image: cockroachdb/cockroach: {your CockroachDB version}
   • spec.volumes[0].project.sources[0].secret.name: my-release-cockroachdb-client-secret

3. Use the file to launch a pod and keep it running indefinitely:

   $ kubectl create -f client-secure.yaml
   

   pod "cockroachdb-client-secure" created
   

4. Get a shell into the pod and start the CockroachDB built-in SQL client:

   $ kubectl exec -it cockroachdb-client-secure \
   -- ./cockroach sql \
   --certs-dir=./cockroach-certs \
   --host=my-release-cockroachdb-public
   

   # Welcome to the cockroach SQL interface.
   # All statements must be terminated by a semicolon.
   # To exit: CTRL + D.
   #
   # Client version: CockroachDB CCL v19.1.0 (x86_64-unknown-linux-gnu, built 2019/04/29 18:36:40, go1.11.6)
   # Server version: CockroachDB CCL v19.1.0 (x86_64-unknown-linux-gnu, built 2019/04/29 18:36:40, go1.11.6)
   
   # Cluster ID: 256a8705-e348-4e3a-ab12-e1aba96857e4
   #
   # Enter \? for a brief introduction.
   #
   root@my-release-cockroachdb-public:26257/defaultdb>
   

   Tip:

   This pod will continue running indefinitely, so any time you need to reopen the built-in SQL client or run any other cockroach client commands (e.g., cockroach node), repeat step 2 using the appropriate cockroach command.

   If you'd prefer to delete the pod and recreate it when needed, run kubectl delete pod cockroachdb-client-secure.

5. 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.50
   (1 row)
   

6. Create a user with a password:

   > CREATE USER roach WITH PASSWORD 'Q7gc8rEdS';
   

   You will need this username and password to access the DB Console later.

7. Exit the SQL shell and pod:

   > \q
   

1. Delete the previously created custom resource:

   $ kubectl delete -f example.yaml
   

2. Remove the Operator:

   $ kubectl delete -f https://raw.githubusercontent.com/cockroachdb/cockroach-operator/v2.15.1/install/operator.yaml
   

   This will delete the CockroachDB cluster being run by the Operator. It will not delete the persistent volumes that were attached to the pods.

   Warning:

   If you want to delete the persistent volumes and free up the storage used by CockroachDB, be sure you have a backup copy of your data. Data cannot be recovered once the persistent volumes are deleted. For more information, see the Kubernetes documentation.

1. Delete the resources associated with the cockroachdb label, including the logs and Prometheus and Alertmanager resources:

   Warning:

   This does not include deleting the persistent volumes that were attached to the pods. If you want to delete the persistent volumes and free up the storage used by CockroachDB, be sure you have a backup copy of your data. Data cannot be recovered once the persistent volumes are deleted. For more information, see the Kubernetes documentation.

   $ kubectl delete pods,statefulsets,services,poddisruptionbudget,jobs,rolebinding,clusterrolebinding,role,clusterrole,serviceaccount,alertmanager,prometheus,prometheusrule,serviceMonitor -l app=cockroachdb
   

   pod "cockroachdb-0" deleted
   pod "cockroachdb-1" deleted
   pod "cockroachdb-2" deleted
   statefulset.apps "alertmanager-cockroachdb" deleted
   statefulset.apps "prometheus-cockroachdb" deleted
   service "alertmanager-cockroachdb" deleted
   service "cockroachdb" deleted
   service "cockroachdb-public" deleted
   poddisruptionbudget.policy "cockroachdb-budget" deleted
   job.batch "cluster-init-secure" deleted
   rolebinding.rbac.authorization.k8s.io "cockroachdb" deleted
   clusterrolebinding.rbac.authorization.k8s.io "cockroachdb" deleted
   clusterrolebinding.rbac.authorization.k8s.io "prometheus" deleted
   role.rbac.authorization.k8s.io "cockroachdb" deleted
   clusterrole.rbac.authorization.k8s.io "cockroachdb" deleted
   clusterrole.rbac.authorization.k8s.io "prometheus" deleted
   serviceaccount "cockroachdb" deleted
   serviceaccount "prometheus" deleted
   alertmanager.monitoring.coreos.com "cockroachdb" deleted
   prometheus.monitoring.coreos.com "cockroachdb" deleted
   prometheusrule.monitoring.coreos.com "prometheus-cockroachdb-rules" deleted
   servicemonitor.monitoring.coreos.com "cockroachdb" deleted
   

2. Delete the pod created for cockroach client commands, if you didn't do so earlier:

   $ kubectl delete pod cockroachdb-client-secure
   

   pod "cockroachdb-client-secure" deleted
   

1. Uninstall the release:

   $ helm uninstall my-release
   

   release "my-release" deleted
   

2. Delete the pod created for cockroach client commands, if you didn't do so earlier:

   $ kubectl delete pod cockroachdb-client-secure
   

   pod "cockroachdb-client-secure" deleted
   

3. Get the names of any CSRs for the cluster:

   $ kubectl get csr
   

   NAME                                                   AGE       REQUESTOR                               CONDITION
   default.client.root                                    1h        system:serviceaccount:default:default   Approved,Issued
   default.node.my-release-cockroachdb-0                  1h        system:serviceaccount:default:default   Approved,Issued
   default.node.my-release-cockroachdb-1                  1h        system:serviceaccount:default:default   Approved,Issued
   default.node.my-release-cockroachdb-2                  1h        system:serviceaccount:default:default   Approved,Issued
   default.node.my-release-cockroachdb-3                  12m       system:serviceaccount:default:default   Approved,Issued
   node-csr-0Xmb4UTVAWMEnUeGbW4KX1oL4XV_LADpkwjrPtQjlZ4   1h        kubelet                                 Approved,Issued
   node-csr-NiN8oDsLhxn0uwLTWa0RWpMUgJYnwcFxB984mwjjYsY   1h        kubelet                                 Approved,Issued
   node-csr-aU78SxyU69pDK57aj6txnevr7X-8M3XgX9mTK0Hso6o   1h        kubelet                                 Approved,Issued
   ...
   

4. Delete any CSRs that you created:

   $ kubectl delete csr default.client.root default.node.my-release-cockroachdb-0 default.node.my-release-cockroachdb-1 default.node.my-release-cockroachdb-2 default.node.my-release-cockroachdb-3
   

   certificatesigningrequest "default.client.root" deleted
   certificatesigningrequest "default.node.my-release-cockroachdb-0" deleted
   certificatesigningrequest "default.node.my-release-cockroachdb-1" deleted
   certificatesigningrequest "default.node.my-release-cockroachdb-2" deleted
   certificatesigningrequest "default.node.my-release-cockroachdb-3" deleted
   

   Note:

   This does not delete any secrets you may have created. For more information on managing secrets, see the Kubernetes documentation.