Microservices with Clojure电子书

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