Microservices: Up and Running: A Step-by-Step Guide to Building a Microservices Architecture

Copyright
Table of Contents
Preface
	Who Should Read This Book
	What You’ll Need
	Conventions Used in This Book
	Using Code Examples
	O’Reilly Online Learning
	How to Contact Us
	Acknowledgments
Chapter 1. Toward a Microservices Architecture
	What Are Microservices?
	Reducing Coordination Costs
		The Coordination Cost Problem
		The Hard Parts
	Learning by Doing
		The “Up and Running” Microservices Model
	Decisions, Decisions…
		Writing a Lightweight Architectural Decision Record
	Summary
Chapter 2. Designing a Microservices Operating Model
	Why Teams and People Matter
		Team Size
		Team Skills
		Interteam Coordination
	Introducing Team Topologies
		Team Types
		Interaction Modes
	Designing a Microservices Team Topology
		Establish a System Design Team
		Building a Microservices Team Template
		Platform Teams
		Enabling and Complicated-Subsystem Teams
		Consumer Teams
		Summary
Chapter 3. Designing Microservices: The SEED(S) Process
	Introducing the Seven Essential Evolutions of Design for Services: The SEED(S) Method
	Identifying Actors
		Example Actors in Our Sample Project
	Identifying Jobs That Actors Have to Do
		Using Job Story Format to Capture JTBDs
		Example JTBDs in Our Sample Project
	Discovering Interaction Patterns with Sequence Diagrams
	Deriving Actions and Queries from JTBDs
		Example Queries and Actions for Our Sample Project
	Describing Each Query and Action as a Specification with an Open Standard
		Example OAS for an Action in Our Sample Project
	Getting Feedback on the API Specification
	Implementing Microservices
	Microservices Versus APIs
	Summary
Chapter 4. Rightsizing Your Microservices: Finding Service Boundaries
	Why Boundaries Matter, When They Matter, and How to Find Them
	Domain-Driven Design and Microservice Boundaries
		Context Mapping
		Synchronous Versus Asynchronous Integrations
		A DDD Aggregate
	Introduction to Event Storming
		The Event-Storming Process
	Introducing the Universal Sizing Formula
		The Universal Sizing Formula
	Summary
Chapter 5. Dealing with the Data
	Independent Deployability and Data Sharing
	Microservices Embed Their Data
		Embedding Data Should Not Lead to an Explosion in the Number of Database Clusters
		Data Embedding and the Data Delegate Pattern
		Using Data Duplication to Solve for Independence
		Distributed Transactions and Surviving Failures
	Event Sourcing and CQRS
		Event Sourcing
		Improving Performance with Rolling Snapshots
		Event Store
		Command Query Responsibility Segregation
	Event Sourcing and CQRS Beyond Microservices
	Summary
Chapter 6. Building an Infrastructure Pipeline
	DevOps Principles and Practices
		Immutable Infrastructure
		Infrastructure as Code
		Continuous Integration and Continuous Delivery
	Setting Up the IaC Environment
		Set Up GitHub
		Install Terraform
	Configuring Amazon Web Services
		Setting Up an AWS Operations Account
		Configure the AWS CLI
		Setting Up AWS Permissions
		Creating an S3 Backend for Terraform
	Building an IaC Pipeline
		Creating the Sandbox Repository
		Understanding Terraform
		Writing the Code for the Sandbox Environment
		Building the Pipeline
		Testing the Pipeline
	Summary
Chapter 7. Building a Microservices Infrastructure
	Infrastructure Components
		The Network
		The Kubernetes Service
		The GitOps Deployment Server
	Implementing the Infrastructure
		Installing kubectl
		Setting Up the Module Repositories
		The Network Module
		The Kubernetes Module
		Setting Up Argo CD
		Testing the Environment
		Cleaning Up the Infrastructure
	Summary
Chapter 8. Developer Workspace
	Coding Standards and the Developer’s Setup
		10 Workspace Guidelines for a Superior Developer Experience
	Setting Up a Containerized Environment Locally
		Installing Multipass
		Entering the Container and Mapping Folders
	Installing Docker
		Testing Docker
	Advanced Local Docker Usage: Installing Cassandra
	Installing Kubernetes
	Summary
Chapter 9. Developing Microservices
	Designing Microservice Endpoints
		Flights Microservice
		Reservations Microservice
		Designing an OpenAPI Specification
	Implementing the Data for a Microservice
		Redis for the Reservations Data Model
		MySQL Data Model for the Flights Microservice
	Implementing Code for a Microservice
		The Code Behind the Flights Microservice
		Health Checks
	Introducing a Second Microservice to the Project
	Hooking Services Up with an Umbrella Project
	Summary
Chapter 10. Releasing Microservices
	Setting Up the Staging Environment
		The Ingress Module
		The Database Module
		Forking the Staging Infrastructure Project
		Configuring the Staging Workflow
		Editing the Staging Infrastructure Code
	Shipping the Flight Information Container
		Introducing Docker Hub
		Configuring Docker Hub
		Configuring the Pipeline
	Deploying the Flights Service Container
		Understanding Kubernetes Deployments
		Creating a Helm Chart
		Creating the Microservices Deployment Repository
		Argo CD for GitOps Deployment
	Clean Up
	Summary
Chapter 11. Managing Change
	Changes in a Microservices System
		Be Data-Oriented
		The Impact of Changes
		Three Deployment Patterns
	Considerations for Our Architecture
		Infrastructure Changes
		Microservices Changes
		Data Changes
	Summary
Chapter 12. A Journey’s End (and a New Beginning)
	On Complexity and Simplification Using Microservices
		Microservices Quadrant
	Measuring the Progress of a Microservices Transformation
	Summary
Index
About the Authors
Colophon