Service Discovery is an important aspect of microservices, particularly when using containers on elastic infrastructure. Most popular approaches for service discovery require a standalone fault tolerant cluster like Consul, Zookeeper or etcd.

If you are already using Akka as a clustering platform for your services, there is an interesting alternative available for Service Discovery. CRDTs, or Conflict-free Replicated Data Types are a relatively new primitive in distributed systems. CRDTs allows concurrent updates without coordination and has provisions for tuning consistency levels. 'Distributed Data' extension natively supports CRDTs on top of Akka-Cluster.

We used CRDTs in Akka to build the service registration and discovery mechanism for TMT's (Thirty Meter Telescope) software platform. TMT will be world's largest optical telescope once operational. The ongoing software work is open source and available on github. We would like to share the details of our implementation and also compare it existing approaches.

 
5 favorite thumb_down thumb_up 0 comments visibility_off  Remove from Watchlist visibility  Add to Watchlist
 

Outline/structure of the Session

- What and Why of Service Discovery

- Popular approaches (Consul, Zookeeper, etcd)

- Introduction to CRDTs

- Introduction to TMT project.

- TMT project's design for CRDT based service discovery

- Comparisons and pros/cons

- Demo only if time permits!

 

Learning Outcome

- Why are CRDTs so cool

- Why are distributed systems so tricky

- Why is service discovery so important

- What is TMT project

Target Audience

Erlang/Akka enthusiasts, Distributed systems geeks, Curious about CRDTs.

Prerequisite

Read up about CRDTs and Basic for Service Discovery. Familiarity with Akka and Scala.

schedule Submitted 1 month ago

Comments Subscribe to Comments

comment Comment on this Proposal

  • Liked Maria Livia Chiorean
    keyboard_arrow_down

    The path to generic endpoints using Shapeless

    Maria Livia Chiorean
    Maria Livia Chiorean
    schedule 3 months ago
    Sold Out!
    20 mins
    Talk
    Beginner

    Programming in Scala is sometimes very time consuming. Finding the most efficient way to solve a problem can end up in days of frustration. This talk is a story of trail and error with a twist at the end. It's a story of API endpoints, generic programming, Shapeless and what happens when they all come together. Everything with examples and plenty of code.

  • Liked Ryan Lemmer
    keyboard_arrow_down

    From Haskell 98 to Modern Haskell - Making sense of the Haskell type system

    Ryan Lemmer
    Ryan Lemmer
    schedule 1 month ago
    Sold Out!
    45 mins
    Talk
    Intermediate

    There are several great books and courses that serve as an introduction to functional programming in Haskell. Typically, these introductions focus on the original core of Haskell ("Haskell 98").

    However, going from there into real world Haskell systems can be a bewildering experience. This is because Haskell has evolved significantly since Haskell 98. In this talk we will investigate the key advances in the type-system that make up "modern Haskell".

    • type-system extensions: Rank-n types, GADTs, functional dependencies, ...
    • kind-system extensions: type functions, kind polymorphism, type promotion, ...

    By taking a historical perspective we will look at why new language extensions were introduced, and the context in which they first appeared. This approach gives us a layered view of seemingly disparate language features.

    We will see that the evolution of the type system has been a steady march from "programming with types" to type-level programming, and ultimately dependently-typed programming in Haskell.

    (This talk will draw from the book "Haskell Design Patterns")

  • Liked Shripad Agashe
    keyboard_arrow_down

    More is different: Mistaking trees for Forest

    Shripad Agashe
    Shripad Agashe
    schedule 1 month ago
    Sold Out!
    45 mins
    Talk
    Intermediate

    Generally scientific approach is kept limited to only reductionist approach i.e. trying to understand the system by understanding its parts. Thats how we have been taught to think. However this construct fails in non trivial systems. Often the property of the system can not be reduced to any property of its constituent parts. To take an example “pressure” is not a property individual atoms/molecules but that of a gas. In any complex system it is important to identify relationship between the property of the system and property of its parts. This relationship is known as emergence in complex systems.

    In this talk I would cover variety of techniques I’ve used to identify emergent properties. It helped me unravel knotty designs and truly understand “deep insight” aspect of domain driven design. I feel this topic is important in the context of functional programming as functions are touted “pure” abstractions: missing the point of interaction.