Book Overview & Buying
Table Of Contents
Feedback & Rating

Microservices with Clojure

By : Anuj Kumar

4.5 (2)

Buy this Book

Microservices with Clojure

4.5 (2)

By: Anuj Kumar

Buy this Book

Overview of this book

The microservice architecture is sweeping the world as the de facto pattern with which to design and build scalable, easy-tomaintain web applications. This book will teach you common patterns and practices, and will show you how to apply these using the Clojure programming language. This book will teach you the fundamental concepts of architectural design and RESTful communication, and show you patterns that provide manageable code that is supportable in development and at scale in production. We will provide you with examples of how to put these concepts and patterns into practice with Clojure. This book will explain and illustrate, with practical examples, how teams of all sizes can start solving problems with microservices. You will learn the importance of writing code that is asynchronous and non-blocking and how Pedestal helps us do this. Later, the book explains how to build Reactive microservices in Clojure that adhere to the principles underlying the Reactive Manifesto. We finish off by showing you various ways to monitor, test, and secure your microservices. By the end, you will be fully capable of setting up, modifying, and deploying a microservice with Clojure and Pedestal.

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Free Chapter

Monolithic Versus Microservices

Dawn of application architecture

Monolithic architecture

Microservices

When to use what

Monolithic applications to microservices

Summary

Microservices Architecture

Domain-driven design

Components

Messaging and contracts

Service discovery

Data management

Automated continuous deployment

Summary

Microservices for Helping Hands Application

Design

Monolithic architecture

Moving to microservices

Workflows for Helping Hands

Summary

Development Environment

Clojure and REPL

Clojure build tools

Clojure project

Clojure IDE

Summary

REST APIs for Microservices

Introducing REST

RESTful APIs

REST APIs for Helping Hands

Summary

Introduction to Pedestal

Pedestal concepts

Creating a Pedestal service

Using server-sent events (SSE)

Using WebSockets

Summary

Achieving Immutability with Datomic

Datomic architecture

Using Datomic

Summary

Building Microservices for Helping Hands

Implementing Hexagonal Architecture

Creating a microservice for Service Consumer

Creating a microservice for Service Provider

Creating a microservice for Services

Creating a microservice for Order

Creating a microservice for Lookup

Creating a microservice for alerts

Summary

Configuring Microservices

Configuration principles

Using Omniconf for configuration

Managing application states with mount

Summary

Event-Driven Patterns for Microservices

Implementing event-driven patterns

Introduction to Apache Kafka

Using Kafka for Helping Hands

Summary

Deploying and Monitoring Secured Microservices

Enabling authentication and authorization

Monitoring microservices

Deploying microservices at scale

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

4.5 (2)

5 star

50%

4 star

50%

3 star

2 star

1 star

Microservices Architecture

"Gather together the things that change for the same reasons. Separate those things that change for different reasons."

- Robert Martin, Single Responsibility Principle

Software architecture plays a key role in identifying the behavior of the system before it is built. A well-designed software architecture leads to flexible, reusable, and scalable components that can be easily extended, verified, and maintained over time. Such architectures evolve over time and help pave the way for the adoption of next-generation architectures. For example, a well-designed monolithic application that is built on the principles of Separation of Concern (SoC) is easier to migrate to microservices than an application that does not have well-defined components. In this chapter, you will: