If you don't have an Astra account, set one up - it's easy.

Go to the Astra page in your browser astra.datastax.com.

When you log in the first time you'll find yourself looking at the main Astra dashboard screen that looks like the image below. click on the Add Database button.

Configure your database by selecting the Free plan.

Next, select a provider.

Now, select a region near you for your database and click the Configure button.

Fill in the Configure and Create Database fields with the following values, then click the Create Database button.

• Database name: betterbotz
• Keyspace name: betterbotz
• Database username: betterbot
• Database password: your choice

Woot! You have an active Astra Cassandra database!

The microservices we are about to deploy will create a products table and an orders table in the betterbotz keyspace within your Astra database. If you already have these tables, this step will delete them so we can start fresh. If you do not have these tables, you can skip this step and move on to the next one.

We will delete the tables using Astra's REST API. Let's set up some environment variables we can use to access the REST API.

We'll set up a variable that contains the Astra REST endpoint URL. Copy and paste the following command into the terminal - BUT DO NOT EXECUTE THE COMMAND YET.

export ASTRA_URL=''

Now, get the REST endpoint URL from the Astra website and paste it between the quotes. From the database Summary tab, click on the Connect button.

Copy the URL by clicking as shown.

Back in the terminal, paste the URL between the single quotes. After pasting the URL, the export command will look something like the following (but the root of the URL will be different).

export ASTRA_URL='https://6d0935aa-d4e7-4609-be6b-58743e85358e-us-east1.apps.astra.datastax.com/api/rest'

With the pasted URL in place, execute the export command.

We'll create variables for the database credentials. Copy and paste the following command into the terminal

export DB_USER=''

Now, enter your Astra database username between the single quotes and execute the command.

Copy and paste the following command into the terminal

export DB_PASSWORD=''

Enter your Astra database password between the single quotes and execute the command.

Next, we want to extract the base part of the URL and store it in an environment variable named $BASEURI. Execute this sed script to do that.

export BASEURI=$(echo $ASTRA_URL | sed 's/\.com.*/\.com/')

You can inspect the result of the command here.

echo $BASEURI

The last environment variable we need is one that contains the database authorization token. We'll use the following command to retrieve the token and set the variable.

export TOKEN=$(curl --request POST --url ${BASEURI}/api/rest/v1/auth --header 'Content-Type: application/json' --data-raw "{\"username\":\"${DB_USER}\",\"password\":\"${DB_PASSWORD}\"}" | jq -r '.authToken')

With the token variable set, we can now delete the table. Click the following cURL command.

curl --request DELETE \
  --url $BASEURI/api/rest/v1/keyspaces/betterbotz/tables/products \
  --header 'accept: */*' \
  --header "x-cassandra-token: $TOKEN" | jq

If you deleted the table successfully, you should see no output. But, if the table did not exist and you tried to delete it, you may see an error like the following indicating the table was not found. Either way, you're good to go.

{
  "description": "Bad request: Unknown table 'betterbotz.products'",
  "code": 400
}

You may want to delete the orders table as well. Click the following.

curl --request DELETE \
  --url $BASEURI/api/rest/v1/keyspaces/betterbotz/tables/orders \
  --header 'accept: */*' \
  --header "x-cassandra-token: $TOKEN" | jq

Superb! We're ready to deploy the microservice!

Now, let's create our first microservice using Spring Boot.

All the code is in the spring-k8s-cassandra-microservices directory.

cd spring-k8s-cassandra-microservices

NOTE: You can check out any of the project files in the editor on the right. To open a file just click on its name. But, be aware that changes to the file save automatically, so be careful when reviewing files not to make inadvertent changes.

Let's start by compiling the code.

mvn package

While we are waiting for the compilation, let's check out the code for this microservice. You can see the structure of the entity for this service in the Product.java file.

You can see that a Product has id, name, description, price and lastUpdated fields. This service will provide the following endpoints:

• /api/products/add: Add a new product
• /api/products/search/{name}: Search products by name
• /api/products/search/{name}/{id}: Search products by name and id
• /api/products/delete/{name}: Delete products by name
• /api/products/delete/{name}/{id}: Delete product by name and id

You can check out the code for accessing Cassandra in ProductDao.java.

Let's build the Docker image for this service.

cd microservice-spring-boot
docker build -t example/spring-boot-service:1.0.0-SNAPSHOT .

Normally, we would store this image in a Docker repo, but for this example using KinD, let's just load it onto the KinD cluster nodes.

Loading the images may take a minute or so to complete. Please be patient.

kind load docker-image example/spring-boot-service:1.0.0-SNAPSHOT --name spring-boot-cluster
cd ..

Let's create a namespace for this service to keep it organized and decoupled from the other services.

kubectl create ns spring-boot-service

We need to set up the credentials for accessing the Astra database. Astra provides a secure connection bundle you will want to download. Here's the command, but notice you will need to replace <paste link here> with a link to the secure bundle. Copy this command and paste it in the terminal window, but DO NOT EXECUTE THE COMMAND YET!!!!!!

curl -L "<paste link here>" > creds.zip

To get the link to the secure connection bundle, on the Astra dashboard page, click on the CONNECT button.

Now, select the Driver Connection Method. Then, right-click on the Download Secure Connection button and select Copy Link Address. This places the link to the secure connection bundle on the clipboard, which you will now paste into the curl command. Note that this link is time-sensitive, so you need to complete the next couple of steps without delay.

Now, go back to the terminal tab. Paste the link (the one you just copied) into the curl command as indicated - be sure to include the double quotes. The curl command with the link will look something like this.

Once you have pasted the link, execute the curl command.

Let's create a couple of variables to hold the database username and password to make the next couple of commands easy. If you already set up these variables in the previous step, you don't need to do it again. Otherwise, copy the following command. Paste it into the terminal. Then, replace <place username here> with the username you supplied when you created the database.

DB_USER="<place username here>"

Now, if you have not already set up the variable for the password, use the following to set the password variable.

DB_PASSWORD="<place password here>"

Next, we'll store the database credentials as Kubernetes secrets so our service can use them.

kubectl -n spring-boot-service create secret generic db-secret --from-literal=username=$DB_USER --from-literal=password=$DB_PASSWORD
kubectl -n spring-boot-service create secret generic astracreds --from-file=secure-connect-bundle=creds.zip

Now, we are ready to deploy the service.

kubectl -n spring-boot-service apply -f deploy/spring-boot

We'll create another variable with the pod ID for later reference.

BOOT_SERVICE_POD=$(kubectl -n spring-boot-service get pods | tail -n 1 | cut -f 1 -d ' ')

At this point, we would like to test our service. In a normal Kubernetes cluster, we would use port-forwarding to allow us to access the service from our local host. But using kind, we can set up a proxy that will allow us to access the service from outside the cluster.

Start the proxy in second terminal by clicking on the following.

kubectl proxy

We'll leave the proxy running in terminal 2 and switch back to terminal 1 by clicking on the following.

echo "Welcome back to Terminal 1!"

The proxy gives us a base URL to the service. We'll save this base URL in a variable so we can use it for several different accesses.

BOOT_BASE_URL=http://localhost:8001/api/v1/namespaces/spring-boot-service/pods/$BOOT_SERVICE_POD/proxy

NOTE: In a regular Kubernetes cluster (not running on KinD or proxy), you could set the base URL as BOOT_BASE_URL=http://localhost:8083. You would also need to forward the port: kubectl -n spring-boot-service port-forward $BOOT_SERVICE_POD 8083:8083

Let's make sure the pod is up and running. Click the following to start watching the state of the pod.

watch kubectl get pods -n spring-boot-service

Wait for the STATUS to be RUNNING. Then, you can exit the watch loop by clicking the following, which sends a Ctrl-C to the terminal.

echo "Exiting watch loop"

Now we are ready to try the service. Let's start by adding a couple of products.

curl -X POST -H "Content-Type: application/json" -d '{"name": "mobile", "id":"123e4567-e89b-12d3-a456-556642440000", "description":"iPhone", "price":"500.00"}' $BOOT_BASE_URL/api/products/add
curl -X POST -H "Content-Type: application/json" -d '{"name": "mobile", "id":"123e4567-e89b-12d3-a456-556642440001", "description":"Android", "price":"600.00"}' $BOOT_BASE_URL/api/products/add

We can search for a product by name.

curl $BOOT_BASE_URL/api/products/search/mobile | jq

We can also search by name and ID.

curl $BOOT_BASE_URL/api/products/search/mobile/123e4567-e89b-12d3-a456-556642440001 | jq

We can even use the API to delete a product.

curl -X DELETE $BOOT_BASE_URL/api/products/delete/mobile/123e4567-e89b-12d3-a456-556642440001

Excellent! You have a running Spring Boot microservice talking to Cassandra!

Let's create a second microservice using Spring Data Cassandra. This service will handle orders by providing the following:

• /api/orders/add: Add a new order
• /api/orders/search/order-by-id?{orderId}: Search orders by id
• /api/products/search/order-by-product-id?{orderId}&{productId}: Search orders by orderid and productid
• /api/orders/search/name-and-price-only?{orderId}: Search orders by id and only return product name and price
• /api/products/delete/order?{orderId}: Delete orders by id
• /api/products/delete/product-from-order?{orderId}&{productId}: Delete product from order

Here's the code for the Order entity.

We see that Order has key, productQuantity, productName, productPrice and addedToOrderTimestamp fields.

Notice how the database access looks different here - we're using Spring Data Cassandra!

Since we compiled the code in the previous step, we are ready to build the docker image.

cd microservice-spring-data
docker build -t example/spring-data-service:1.0.0-SNAPSHOT .

Again, let's share this docker image with the nodes in the cluster, which may take a minute. Please be patient.

kind load docker-image example/spring-data-service:1.0.0-SNAPSHOT --name spring-boot-cluster
cd ..

We'll create a namespace for this service.

kubectl create ns spring-data-service

We'll use the same Astra credentials we set up in the previous step to create the secrets for this service.

kubectl -n spring-data-service create secret generic db-secret --from-literal=username=$DB_USER --from-literal=password=$DB_PASSWORD
kubectl -n spring-data-service create secret generic astracreds --from-file=secure-connect-bundle=creds.zip

Now, we are ready to deploy the service.

kubectl -n spring-data-service apply -f deploy/spring-data

We'll also set up a variable with the pod ID for later reference.

DATA_SERVICE_POD=$(kubectl -n spring-data-service get pods | tail -n 1 | cut -f 1 -d ' ')

We'll set up a variable for the base URL of the service.

DATA_BASE_URL=http://localhost:8001/api/v1/namespaces/spring-data-service/pods/$DATA_SERVICE_POD/proxy

NOTE: In a regular Kubernetes cluster (not running on KinD or proxy), you could set the base URL as DATA_BASE_URL=http://localhost:8081. You would also need to forward the port: kubectl -n spring-data-service port-forward $DATA_SERVICE_POD 8081:8081

We'll wait for the pod to be running. Click the following to start a watch loop.

watch kubectl get pods -n spring-data-service

Once the STATUS is RUNNING, exit the watch loop by clicking the following, which sends a Ctrl-C to the terminal.

echo "Exiting the watch loop"

Let's use the service to create an order with two products.

curl -H "Content-Type: application/json" -d '{"key": {"orderId":"123e4567-e89b-12d3-a456-556642440000", "productId":"123e4567-e89b-12d3-a456-556642440000"}, "productName":"iPhone", "productPrice":"500.00", "productQuantity":1, "addedToOrderTimestamp": "2020-04-12T11:21:59.001+0000"}' $DATA_BASE_URL/api/orders/add | jq

curl -H "Content-Type: application/json" -d '{"key": {"orderId":"123e4567-e89b-12d3-a456-556642440000", "productId":"123e4567-e89b-12d3-a456-556642440001"}, "productName":"Android", "productPrice":"600.00", "productQuantity":1, "addedToOrderTimestamp": "2020-04-12T11:22:59.001+0000"}' $DATA_BASE_URL/api/orders/add | jq

We can search for an order by ID.

curl $DATA_BASE_URL/api/orders/search/order-by-id?orderId=123e4567-e89b-12d3-a456-556642440000 | jq

Here's a query to search by order ID and product ID.

curl "$DATA_BASE_URL/api/orders/search/order-by-product-id?orderId=123e4567-e89b-12d3-a456-556642440000&productId=123e4567-e89b-12d3-a456-556642440000" | jq

In this query, we only want the name and price (notice that the other fields are null).

curl $DATA_BASE_URL/api/orders/search/name-and-price-only?orderId=123e4567-e89b-12d3-a456-556642440000 | jq

Here's a query that shows how to use a projection with Spring Data REST (notice that the other fields don't appear).

curl "$DATA_BASE_URL/api/orders/search/name-and-price-only?orderId=123e4567-e89b-12d3-a456-556642440000&projection=product-name-and-price" | jq

Here's an example of deleting an order.

curl -X DELETE "$DATA_BASE_URL/api/orders/delete/order?orderId=123e4567-e89b-12d3-a456-556642440000"

Sweet! Now you have a Spring Data Cassandra microservice running!

Finally, We'll place a gateway service in front of our two previous services.

NOTE: This step may run a bit slowly. This is because we are running a lot of infrastructure on a relatively small virtual machine. Please be patient and wait for each command to complete successfully before proceeding.

Again, we already compiled the code for this service, so we can proceed to build the Docker image.

cd gateway-service
docker build -t example/gateway-service:1.0.0-SNAPSHOT .

Now, we'll share the image with the nodes in the cluster. Again, please be patient as this may take a minute.

kind load docker-image example/gateway-service:1.0.0-SNAPSHOT --name spring-boot-cluster
cd ..

Let's create a namespace for the gateway service.

kubectl create ns gateway-service

Finally, we can deploy the gateway service.

kubectl -n gateway-service apply -f deploy/gateway

We will create a variable with the pod ID for this service.

GATEWAY_SERVICE_POD=$(kubectl -n gateway-service get pods | tail -n 1 | cut -f 1 -d ' ')

This service also has a URL. We'll save this base URL in a variable so we can use it for several different accesses.

NOTE: In a regular Kubernetes cluster (not running on KinD or proxy), you could set the base URL as GATEWAY_BASE_URL=http://localhost:8080. You would also need to forward the port: kubectl -n gateway-service port-forward $BOOT_SERVICE_POD 8080:8080

GATEWAY_BASE_URL=http://localhost:8001/api/v1/namespaces/gateway-service/pods/$GATEWAY_SERVICE_POD/proxy

Wait for the service to fully initialize. Click the following.

watch kubectl get pods -n gateway-service

Once the STATUS is RUNNING, click the following to exit the watch loop, which sends a Ctrl-C to the terminal.

echo "Exiting watch loop"

Now, we are ready to test the gateway service. The access requests for this service look just like the requests we made when we tested the backend services, except the base URL is different.

For example, here's query for products by name.

curl $GATEWAY_BASE_URL/api/products/search/mobile | jq

Great! Now you have all three microservices running!