Microservices with Clojure: Develop event-driven, scalable, and reactive microservices with real-time monitoring 9781788626316, 9781788622240

Table of contents :
Title Page
Copyright and Credits
Microservices with Clojure
Dedication
Packt Upsell
Why subscribe?
PacktPub.com
Contributors
About the author
About the reviewer
Packt is searching for authors like you
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Conventions used
Get in touch
Reviews
Monolithic Versus Microservices
Dawn of application architecture
Monolithic architecture
Microservices
Data management
When to use what
Monolithic applications to microservices
Identifying candidates for microservices
Release cycle and the deployment process
Summary
Microservices Architecture
Domain-driven design
Bounded context
Identifying bounded contexts
Organizing around bounded contexts
Components
Hexagonal architecture
Messaging and contracts
Direct messaging
Observer model
Service contracts
Service discovery
Service registry
Service discovery patterns
Data management
Direct lookup
Asynchronous events
Combining data
Transactions
Automated continuous deployment
CI/CD
Scaling
Summary
Microservices for Helping Hands Application
Design
Users and entities
User stories
Domain model
Monolithic architecture
Application components
Deployment
Limitations
Moving to microservices
Isolating services by persistence
Isolating services by business logic
Messaging and events
Extensibility
Workflows for Helping Hands
Service provider workflow
Service workflow
Service consumer workflow
Order workflow
Summary
Development Environment
Clojure and REPL
History of Clojure
REPL
Clojure build tools
Leiningen
Boot
Clojure project
Configuring a project
Running a project
Running tests
Generating reports
Generating artifacts
Clojure IDE
Summary
REST APIs for Microservices
Introducing REST
RESTful APIs
Status codes
Naming conventions
Using RESTful APIs via cURL
REST APIs for Helping Hands
Consumer and Provider APIs
Service and Order APIs
Summary
Introduction to Pedestal
Pedestal concepts
Interceptors
The interceptor chain
Importance of a Context Map
Creating a Pedestal service
Using interceptors and handlers
Creating routes
Declaring routers
Accessing request parameters
Creating interceptors
Handling errors and exceptions
Logging
Publishing operational metrics
Using chain providers
Using server-sent events (SSE)
Creating interceptors for SSE
Using WebSockets
Using WebSocket with Pedestal and Jetty
Summary
Achieving Immutability with Datomic
Datomic architecture
Datomic versus traditional database
Development model
Data model
Schema
Using Datomic
Getting started with Datomic
Connecting to a database
Transacting data
Using Datalog to query
Achieving immutability
Deleting a database
Summary
Building Microservices for Helping Hands
Implementing Hexagonal Architecture
Designing the interceptor chain and context
Creating a Pedestal project
Defining generic interceptors
Interceptor for Auth
Interceptor for the data model
Interceptor for events
Creating a microservice for Service Consumer
Adding routes
Defining the Datomic schema
Creating a persistence adapter
Creating interceptors
Testing routes
Creating a microservice for Service Provider
Adding routes
Defining Datomic schema
Creating a persistence adapter
Creating interceptors
Testing routes
Creating a microservice for Services
Adding routes
Defining a Datomic schema
Creating a persistence adapter
Creating interceptors
Testing routes
Creating a microservice for Order
Adding routes
Defining Datomic schema
Creating a persistence adapter
Creating interceptors
Testing routes
Creating a microservice for Lookup
Defining the Elasticsearch index
Creating query interceptors
Using geo queries
Getting status with aggregation queries
Creating a microservice for alerts
Adding routes
Creating an email interceptor using Postal
Summary
Configuring Microservices
Configuration principles
Defining configuration parameters
Using configuration parameters
Using Omniconf for configuration
Enabling Omniconf
Integrating with Helping Hands
Managing application states with mount
Enabling mount
Integrating with Helping Hands
Summary
Event-Driven Patterns for Microservices
Implementing event-driven patterns
Event sourcing
Using the CQRS pattern
Introduction to Apache Kafka
Design principles
Getting Kafka
Using Kafka as a messaging system
Using Kafka as an event store
Using Kafka for Helping Hands
Using Kafka APIs
Initializing Kafka with Mount
Integrating the Alert Service with Kafka
Using Avro for data transfer
Summary
Deploying and Monitoring Secured Microservices
Enabling authentication and authorization
Introducing Tokens and JWT
Creating an Auth service for Helping Hands
Using a Nimbus JOSE JWT library for Tokens
Creating a secret key for JSON Web Encryption
Creating Tokens
Enabling users and roles for authorization
Creating Auth APIs using Pedestal
Monitoring microservices
Using ELK Stack for monitoring
Setting up Elasticsearch
Setting up Kibana
Setting up Logstash
Using ELK Stack with Collectd
Logging and monitoring guidelines
Deploying microservices at scale
Introducing Containers and Docker
Setting up Docker
Creating a Docker image for Helping Hands
Introducing Kubernetes
Getting started with Kubernetes
Summary
Other Books You May Enjoy
Leave a review - let other readers know what you think