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

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

Let's create the database. Follow the steps outlined here. To make life easy, you can use the values we recommend.

On this dialog, click View Database.

When you see the active status on this page, your database is ready to go.

Woot! You have an active Astra Cassandra database!

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.

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

You can find the link on the Astra page as shown below. 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. You will need to 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. 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, do the same thing with the database password in the following command.

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

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.

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 credential 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 varaible 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

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

NOTE: It may take a moment for the service to completely initialize. If you try the following command and see an error, wait a minute and try the command again. Remember, we are placing a heavy load on the Katacoda VM that is simulating our Kubernetes cluster, so please be patient.

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.

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

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.

NOTE: It may take a moment for the service to completely initialize. If you try the command and see an error, wait a minute (literally 60 seconds) and try the command again - eventually it will work. Remember, we are placing a heavy load on the Katacoda VM that is simulating our Kubernetes cluster, so please be patient.

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

Great! Now you have all three microservices running!