Microservice patterns and best practices : explore patterns like CQRS and event sourcing to create scalable, maintainable, and testable microservices / Vinicius Feitosa Pacheco.

Format:

Book

Author/Creator:

Pacheco, Vinicius Feitosa, author.

Language:

English

Subjects (All):

Service-oriented architecture (Computer science).

Software architecture.

Physical Description:

1 online resource (357 pages) : illustrations (some color)

Edition:

1st ed.

Place of Publication:

Birmingham, England ; Mumbai, [India] : Packt, 2018.

Summary:

Microservices are a hot trend in the development world right now. Many enterprises have adopted this approach to achieve agility and the continuous delivery of applications to gain a competitive advantage. This book will take you through the different design patterns at different stages of the microservice application development process,.

Contents:

Cover

Copyright and Credits

Dedication

Packt Upsell

Contributors

Table of Contents

Preface

Chapter 1: Understanding the Microservices Concepts

Knowing the application

Domain-driven design

Single responsibility principle

Explicitly published interface

Independently deploy, upgrade, scale, and replace

Independent deployment

Upgrade

Scale

The x-axis

The y-axis

The z-axis

Replace

Light weight communication

Synchronous

Asynchronous

Potentially heterogeneous/polyglot

Documentation of communication

Endpoints for web applications

Endpoints for mobile applications

Caching at the client level

Throttling for your client

Identifying anemic domains

Identifying the fat domains

Identifying microservice domains for the business

From domain to entity

Summary

Chapter 2: The Microservice Tools

Programming languages

Proficiency

Performance

Development of practicality

Ecosystem

Scalability cost

Making choices for our application

Java

C#

Python

JavaScript

Go

Microservice frameworks

Logs

Handlers

Middleware

Tests

Package manager

Golang ORMs

Binary communication - direct communication between services

Understanding the aspect

Tools for synchronous communication

MessagePack

gRPC

Apache Avro

Apache Thrift

Direct communication alerts

Message broker - Async communication between services

ActiveMQ

RabbitMQ

Kafka

Caching tools

Memcached

Redis

Fail alert tools

Build

Components

Implementation gaps

The databases

Locale proof performance

Apache Benchmark

WRK

Locust

Chapter 3: Internal Patterns

Developing the structure

Database

Programming language and tools

Project structure

The models.go file.

The app.go file

The main.go file

Caching strategies

Applying cache

Caching first

Enqueuing tasks

Asynchronism and workers

CQRS - query strategy

What is CQRS?

Understanding CQRS

Advantages and disvantages of implementing CQRS

Event sourcing - data integrity

State mutation

Understanding event sourcing

Chapter 4: Microservice Ecosystem

Separating containers

Layered services architecture

Separating UsersService

Creating Dockerfile

Using the containers

Storage distribution

Depreciating data

Regionalizing data

Bulkheads - using the ecosystem against failures

Designing for redundancy

Partitioning by criticality

Designing with isolation

Fail fast

Circuit breaker

Chapter 5: Shared Data Microservice Design Pattern

Understanding the pattern

Breaking a monolithic application into microservices

Defining priorities

Setting deadlines

Defining the domain

Making experiments

Defining standards

Creating a prototype

Sending to production

Developing new microservices

Writing the microservice configuration file

Creating our model

Exposing the microservice data

Preparing the app to run

Creating the Dockerfile

Dependencies with requirements.txt

Data orchestration

Consolidating responses

Microservice communication

Storage sharing anti-pattern

Best practices

Testing

Pros and cons of the shared data pattern

Chapter 6: Aggregator Microservice Design Pattern

Applying CQRS and event sourcing

Separating the database

Writing the CommandStack container

Creating the news databases

Writing the QueryStack container

Refactoring the microservices

Selecting our requirements

Configuring the framework

Configuring the container.

Writing the models

Creating the service

Preparing the database containers to work together

Building the orchestrator

Preparing the microservice container

Writing the dependencies

Writing the configuration file

Writing the server access

Creating the orchestration controller

Applying the message broker

Making the containers work together

Updating the proxy/load balancer

Pattern scalability

Bottleneck anti-pattern

Applying tests

Functional test

Writing the functional test

Integration test

Writing the integration tests

Pros and cons of aggregator design pattern

Pros of aggregator design pattern

Cons of aggregator design pattern

Chapter 7: Proxy Microservice Design Pattern

The proxy approach

Dumb proxy

Smart proxy

Understanding our proxy

Proxy strategy to orchestrator

Purest pattern

Looking at the bottleneck

Caching in the proxy

Simple response

Pros and cons of proxy design pattern

Chapter 8: Chained Microservice Design Pattern

Data orchestration and response consolidation

Big Ball of Mud anti-pattern

Purest microservices

Requesting consistent data

Understanding chain in depth

Paying attention to the communication layer

Understanding the pros and cons of chained design pattern

Chapter 9: Branch Microservice Design Pattern

Domain definition

Respect the rules

Attention to physical components

Keep it simple.

Pros and cons of the branch design pattern

Chapter 10: Asynchronous Messaging Microservice

Domain definition - RecommendationService

Data definition - RecommendationService

Coding the microservice

Applying the message broker and queues

Preparing the pub/sub structure

Process sequence anti-pattern

Application definition

Don't try to create responses

Keep it simple

Pros and cons of the asynchronous messaging design pattern

Chapter 11: Microservices Working Together

Understanding the current application status

The public facing layer

The internal layer

Understanding general tools

Communication layer and accreditation between services

Understanding the data contract between services

Applying binary communication

Pattern distribution

Fail strategies

API integration

Chapter 12: Testing Microservices

Unit tests

Preparing the containers for the integration test

Integration tests

End-to-end tests

Release pipelines

Signature tests

Monkey tests

Chaos Monkey

Chapter 13: Monitoring Security and Deployment

Monitoring microservices

Monitoring a single service

Monitoring multiple services

Looking at the logs

Learning from the errors in the application

The metrics - Understanding the numbers

Security

Understanding JWT

Single Sign-On

Security of data

Defense for malicious requests - Identifying attacks

Explaining the interceptor

Web container

The API gateway

Deployment

Continuous integration/continuous delivery/continuous deploy

The blue/green deployment pattern and Canary releases

Multiple service instances per host

Service instance per host

Service instance per VM.

Service instance per container

Other Books You May Enjoy

Leave a review - let other readers know what you think

Index.

Notes:

Includes index.

Description based on online resource; title from PDF title page (EBC, viewed March 6, 2018).