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.14.0/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.

   • To use these defaults, apply the Operator manifest without modifying it:

     kubectl apply -f https://raw.githubusercontent.com/cockroachdb/cockroach-operator/v2.14.0/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
     

   • To change these defaults:
     1. Download the Operator manifest:

        curl -O https://raw.githubusercontent.com/cockroachdb/cockroach-operator/v2.14.0/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. Apply your local version of the Operator manifest to the cluster:

        kubectl apply -f operator.yaml
        

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.14.0/examples/example.yaml
   

   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 all Kubernetes versions that are supported by the Kubernetes project when cert-manager is used for mTLS.

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 successfully deploy, 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
   

1. To use the CockroachDB SQL client, first launch a secure pod running the cockroach binary.

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

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

3. 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)
   

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

5. Exit the SQL shell and pod:

   > \q
   

1. To use the CockroachDB SQL client, first launch a secure pod running the cockroach binary.

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

   pod/cockroachdb-client-secure created
   

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

3. 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)
   

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

5. 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.14.0/install/operator.yaml
   

   This will delete the CockroachDB cluster being run by the Operator. It intentionally does not delete:

   • The persistent volumes that were attached to the pods, to avoid the risk of data loss. Before deleting a cluster's persistent volumes, be sure to back them up. For more information, refer to Delete a Cluster's Persistent Volumes in the Kubernetes project's documentation.
   • Any secrets you may have created. For more information on managing secrets, refer to Managing Secrets Using kubectl in the Kubernetes project's documentation.

This procedure shuts down the CockroachDB cluster and deletes the resources you just created, including the logs and Prometheus and Alertmanager resources. This command intentionally does not delete:

• The persistent volumes that were attached to the pods, to avoid the risk of data loss. Before deleting a cluster's persistent volumes, be sure to back them up. For more information, refer to Delete a Cluster's Persistent Volumes in the Kubernetes project's documentation.
• Any secrets you may have created. For more information on managing secrets, refer to Managing Secrets Using kubectl in the Kubernetes project's documentation.

1. Delete the resources associated with the cockroachdb label, including the logs and Prometheus and Alertmanager resources. This command is very long; you may need to scroll your browser to read all of it.

   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
   

3. Delete the cluster's cryptographic resources.

   • If your cluster's certificates are managed using cert-manager (recommended but not default), get the names of the cluster's issuers and delete them:

     kubectl get issuer
     

     kubectl delete issuer {issuer_name}
     

   • If your cluster uses self-signed certificates (the default), get the names of any CSRs for the cluster, then delete them:

     kubectl get csr
     

     kubectl delete csr default.client.root default.{node_name}
     

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. Delete the cluster's cryptographic resources.

   • If your cluster's certificates are managed using cert-manager (recommended but not default), get the names of the cluster's issuers and delete them:

     kubectl get issuer
     

     kubectl delete issuer {issuer_name}
     

   • If your cluster uses self-signed certificates (the default), get the names of any CSRs for the cluster, then delete them:

     kubectl get csr
     

     kubectl delete csr default.client.root default.{node_name}