Microservices: Up and Running

Spis treści książki

• Preface
  • Who Should Read This Book
  • What Youll Need
  • Conventions Used in This Book
  • Using Code Examples
  • OReilly 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
      • Queries
      • Actions
  • 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
      • Distributed transactions with sagas
  • Event Sourcing and CQRS
    • Event Sourcing
      • Event Sourcing in accounting and chess
      • Event Sourcing versus relational modeling
      • What does an event look like?
      • Calculating current state with projections
    • 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
      • An introduction to Terraform
    • 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
      • Setting up secrets
      • Creating the workflow
      • Configuring the trigger and setup
      • Installing dependencies
      • Applying Terraform files
      • Publishing assets and committing changes
    • 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
      • Network module outputs
      • Network module main configuration
      • Network module variables
      • Create a sandbox network
    • The Kubernetes Module
      • Kubernetes module outputs
      • Defining the EKS cluster
      • Defining the EKS node group
      • Kubernetes module variables
      • Create a sandbox Kubernetes cluster
    • Setting Up Argo CD
      • Variables for Argo CD
      • Installing Argo CD in the sandbox
    • Testing the Environment
    • Cleaning Up the Infrastructure
  • Summary
• 8. Developer Workspace
  • Coding Standards and the Developers 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. 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
      • Testing access to the Kubernetes cluster
      • Create a Kubernetes secret
  • Shipping the Flight Information Container
    • Introducing Docker Hub
    • Configuring Docker Hub
    • Configuring the Pipeline
      • Configuring Docker Hub secrets
      • Shipping the flight service container
  • Deploying the Flights Service Container
    • Understanding Kubernetes Deployments
      • Understanding Kubernetes objects and controllers
    • Creating a Helm Chart
    • Creating the Microservices Deployment Repository
      • Create a Helm chart
      • Update the flights deployment template
      • Set package values
      • Test and commit the package
    • Argo CD for GitOps Deployment
      • Log in to Argo CD
      • Sync and deploy a microservice
      • Test the flights service
  • Clean Up
  • Summary
• 11. Managing Change
  • Changes in a Microservices System
    • Be Data-Oriented
    • The Impact of Changes
    • Three Deployment Patterns
      • Blue-green deployment
      • Canary deployment
      • Multiple versions
  • Considerations for Our Architecture
    • Infrastructure Changes
      • Infrastructure change: Implementation costs
      • Infrastructure change: Coordination costs
      • Infrastructure change: Downtime
      • Infrastructure change: Consumer impact
    • Microservices Changes
      • Microservices: Implementation costs
      • Microservices: Coordination costs
      • Microservices: Downtime
      • Microservices: Consumer impact
    • Data Changes
      • Data: Implementation costs
      • Data: Coordination costs
      • Data: Downtime
      • Data: Consumer impact
  • Summary
• 12. A Journeys End (and a New Beginning)
  • On Complexity and Simplification Using Microservices
    • Microservices Quadrant
  • Measuring the Progress of a Microservices Transformation
  • Summary
• Index

pokaż cały spis treści

ukryj recenzje