Microservice Patterns and Best Practices电子书

Title Page

Copyright and Credits

Microservice Patterns and Best Practices

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

Download the color images

Conventions used

Get in touch

Reviews

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

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

Python

Go

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

Performance

Build

Components

Implementation gaps

The databases

Locale proof performance

Apache Benchmark

WRK

Locust

Summary

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

Summary

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

Summary

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

Summary

Aggregator Microservice Design Pattern

Understanding the 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

Microservice communication

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

Best practices

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

Summary

Proxy Microservice Design Pattern

The proxy approach

Dumb proxy

Smart proxy

Understanding our proxy

Proxy strategy to orchestrator

Microservice communication

Pattern scalability

Best practices

Purest pattern

Looking at the bottleneck

Caching in the proxy

Simple response

Pros and cons of proxy design pattern

Summary

Chained Microservice Design Pattern

Understanding the pattern

Data orchestration and response consolidation

Microservice communication

Pattern scalability

Big Ball of Mud anti-pattern

Best practices

Purest microservices

Requesting consistent data

Understanding chain in depth

Paying attention to the communication layer

Understanding the pros and cons of chained design pattern

Summary

Branch Microservice Design Pattern

Understanding the pattern

Data orchestration and response consolidation

Microservice communication

Pattern scalability

Best practices

Domain definition

Respect the rules

Attention to physical components

Keep it simple

Pros and cons of the branch design pattern

Summary

Asynchronous Messaging Microservice

Understanding the pattern

Domain definition – RecommendationService

Data definition – RecommendationService

Coding the microservice

Microservice communication

Applying the message broker and queues

Preparing the pub/sub structure

Pattern scalability

Process sequence anti-pattern

Best practices

Application definition

Don’t try to create responses

Keep it simple

Pros and cons of the asynchronous messaging design pattern

Summary

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

Summary

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

Summary

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

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think