Microservices: A Practical Guide, Second Edition
Principles, Concepts, and Recipes
Eberhard Wolff
  • July 2019
  • ISBN 9781617296505
  • 336 pages
  • printed in black & white
You’ve decided to use microservices in your next project—now what? Microservices: A Practical Guide is a cookbook of immediately useful techniques you can customize for your project’s unique requirements. Get hands-on with the tools and technologies you need to build robust, production-ready, scalable microservices applications.

Distributed by Manning Publications

This book was created independently by architecture expert Eberhard Wolff and is distributed by Manning Publications.

About the Technology

The microservices design separates applications built with tightly coupled components into a system of independent, single-responsibility services that you can write and maintain individually. Building microservices-based applications presents some new design and implementation challenges, especially in the area of messaging, transactions, and state. The payoff can be big, though. This approach makes it easier to share work between teams and quicker to bring software to production.

About the book

In Microservices: A Practical Guide, architecture expert Eberhard Wolff starts by introducing microservices, self-contained systems, and the migration to microservices architecture. You’ll then move on to cookbook-style recipes that answer the most common challenges and operations of implementing microservices, including client-side and server-side frontend integration, asynchronous microservices, synchronous systems, and utilizing microservices platforms such as Kubernetes, Istio, and Cloud Foundry. Each recipe is fully illustrated with demo code and suggested variations that make them easy to adapt to your needs. By the time you’re done, you’ll have the skills to start implementing microservices architecture and a handy guide to consult as you work.
Table of Contents detailed table of contents

0 Introduction

0.1 Structure of the Book

0.2 Target Group

0.3 Prior Knowledge

0.4 Quick Start

0.5 Acknowledgements

0.6 Website

Part I: Principles of Microservices

1 Microservices

1.1 Microservices: Definition

1.2 Reasons for Microservices

1.3 Challenges

1.4 Variations

1.5 Conclusion

2 Micro and Macro Architecture

2.1 Bounded Context and Strategic Design

2.2 Technical Micro and Macro Architecture

2.3 Operation: Micro or Macro Architecture?

2.4 Give a Preference to Micro Architecture!

2.5 Organizational Aspects

2.6 Independent Systems Architecture Principles (ISA)

2.7 Variations

2.8 Conclusion

3 Migration

3.1 Reasons for Migrating

3.2 A Typical Migration Strategy

3.3 Alternative Strategies

3.4 Build, Operation, and Organization

3.5 Variations

3.6 Conclusion

Part II: Technology Stacks

4 Docker

4.1 Docker for Microservices: Reasons

4.2 Docker Basics

4.3 Docker Installation and Docker Commands

4.4 Installing Docker Hosts with Docker Machine

4.5 Dockerfiles

4.6 Docker Compose

4.7 Variations

4.8 Conclusion

5 Technical Micro Architecture

5.1 Requirements

5.2 Reactive

5.3 Spring Boot

5.4 Go

5.5 Variations

5.6 Conclusion

6 Self-contained Systems

6.1 Reasons for the Term Self-contained Systems

6.2 Definition

6.3 An Example

6.4 SCSs and Microservices

6.5 Challenges

6.6 Benefits

6.7 Variations

6.8 Conclusion

7 Concept: Frontend Integration

7.1 Frontend: Monolith or Modular?

7.2 Options

7.3 Resource-oriented Client Architecture (ROCA)

7.4 Challenges

7.5 Benefits

7.6 Variations

7.7 Conclusion

8 Recipe: Links and Client-side Integration

8.1 Overview

8.2 Example

8.3 Variations

8.4 Experiments

8.5 Conclusion

9 Recipe: Server-side Integration using Edge Side Includes (ESI)

9.1 ESI: Concepts

9.2 Example

9.3 Varnish

9.4 Recipe Variations

9.5 Experiments

9.6 Conclusion

10 Concept: Asynchronous Microservices

10.1 Definition

10.2 Events

10.3 Challenges

10.4 Advantages

10.5 Variations

10.6 Conclusions

11 Recipe: Messaging and Kafka

11.1 Message-oriented Middleware (MOM)

11.2 The Architecture of Kafka

11.3 Events with Kafka

11.4 Example

11.5 Recipe Variations

11.6 Experiments

11.7 Conclusion

12 Recipe: Asynchronous Communication with Atom and REST

12.1 The Atom Format

12.2 Example

12.3 Recipe Variations

12.4 Experiments

12.5 Conclusion

13 Concept: Synchronous Microservices

13.1 Definition

13.2 Benefits

13.3 Challenges

13.4 Variations

13.5 Conclusion

14 Recipe: REST with the Netflix Stack

14.1 Example

14.2 Eureka: Service Discovery

14.3 Router: Zuul

14.4 Load Balancing: Ribbon

14.5 Resilience: Hystrix

14.6 Recipe Variations

14.7 Experiments

14.8 Conclusion

15 Recipe: REST with Consul and Apache httpd

15.1 Example

15.2 Service Discovery: Consul

15.3 Routing: Apache httpd

15.4 Consul Template

15.5 Consul and Spring Boot

15.6 DNS and Registrator

15.7 Recipe Variations

15.8 Experiments

15.9 Conclusion

16 Concept: Microservices Platforms

16.1 Definition

16.2 Variations

16.3 Conclusion

17 Recipe: Docker Containers with Kubernetes

17.1 Kubernetes

17.2 The Example with Kubernetes

17.3 The Example in Detail

17.4 Additional Kubernetes Features

17.5 Recipe Variations

17.6 Experiments

17.7 Conclusion

18 Recipe: PaaS with Cloud Foundry

18.1 PaaS: Definition

18.2 Cloud Foundry

18.3 The Example with Cloud Foundry

18.4 Recipe Variations

18.5 Experiments

18.6 Serverless

18.7 Conclusion

Part III: Operation

19 Concept: Operation

19.1 Why Operation Is Important

19.2 Approaches for the Operation of Microservices

19.3 Effects of the Discussed Technologies

19.4 Conclusion

20 Recipe: Monitoring with Prometheus

20.1 Basics

20.2 Metrics for Microservices

20.3 Metrics with Prometheus

20.4 Example with Prometheus

20.5 Recipe Variations

20.6 Experiments

20.7 Conclusion

21 Recipe: Log Analysis with the Elastic Stack

21.1 Basics

21.2 Logging with the Elastic Stack

21.3 Example

21.4 Recipe Variations

21.5 Experiments

21.6 Conclusion

22 Recipe: Tracing with Zipkin

22.1 Basics

22.2 Tracing with Zipkin

22.3 Example

22.4 Recipe Variations

22.5 Conclusion

23 Recipe: Service Mesh Istio

23.1 What Is a Service Mesh?

23.2 Example

23.3 How Istio Works

23.4 Monitoring with Prometheus and Grafana

23.5 Tracing with Jaeger

23.6 Logging

23.7 Resilience

23.8 Challenges

23.9 Benefits

23.10 Variations

23.11 Experiments

23.12 Conclusion

24 And Now What?


Appendix A: Installation of the Environment

Appendix B: Maven Commands

Appendix C: Docker and Docker Compose Commands


What's inside

  • Migrating to microservices
  • Frontend Integration with JavaScript and Edge Side Includes
  • Asynchronous microservices with Apache Kafka or REST/Atom
  • Synchronous microservices with the Netflix Stack or Consul
  • Microservice platforms: Kubernetes, Cloud Foundry, or Istio
  • Monitoring with Prometheus
  • Log Analysis with Elasticsearch and Kibana
  • Tracing with Zipkin

About the reader

Aimed at beginners to microservices.

About the author

Eberhard Wolff has over 15 years of experience as an architect and consultant on the intersection of business and technology. He is a Fellow at INNOQ in Germany. As a speaker, he has given talks at international conferences, and, as an author, he has written more than 100 articles and books. His technological focus is on modern architectures, often involving Cloud, Continuous Delivery, DevOps, microservices, or NoSQL.

placing your order...

Don't refresh or navigate away from the page.
print book $30.00 $49.99 pBook + eBook
Additional shipping charges may apply
Prints and ships within 3-5 days
Microservices: A Practical Guide, Second Edition (print book) added to cart
continue shopping
go to cart

eBook $25.00 $39.99 3 formats
Microservices: A Practical Guide, Second Edition (eBook) added to cart
continue shopping
go to cart

Prices displayed in rupees will be charged in USD when you check out.

FREE domestic shipping on three or more pBooks