Dependable Microservices via Lattice

Grails 3 makes development of microservices awesome. Docker makes ops for developers of said microservices awesome. However, once we get past “hello, world” and into HOLY TRAFFIC there’s a whole new layer of complexity around scalability and reliability. There have been a handful of tools emerging to target these issues, but in this post I want to introduce Cloud Foundry’s Lattice. If you haven’t heard of Lattice here’s the elevator pitch to save you a click:

What is it?

A project that helps manage a cluster of containers to keep things scalable and reliable so you don’t have to reinvent that wheel during the worst possible time (when you’re app is finally attracting load).

What will it address for these containers?

  • Scheduling: balancing containers across available resources as things change
  • Routing: configuring routes so started containers can service requests as soon as they are ready (and pull out containers as soon as their health check fails)
  • Self Healing: Lattice uses declarative application deployment via Terraform and will automatically right the ship if the system state doesn’t match what you’re expecting
  • Status Streaming: Logs from all the containers get aggregated and streamed to one spot for real-time monitoring
  • Check out lattice’s documentation for the full feature set including cool capabilities like A/B testing and blue-green deployments

Using Lattice locally with Grails

Let’s go through a simple tutorial of getting a bare Grails 3 app deployed to Docker and clustered with Lattice.

1) Installing and running Lattice

Lattice’s Getting Started docs do a great job explaining how to get everything set up and running. Make sure to follow the instructions all the way through the launching of their sample “lattice-app” to make sure everything is installed correctly.

2) Installing Grails

I would recommend using GVM to install and manage your Grails versions, but it can also be downloaded and installed from the Grails website. For this tutorial you will need Grails 3 or higher. I’m using 3.0.1.

3) Creating the Grails app

4) Setting up a Docker Hub account

You will need to create an account on Docker Hub. We will use it to store the image that will be run in the cluster.

5) Getting the container ready

Much of this is borrowed from the spring-boot-docker guide (hurray for boot-based Grails :-)), so check there for more info. We will start by creating a Dockerfile in the project:

In the Dockerfile, use the following instructions:

Now we need to add the following pieces to build.gradle:

Make sure you replace “group” with your Docker Hub id, or else it will fail while pushing the image. Next we will build the Docker image and push it to Docker Hub (NOTE: if using a Mac, execute this in your boot2docker terminal):

6) Creating the cluster

It should print out a URL to hit the application such as
It may take a while for the image to download so don’t panic if you get a timeout message or the URL gives you an error. Keep checking the status of the application with the command

Once the “Instances” field has the value “1/1” it means the application is deployed and should serve requests. You’re now ready to scale up, crash instances to watch recovery, and all the other fun basic operations from Lattice’s Getting Started docs.

Should I be using Lattice?

Depends on your team size and deployment needs. Lattice is being created for single user/single tenant clusters and is ideal for small teams and simpler use cases. It is a small subset of a full Cloud Foundry Elastic Runtime deployment and serves as its impressive gateway drug. Even if you aren’t planning on using Lattice in production, its ease of use makes deploying and experimenting with a local environment of microservices useful.

About the Author

Object Partners profile.

One thought on “Dependable Microservices via Lattice

  1. Fabio Favero Henkes says:

    Hey nice article!

    I`m trying lattice lately and I wasn`t able to figure out how to use volumes. I need to setup a distributed file system such as NFS for file sharing between microservices. I`ve notice the /tmp mapping in your Dockerfile, how do you reach that volume?


  2. @Fabio – that’s a good question, I haven’t needed a distributed filesystem for my own uses yet. I used the same volume setup as the article I mentioned for consistency (their reasoning for that setup is noted in the article), though I haven’t been using persistent storage. What have you all tried?

    1. Fabio Favero Henkes says:

      I’m testing a mix of lattice and flocker that is an implementation of zfs for Linux and work well with volumes. I didn’t setup the NFS yet.
      Another stuff that I’m keeping an eye on it’s

Leave a Reply

Your email address will not be published.

Related Blog Posts
Natively Compiled Java on Google App Engine
Google App Engine is a platform-as-a-service product that is marketed as a way to get your applications into the cloud without necessarily knowing all of the infrastructure bits and pieces to do so. Google App […]
Building Better Data Visualization Experiences: Part 2 of 2
If you don't have a Ph.D. in data science, the raw data might be difficult to comprehend. This is where data visualization comes in.
Unleashing Feature Flags onto Kafka Consumers
Feature flags are a tool to strategically enable or disable functionality at runtime. They are often used to drive different user experiences but can also be useful in real-time data systems. In this post, we’ll […]
A security model for developers
Software security is more important than ever, but developing secure applications is more confusing than ever. TLS, mTLS, RBAC, SAML, OAUTH, OWASP, GDPR, SASL, RSA, JWT, cookie, attack vector, DDoS, firewall, VPN, security groups, exploit, […]