Christopher Bradford

When you are designing and building a cloud-native application, you are probably thinking about deploying it with Kubernetes. What about the database? That can get a bit more complicated as you weigh out the tradeoffs of elasticity, scale, and self-healing requirements versus maintaining servers and the long term operations required. Apache Cassandra™ ticks the first three boxes easily, but what about the operational burden of managing Cassandra? That’s where the cloud-native, <a href="/products/datastax-astra">DataStax Astra</a>, helps both operators and developers. But what makes it easy for deployments on Kubernetes to access the Astra managed service?

Today, we are releasing the DataStax Astra Service Broker, so you can seamlessly integrate Cassandra into your Kubernetes deployments and leave the operations to somebody else. In this article, we’ll show you exactly how easy it is to use Astra with Kubernetes, and make you wonder why anyone would do anything else.

For those unfamiliar with DataStax Astra, it is a Database-as-a-Service (DBaaS) platform that lets you use Cassandra without the operations overhead. From the web interface, you can fill out a few fields, click a button and in a short time you will have a fully functioning database ready to scale on demand. When building cloud-native applications, combining services that scale in a similar fashion reduces the amount of tradeoffs initially and the dreaded technical debt later. Astra is cloud agnostic and gives you full portability between one or more cloud platforms. Just like how Kubernetes allows you to run where and how you want, Astra will be right there as a highly reliable data layer.

When you are building cloud-native applications with Kubernetes, choices still have to be made. When spinning up an instance of your application how can you provision that data layer? How is the application made aware of the data connection’s information including endpoints, security certificates, and credentials? The <a href="https://www.openservicebrokerapi.org/">Open Service Broker API</a> and <a href="https://svc-cat.io/">Service Catalog</a> operator for Kubernetes define an interface for provisioning and binding of services like DataStax Astra. For DataStax this means standing up a Service Broker for translating requests from the Open Service Broker API specification to our <a href="https://docs.astra.datastax.com/docs/manage-database-with-service-account">Astra DevOps API</a>. The Service Catalog handles monitoring the Kubernetes API for lifecycle requests and forwarding them to the Astra Service Broker. Once an instance is provisioned it may then be bound, at which point service information is retrieved and stored in a Kubernetes secret.

In a continuous delivery environment, placing these custom resources alongside your code makes it trivial to push them to Kubernetes with each deployment of your application. Let's take a look at how easy it is to integrate the Astra Service Broker.

You’ll need a few prerequisites to follow this walkthrough

<ul>
	<li>A running Kubernetes cluster you can access via command line.</li>
	<li><a href="https://helm.sh/docs/intro/install/">Helm</a> package manager for Kubernetes.</li>
	<li><a href="https://svc-cat.io/docs/install/#installing-the-service-catalog-cli">Service Catalog</a> command line interface.</li>
	<li>A <a href="http://astra.datastax.com">DataStax Astra</a> account with <a href="https://docs.astra.datastax.com/docs/creating-a-new-service-account-for-your-database">service account credentials</a> created.</li>
</ul>

First, start by ensuring the Service Catalog operator is installed in your local cluster. This only needs to be done once per Kubernetes cluster.

<pre>
<code>helm repo add svc-cat https://svc-catalog-charts.storage.googleapis.com
helm repo update
helm install catalog svc-cat/catalog --namespace catalog --create-namespace</code></pre>

Next, create a Kubernetes secret with the service account information from Astra. For this, you will need to go to the service account area of Astra and copy the credentials (<a href="https://docs.astra.datastax.com/docs/creating-a-new-service-account-for-your-database">instructions</a>). What you get is a small snippet of JSON with all the important info needed to create the secret in Kubernetes. It requires a little Command-line Fu but rest-assured, you only have to do this once. You just need to replace the part labeled <code>&lt;service_account_creds&gt;</code>

<pre>
<code>kubectl create secret generic astra-creds --from-literal=username=unused --from-literal=password=`echo '&lt;service_account_creds&gt;'| base64`</code></pre>

You then register the broker via a ServiceBroker custom resource. For brevity we will leverage the helpful svcat command-line tool.

<pre>
<code>$ svcat register astra --url https://broker.astra.datastax.com/ --basic-secret astra-creds</code></pre>

With this information, Service Catalog automatically queries for available services on Astra and displays all the plans or service tiers.

<pre>
<code>$ svcat marketplace
 	CLASS 	PLANS 	DESCRIPTION 	 
+----------------+-----------+------------------------------------------------+
 astra-database A10 	DataStax Astra, built on the 	 
 	best distribution of Apache 	 
 	Cassandra™, provides the 	 
 	ability to develop and deploy 	 
 	data-driven applications 	 
 	with a cloud-native service, 	 
 	without the hassles of 	 
 	database and infrastructure 	 
 	administration. 	 
 	A20 	 	 
 	developer 	
 
$ svcat get plans
	NAME 	NAMESPACE 	CLASS 	DESCRIPTION 	 
+-----------+-----------+----------------+------------------------------------+
 A10 	default 	astra-database 6 vCPU, 24GB DRAM, 20GB 	 
 	Storage 	 
 A20 	default 	astra-database 12 vCPU, 48GB DRAM, 40GB 	 
 	Storage 	 	 
 developer default 	astra-database Free tier: Try Astra with 	 
 	no obligation. Get 5 GB of 	 
 	storage, free forever.</code></pre>

Note the information here is a small subset of what is available. Listings have been reduced for space.

With this information you may now provision your database instance using svcat or kubectl:

<pre>
<code>$ svcat provision devdb --class astra-database --plan developer --params-json '{
 "cloud_provider": "GCP",
 "region": "us-east1",
 "capacity_units": 1,
 "keyspace": "sample_keyspace"
}'</code></pre>

You should see the following output:

<pre>
<code> Name: 	devdb 
 Namespace: default 
 Status: 	 
 Class: 	 
 Plan: 	 

Parameters:
 capacity_units: 1
 cloud_provider: GCP
 keyspace: sample_keyspace
 region: us-east1</code></pre>

For <code>kubectl</code> create a file called <code>astra.yaml</code> to describe the type of instance you need:

<pre>
<code>apiVersion: servicecatalog.k8s.io/v1beta1
kind: ServiceInstance
metadata:
 name: devdb
 namespace: default
spec:
 parameters:
 capacity_units: 1
 cloud_provider: GCP
 keyspace: petclinic
 region: us-east1
 serviceClassExternalName: astra-database
 servicePlanExternalName: developer

kubectl apply -f astra.yaml</code></pre>

Service catalog handles the provisioning and communication with Astra. After a couple minutes you can check the instance status with svcat and kubectl:

<pre>
<code>$ svcat get instances
 NAME	NAMESPACE CLASS PLAN STATUS 
+-------+-----------+-------+------+--------+
 devdb default 	Ready 
$ kubectl get serviceinstances devdb
NAME	CLASS 	PLAN 	STATUS AGE
devdb ServiceClass/26b3fbe6-0c18-5140-8ac6-87d03b5b4148 1c9bb5ac-6609-5af5-a747-ecf1d093cc7f Ready	3m20s</code></pre>

The process of retrieving service credentials is known as binding. Here’s how you bind the devdb instance:

<pre>
<code>$ svcat bind devdb
 Name: 	devdb 
 Namespace: default 
 Status: 	 
 Secret: 	devdb 
 Instance:	devdb 

Parameters:
 No parameters defined</code></pre>

With kubectl this may be described with a ServiceBinding resource, such as: <code>astra-service-binding.yaml</code>:

<pre>
<code>apiVersion: servicecatalog.k8s.io/v1beta1
kind: ServiceBinding
metadata:
 name: devdb
spec:
 externalID: 9a412237-1c66-4d43-b5e6-cd92d7b61779
 instanceRef:
	name: devdb
 secretName: devdb

kubectl apply -f astra-service-binding.yaml</code></pre>

After receiving this request Service Catalog handles retrieving the credentials from Astra and placing them within a local kubernetes secret at the same name as our binding. In this example, this is called <code>devdb</code>:

<pre>
<code>$ kubectl get secrets devdb -o yaml
apiVersion: v1
data:
 cql_port: 9042
 external_endpoint: ...astra.datastax.com
 encoded_external_bundle: BASE64_ENCODED_CONNECT_BUNDLE_ZIP
 internal_endpoint: ...internal.astra.datastax.com
 encoded_internal_bundle: BASE64_ENCODED_CONNECT_BUNDLE_ZIP
 keyspace: sample_keyspace
 local_datacenter: dc-1
 password: REDACTED
 port: 1337
 tls_ca_cert: PEM_ENCODED_CA_CERT
 tls_cert: PEM_ENCODED_APPLICATION_CERT
 tls_key: PEM_ENCODED_APPLICATION_KEY
 username: REDACTED
kind: Secret
metadata:
 name: devdb
type: Opaque</code></pre>

This is all of the information required to configure the Cassandra driver for secure connectivity to Astra. Instead of manually spinning up nodes, wiring up monitoring, and sourcing infrastructure, Apache Cassandra is available on-demand through a simple GitOps interface. If you need to update the cluster to increase capacity, it is a simple YAML change that is checked into your repository and deployed with CD tools. The only "hard work" here is a call to <code>kubectl apply</code>. With a running database head over to the <a href="https://github.com/spring-petclinic/spring-petclinic-reactive/">Spring Reactive Pet Clinic</a> for a reference Java application which is configured to use the Secret returned by Astra Service Broker.

For more learning check out the <a href="/dev/kubernetes">Kubernetes and Cassandra</a> and <a href="/cloud-native">cloud-native data</a> pages on our developer site <a href="/dev">datastax.com/dev</a>. If you are interested in receiving updates on our new Cassandra on Kubernetes certification program, or becoming a Cassandra certified developer or administrator please visit <a href="/dev/certifications">https://datastax.com/dev/certifications</a>.

Build and scale cloud native apps

Discover the benefits of DBaaS and why your apps deserve an upgrade.

Learn about NoSQL Databases

Learn about NoSQL databases with Apache Cassandra and Astra DB.

2022 Recap: A Year for Customers, Community, and Real-Time Data

Highlights from 2022 and a glimpse into the year ahead.

ViewingTechnical How To’s

Announcing the Astra Service Broker: Tradeoff-Free Cassandra in Kubernetes

Sign up for our Developer Newsletter

Share