Librería Portfolio

Microservices architectures offer faster change speeds, better scalability, and cleaner, evolvable system designs. But implementing your first microservices architecture is difficult. How do you make myriad choices, educate your team on all the technical details, and navigate the organization to a successful execution to maximize your chance of success? With this book, authors Ronnie Mitra and Irakli Nadareishvili provide step-by-step guidance for building an effective microservices architecture.

Architects and engineers will follow an implementation journey based on techniques and architectures that have proven to work for microservices systems. You´ll build an operating model, a microservices design, an infrastructure foundation, and two working microservices, then put those pieces together as a single implementation. For anyone tasked with building microservices or a microservices architecture, this guide is invaluable.

Learn an effective and explicit end-to-end microservices system design
Define teams, their responsibilities, and guidelines for working together
Understand how to slice a big application into a collection of microservices
Examine how to isolate and embed data into corresponding microservices
Build a simple yet powerful CI/CD pipeline for infrastructure changes
Write code for sample microservices
Deploy a working microservices application on Amazon Web Services



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