Microservices with Clojure

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

  1.  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

  2.  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

3.  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

4.  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

5.  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

6.  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

7.  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

8.  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

9.  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

10.  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

11.  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