Implementing Serverless Microservices Architecture Patterns

Video description

Building a microservices platform using virtual machines or containers, involves a lot of initial and ongoing effort and there is a cost associated with having idle services running, maintenance of the boxes and a configuration complexity involved in scaling up and down.

In this course, We will show you how Serverless computing can be used to implement the majority of the Microservice architecture patterns and when put in a continuous integration & continuous delivery pipeline; can dramatically increase the delivery speed, productivity and flexibility of the development team in your organization, while reducing the overall running, operational and maintenance costs.

We start by introducing the microservice patterns that are typically used with containers, and show you throughout the course how these can efficiently be implemented using serverless computing. This includes the serverless patterns related to non-relational databases, relational databases, event sourcing, command query responsibility segregation (CQRS), messaging, API composition, monitoring, observability, continuous integration and continuous delivery pipelines.

By the end of the course, you’ll be able to build, test, deploy, scale and monitor your microservices with ease using Serverless computing in a continuous delivery pipeline.

What You Will Learn

  • Implement over 15 microservices architecture patterns without needing containers or EC2 instances
  • Build, test, deploy and maintain serverless microservices
  • Speed up delivery, flexibility and time to market using serverless microservices
  • Get serverless best practices and recommendation on scaling out and enforcing security
  • Debug, monitor and observe your serverless stack
  • Add your microservices to a continuous integration & continuous delivery pipeline
  • Estimate, and reduce maintenance and running costs


This video course is for developers, architects, DevOps, administrators and operations who would like to deploy Serverless computing and microservices in their organization.

About The Author

Richard T. Freeman: Richard Takashi Freeman has an M.Eng. in computer systems engineering and a Ph.D. in machine learning and natural language processing from the University of Manchester, UK. He is currently a lead big data and machine learning engineer at JustGiving; and a cloud architect, serverless computing, and machine learning freelance SME and consultant at Starwolf. He previously worked at PageGroup and Capgemini, and has been delivering cloud-based, big data, machine learning, serverless, and scalable solutions for over 14 years across different sectors.

He is a blogger; a speaker, presenting at various events; and the author of two video courses. You can visit his website, titled Richard Freeman, PhD, for his blog posts, presentations, and courses.

Table of contents

  1. Chapter 1 : Serverless Microservices Architecture Patterns
    1. The Course Overview
    2. Overview of Microservice Integration Patterns
    3. Communication Styles and Decomposition Microservice Patterns
    4. Serverless Computing to Implement Microservice Patterns
  2. Chapter 2 : Serverless Distributed Data Management Patterns
    1. Implementing Database Per Service and Shared Database Patterns
    2. Accessing DynamoDB from API Gateway Via a Lambda Function
    3. Accessing DynamoDB Directly from API Gateway
    4. Implementing the Transaction Log Tailing Pattern
    5. Implementing the Saga Pattern
    6. Securing Your DynamoDB Databases
  3. Chapter 3 : Accessing Relational Database Serverless Patterns
    1. Relational Versus Non-Relational Databases
    2. Overview of Amazon Virtual Private Cloud
    3. Setting Up Amazon Virtual Private Cloud for Accessing RDS and Aurora
    4. Setting Up RDS and Accessing It from Your Local Network
    5. Accessing RDS from API Gateway Via a Lambda Function
    6. Accessing Aurora from API Gateway Via a Lambda Function
    7. Securing Your RDS and Aurora Databases
  4. Chapter 4 : Serverless Query and Messaging Patterns
    1. API Gateway and API Composition Patterns
    2. Implementing the Serverless API Composition Patterns
    3. Event Sourcing and CQRS Patterns
    4. Architectures of the Serverless Event Sourcing Pattern
    5. Implementing the Serverless Event Sourcing Pattern
    6. Architectures of the Serverless CQRS Pattern
    7. Implementing the Serverless CQRS Pattern
    8. Securing Your Event Streams and Queries
  5. Chapter 5 : Serverless Monitoring and Observability Patterns
    1. Monitoring and Observability Patterns
    2. Implementing Serverless Metrics and Health Check API Patterns
    3. Implementing the Serverless Centralized Logging Pattern
    4. Implementing the Serverless Audit Logging Pattern
    5. Implementing the Serverless Distributed Tracing Pattern
    6. Creating a Serverless Discovery Service and Catalogue
  6. Chapter 6 : Serverless Continuous Integration and Continuous Delivery Pipelines
    1. Continuous Integration and Continuous Delivery
    2. Serverless Continuous Integration and Continuous Delivery Setup
    3. Using CodeCommit for the Serverless Data API Code
    4. Using CodeBuild to Build-Test the Serverless Data API Stack
    5. Using CodePipeline as CI/CD for the Serverless Data API Stack
    6. Using Other CI/CD Solutions with the Serverless Data API Stack
  7. Chapter 7 : Serverless Microservices at Scale in Production
    1. When to Use and Not Use Serverless Computing?
    2. Estimating Serverless Stack Costs
    3. Database and Event Streaming Scalability
    4. Web Scale Best Practices
    5. Conclusion

Product information

  • Title: Implementing Serverless Microservices Architecture Patterns
  • Author(s): Richard T. Freeman
  • Release date: May 2018
  • Publisher(s): Packt Publishing
  • ISBN: 9781788839570