{"id":81599,"date":"2018-09-10T13:00:34","date_gmt":"2018-09-10T10:00:34","guid":{"rendered":"https:\/\/www.javacodegeeks.com\/?p=81599"},"modified":"2018-09-10T01:11:05","modified_gmt":"2018-09-09T22:11:05","slug":"spring-data-cassandra-application","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2018\/09\/spring-data-cassandra-application.html","title":{"rendered":"Containerising a Spring Data Cassandra application"},"content":{"rendered":"

I\u2019m continuing my journey of learning Docker. I am still keeping it simple at this point. This time around, I am going to tackle converting a Spring and Cassandra application to use containers instead of running locally on the host machine. More precisely, using Spring Data Cassandra to sort out the application.<\/p>\n

I wish I looked at doing this change a while ago. I have written a fair amount of posts on Cassandra and each time I had to cd<\/code> to the correct directory or have a shortcut to start it up. I guess it\u2019s not that big of a deal, but there were a few other things involved. Such as, dropping and recreating keyspaces so I could test my application from scratch. Now, I just delete the container and restart it. To me anyway, this is helpful!<\/p>\n

\"cassandra\"<\/a><\/p>\n

This post will be slightly different from my previous post, Using Docker to shove an existing application into containers<\/a>. Instead, I will focus slightly more on the application side and remove the intermediate steps of using only Docker and instead will jump straight into Docker Compose.<\/p>\n

Containers, containers, containers<\/h3>\n

I think it\u2019s best to start on the container side of the project since the application depends on the configuration of the Cassandra container.<\/p>\n

Let\u2019s go!<\/p>\n

FROM openjdk:10-jre-slim\r\nLABEL maintainer=\"Dan Newton\"\r\nARG JAR_FILE\r\nADD target\/${JAR_FILE} app.jar\r\nENTRYPOINT [\"java\", \"-jar\", \"\/app.jar\"]<\/pre>\n
There\u2019s not much going on here. This Dockerfile<\/code> builds the Spring application image that will be put into a container in a few moments.<\/p>\n
Next up is the docker-compose<\/code> file. This is will build both the Spring application and Cassandra containers:<\/p>\n
version: '3'\r\nservices:\r\n  app:\r\n    build:\r\n      context: .\r\n      args:\r\n        JAR_FILE: \/spring-data-cassandra-docker-1.0.0.jar\r\n    restart: always\r\n  cassandra:\r\nimage: \"cassandra\"<\/pre>\n
Again, there isn\u2019t too much here. The app<\/code> container builds the Spring application using the Dockerfile<\/code> defined previously. The cassandra<\/code> container instead relies on an existing image, appropriately named cassandra<\/code>.<\/p>\n
One thing that stands out is that the restart<\/code> property is set to always<\/code>. This was my lazy attempt to get past how long Cassandra takes to start and the fact that all the containers started with docker-compose<\/code> start at the same time. This lead to a situation where the application is trying to connect to Cassandra without it being ready. Unfortunately, this leads to the application dying. I hoped that it would have some retry capability for initial connectivity built in\u2026 But it does not.<\/p>\n
When we go through the code, we will see how to deal with the initial Cassandra connection programmatically instead of relying on the application dying and restarting multiple times. You will see my version of handling the connection anyway\u2026 I\u2019m not really a fan of my solution but everything else I tried caused me much more pain.<\/p>\n
A dash of code<\/h3>\n
I said this post would focus more on the application code, which it will, but we are not going to dive into everything I put within this application and how to use Cassandra. For that sort of information, you can have a look at my older posts, which I\u2019ll link at the end. What we will do though, is examine the configuration code that creates the beans that connect to Cassandra.<\/p>\n
First, let\u2019s go through ClusterConfig<\/code> which sets up the Cassandra cluster:<\/p>\n
@Configuration\r\npublic class ClusterConfig extends AbstractClusterConfiguration {\r\n\r\n  private final String keyspace;\r\n  private final String hosts;\r\n\r\n  ClusterConfig(\r\n      @Value(\"${spring.data.cassandra.keyspace-name}\") String keyspace,\r\n      @Value(\"${spring.data.cassandra.contact-points}\") String hosts) {\r\n    this.keyspace = keyspace;\r\n    this.hosts = hosts;\r\n  }\r\n\r\n  @Bean\r\n  @Override\r\n  public CassandraClusterFactoryBean cluster() {\r\n\r\n    RetryingCassandraClusterFactoryBean bean = new RetryingCassandraClusterFactoryBean();\r\n\r\n    bean.setAddressTranslator(getAddressTranslator());\r\n    bean.setAuthProvider(getAuthProvider());\r\n    bean.setClusterBuilderConfigurer(getClusterBuilderConfigurer());\r\n    bean.setClusterName(getClusterName());\r\n    bean.setCompressionType(getCompressionType());\r\n    bean.setContactPoints(getContactPoints());\r\n    bean.setLoadBalancingPolicy(getLoadBalancingPolicy());\r\n    bean.setMaxSchemaAgreementWaitSeconds(getMaxSchemaAgreementWaitSeconds());\r\n    bean.setMetricsEnabled(getMetricsEnabled());\r\n    bean.setNettyOptions(getNettyOptions());\r\n    bean.setPoolingOptions(getPoolingOptions());\r\n    bean.setPort(getPort());\r\n    bean.setProtocolVersion(getProtocolVersion());\r\n    bean.setQueryOptions(getQueryOptions());\r\n    bean.setReconnectionPolicy(getReconnectionPolicy());\r\n    bean.setRetryPolicy(getRetryPolicy());\r\n    bean.setSpeculativeExecutionPolicy(getSpeculativeExecutionPolicy());\r\n    bean.setSocketOptions(getSocketOptions());\r\n    bean.setTimestampGenerator(getTimestampGenerator());\r\n\r\n    bean.setKeyspaceCreations(getKeyspaceCreations());\r\n    bean.setKeyspaceDrops(getKeyspaceDrops());\r\n    bean.setStartupScripts(getStartupScripts());\r\n    bean.setShutdownScripts(getShutdownScripts());\r\n\r\n    return bean;\r\n  }\r\n\r\n  @Override\r\n  protected List getKeyspaceCreations() {\r\n    final CreateKeyspaceSpecification specification =\r\n        CreateKeyspaceSpecification.createKeyspace(keyspace)\r\n            .ifNotExists()\r\n            .with(KeyspaceOption.DURABLE_WRITES, true)\r\n            .withSimpleReplication();\r\n    return List.of(specification);\r\n  }\r\n\r\n  @Override\r\n  protected String getContactPoints() {\r\n    return hosts;\r\n  }\r\n}<\/pre>\n
There isn\u2019t too much there, but there would be even less if Spring would retry the initial connection to Cassandra. Anyway, let\u2019s leave that part for a few minutes and focus on the other points in this class.
 
<\/div> <\/div><\/p>\n
The original reason I created ClusterConfig<\/code> was to create the keyspace that the application will use. To do this getKeyspaceCreations<\/code> was overridden. When the application connects it will execute the query defined in this method to create the keyspace.<\/p>\n
If this wasn\u2019t needed and the keyspace was created in some other way, for example, a script executed as part of creating the Cassandra container, Spring Boot\u2019s auto-configuration could be relied upon instead. This actually allows the whole application to be configured by the properties defined in application.properties<\/code> and nothing else. Alas, it was not meant to be.<\/p>\n
Since we have defined an AbstractClusterConfiguration<\/code>, Spring Boot will disable its configuration in this area. Therefore, we need to define the contactPoints<\/code> (I named the variable hosts<\/code>) manually by overriding the getContactPoints<\/code> method. Originally this was only defined in application.properties<\/code>. I realised I needed to make this change once I started getting the following error:<\/p>\n
All host(s) tried for query failed (tried: localhost\/127.0.0.1:9042 (com.datastax.driver.core.exceptions.TransportException: [localhost\/127.0.0.1:9042] Cannot connect))<\/pre>\n
Before I created ClusterConfig<\/code> the address was cassandra<\/code> rather than localhost<\/code>.<\/p>\n
No other properties for the cluster need to be configured as Spring\u2019s defaults are good enough for this scenario.<\/p>\n
I have mentioned application.properties<\/code> so much at this point, I should probably show you what is in it.<\/p>\n
spring.data.cassandra.keyspace-name=mykeyspace\r\nspring.data.cassandra.schema-action=CREATE_IF_NOT_EXISTS\r\nspring.data.cassandra.contact-points=cassandra<\/pre>\n
keyspace-name<\/code> and contact-points<\/code> have already popped up since they are related to configuring the cluster. schema-action<\/code> is needed to create tables based on the entities in the project. We don\u2019t need to do anything else here as auto-configuration is still working in this area.<\/p>\n
The fact that the contact-points<\/code> value is set to cassandra<\/code> is very important. This domain name originates from the name given to the container, in this case, cassandra<\/code>. Therefore either cassandra<\/code> can be used or the actual IP of the container. The domain name is definitely easier since it will always be static between deployments. Just to test this theory out, you can change the name of the cassandra<\/code> container to whatever you want and it will still connect, as long as you change it in the application.properties<\/code> as well.<\/p>\n
Back to the ClusterConfig<\/code> code. More precisely, the cluster<\/code> bean. I have pasted the code below again so it\u2019s easier to look at:<\/p>\n
@Configuration\r\npublic class ClusterConfig extends AbstractClusterConfiguration {\r\n\r\n  \/\/ other stuff\r\n\r\n  @Bean\r\n  @Override\r\n  public CassandraClusterFactoryBean cluster() {\r\n\r\n    RetryingCassandraClusterFactoryBean bean = new RetryingCassandraClusterFactoryBean();\r\n\r\n    bean.setAddressTranslator(getAddressTranslator());\r\n    bean.setAuthProvider(getAuthProvider());\r\n    bean.setClusterBuilderConfigurer(getClusterBuilderConfigurer());\r\n    bean.setClusterName(getClusterName());\r\n    bean.setCompressionType(getCompressionType());\r\n    bean.setContactPoints(getContactPoints());\r\n    bean.setLoadBalancingPolicy(getLoadBalancingPolicy());\r\n    bean.setMaxSchemaAgreementWaitSeconds(getMaxSchemaAgreementWaitSeconds());\r\n    bean.setMetricsEnabled(getMetricsEnabled());\r\n    bean.setNettyOptions(getNettyOptions());\r\n    bean.setPoolingOptions(getPoolingOptions());\r\n    bean.setPort(getPort());\r\n    bean.setProtocolVersion(getProtocolVersion());\r\n    bean.setQueryOptions(getQueryOptions());\r\n    bean.setReconnectionPolicy(getReconnectionPolicy());\r\n    bean.setRetryPolicy(getRetryPolicy());\r\n    bean.setSpeculativeExecutionPolicy(getSpeculativeExecutionPolicy());\r\n    bean.setSocketOptions(getSocketOptions());\r\n    bean.setTimestampGenerator(getTimestampGenerator());\r\n\r\n    bean.setKeyspaceCreations(getKeyspaceCreations());\r\n    bean.setKeyspaceDrops(getKeyspaceDrops());\r\n    bean.setStartupScripts(getStartupScripts());\r\n    bean.setShutdownScripts(getShutdownScripts());\r\n\r\n    return bean;\r\n  }\r\n\r\n  \/\/ other stuff\r\n}<\/pre>\n
This code is only needed to allow retries on the initial Cassandra connection. It is annoying, but I could not come up with another simple solution. If you have a nicer one then please let me know!<\/p>\n
What I have done is actually quite simple, but the code itself is not very nice. The cluster<\/code> method is a carbon copy of the overridden version from AbstractClusterConfiguration<\/code>, with the exception of the RetryingCassandraClusterFactoryBean<\/code> (my own class). The original function used a CassandraClusterFactoryBean<\/code> (Spring class) instead.<\/p>\n
Below is the RetryingCassandraClusterFactoryBean<\/code>:<\/p>\n
public class RetryingCassandraClusterFactoryBean extends CassandraClusterFactoryBean {\r\n\r\n  private static final Logger LOG =\r\n      LoggerFactory.getLogger(RetryingCassandraClusterFactoryBean.class);\r\n\r\n  @Override\r\n  public void afterPropertiesSet() throws Exception {\r\n    connect();\r\n  }\r\n\r\n  private void connect() throws Exception {\r\n    try {\r\n      super.afterPropertiesSet();\r\n    } catch (TransportException | IllegalArgumentException | NoHostAvailableException e) {\r\n      LOG.warn(e.getMessage());\r\n      LOG.warn(\"Retrying connection in 10 seconds\");\r\n      sleep();\r\n      connect();\r\n    }\r\n  }\r\n\r\n  private void sleep() {\r\n    try {\r\n      Thread.sleep(10000);\r\n    } catch (InterruptedException ignored) {\r\n    }\r\n  }\r\n}<\/pre>\n
The afterPropertiesSet<\/code> method in the original CassandraClusterFactoryBean<\/code> takes its values and creates the representation of a Cassandra cluster by finally delegating to the Datastax Java driver. As I have mentioned throughout the post. If it fails to establish a connection, an exception will be thrown and if not caught will cause the application to terminate. That is the whole point of the above code. It wraps the afterPropertiesSet<\/code> in a try-catch block specified for the exceptions that can be thrown.<\/p>\n
The sleep<\/code> is added to give Cassandra some time to actually start up. There is no point trying to reconnect straight away when the previous attempt failed.<\/p>\n
Using this code the application will eventually connect to Cassandra.<\/p>\n
At this point, I would normally show you some meaningless logs to prove that the application works, but in this situation, it really does not bring anything to the table. Just trust me when I say, if you run the below command:<\/p>\n
mvn clean install && docker-compose up<\/pre>\n
Then the Spring application image is created and both containers are spun up.<\/p>\n
Conclusion<\/h3>\n
We have had a look at how to put a Spring application that connects to a Cassandra database into containers. One for the application and another for Cassandra. The application image is built from the project\u2019s code, whereas the Cassandra image is taken from Docker Hub. The image name is cassandra<\/code> just to make sure no one forgets. In general connecting the two containers together was relatively simple but the application needed some adjustments to allow retries when connecting to Cassandra running in the other container. This made the code a bit uglier, but it works at least\u2026 Thanks to the code written in this post, I now have another application that I don\u2019t need to set up on my own machine.<\/p>\n
The code used in this post can be found on my GitHub<\/a>.<\/p>\n
If you found this post helpful, you can follow me on Twitter at @LankyDanDev<\/a> to keep up with my new posts.<\/p>\n
Links to my Spring Data Cassandra posts<\/h3>\n