VOOZH about

URL: https://www.coursera.org/learn/packt-microservices-design-communication-and-data-handling-jwxt9

⇱ Microservices Architecture and Communication Patterns | Coursera

Microservices Architecture and Communication Patterns

Ends soon! Keep adding new skills with 10,000+ programs for $239 (usually $399). Save now.

Microservices Architecture and Communication Patterns

Included with

Gain insight into a topic and learn the fundamentals.
Intermediate level

Recommended experience

8 hours to complete
Flexible schedule
Learn at your own pace
Gain insight into a topic and learn the fundamentals.
Intermediate level

Recommended experience

8 hours to complete
Flexible schedule
Learn at your own pace

What you'll learn

  • Master the fundamentals of microservices communication, including synchronous, asynchronous, RESTful APIs, and gRPC.

  • Learn to implement API Gateways and patterns like BFF to optimize communication in microservices architectures.

  • Understand advanced data management techniques, such as CQRS, event sourcing, and database sharding.

  • Gain practical skills in handling microservices issues like service-to-service communication, and database bottlenecks,

Details to know

Shareable certificate

Add to your LinkedIn profile

Assessments

7 assignments

Taught in English

Build your subject-matter expertise

This course is part of the Microservices Architecture: Design Patterns & Principles Specialization
When you enroll in this course, you'll also be enrolled in this Specialization.
  • Learn new concepts from industry experts
  • Gain a foundational understanding of a subject or tool
  • Develop job-relevant skills with hands-on projects
  • Earn a shareable career certificate

There are 5 modules in this course

This course features Coursera Coach!

A smarter way to learn with interactive, real-time conversations that help you test your knowledge, challenge assumptions, and deepen your understanding as you progress through the course. This course will guide you through the essentials of microservices architecture and communication patterns. You will explore key communication strategies, such as synchronous and asynchronous communication, RESTful APIs, GraphQL, and gRPC. The course dives into advanced patterns like API Gateways, service-to-service communication, and event-driven architectures, preparing you to design and implement scalable microservices systems. You will also delve into data management within microservices, learning about database patterns like Database-per-Service, polyglot persistence, and CQRS. The course offers practical applications, including handling real-world problems like network traffic issues, database bottlenecks, and long-running operations in microservices. This course is ideal for software developers and engineers who have a basic understanding of system architecture. It’s perfect for those wanting to dive into microservices and their complex communication and data management patterns. By the end, you’ll be ready to build robust microservices systems with efficient communication and data handling strategies. By the end of the course, you will be able to design and implement microservices using various communication patterns, select appropriate databases for microservices, and optimize data management techniques, including CQRS and Event Sourcing.

In this module, we will cover the core principles of microservices communication, focusing on key differences with monolithic systems. You will explore synchronous vs asynchronous communication and learn how to design and implement RESTful APIs for seamless service interaction.

What's included

12 videos2 readings1 assignment

12 videos•Total 83 minutes
  • Microservices Communication Basics and Differences between Monoliths•7 minutes
  • Microservices Communication Types - Synchronous (Request-Driven) or Asynchronous•4 minutes
  • RESTful API Design for Microservices•14 minutes
  • Design: E-Shop Microservices with RESTful API Design•5 minutes
  • Code: E-Shop Microservices with RESTful API Design•16 minutes
  • Problem: Multiple Request (N+1) for Retrieving Relational Data•4 minutes
  • GraphQL: A Query Language for APIs•6 minutes
  • Design: Microservices Architecture with GraphQL API Design•4 minutes
  • Problem: Inter-service Communication Makes Heavy Load on Network Traffic•4 minutes
  • gRPC: High-Performance Remote Procedure Calls•7 minutes
  • Design: Microservices Architecture with gRPC API Design•6 minutes
  • Problem: Direct Client-to-Service Communication•4 minutes
2 readings•Total 20 minutes
  • Introduction to the course 'Microservices Architecture and Communication Patterns'•10 minutes
  • Full Specialization Resources•10 minutes
1 assignment•Total 15 minutes
  • Microservices Communications - The Basics - Assessment•15 minutes

In this module, we will dive into API Gateway patterns, exploring how they help manage and route traffic between microservices. You’ll design and implement the e-shop architecture using API Gateways, optimizing routing and communication for different client requirements.

What's included

13 videos1 assignment

13 videos•Total 77 minutes
  • Introduction: Microservices Communication Patterns - API Gateways•2 minutes
  • Gateway Routing, Gateway Aggregation, Gateway Offloading Patterns•8 minutes
  • API Gateway Pattern•4 minutes
  • Design: Microservices Architecture with API Gateway Design•7 minutes
  • Code: Microservices Architecture with API Gateway Design•16 minutes
  • Problem: Client Apps Have Different UI Requirements•4 minutes
  • Backends for Frontends Pattern - BFF Pattern•5 minutes
  • Design: Microservices Architecture with Backends for Frontends Pattern-BFF•6 minutes
  • Service-to-Service Communications Between Backend Internal Microservices•5 minutes
  • Problem: Service-to-Service Communication Chain Queries•4 minutes
  • Service Aggregator Pattern, Service Registry/Discovery Patterns•7 minutes
  • Design: Microservices Architecture with Service Aggregator, Registry/Discovery•6 minutes
  • Problem: Long Running Operations Can't Handle with Sync Communication•4 minutes
1 assignment•Total 15 minutes
  • Microservices Communication Patterns - API Gateways - Assessment•15 minutes

In this module, we will introduce asynchronous communication and event-driven architecture (EDA), exploring how these patterns support scalability and resilience. You will design and implement a publish/subscribe model in the e-shop’s microservices to optimize communication and system performance.

What's included

7 videos1 assignment

7 videos•Total 54 minutes
  • Introduction - Microservices Asynchronous Communication & Event-driven Architecture•4 minutes
  • Asynchronous Communication Types: One-to-One / One-to-Many•4 minutes
  • Event-Driven Architecture and Publish/Subscribe Pattern•8 minutes
  • Design: Microservices Architecture w/ EDA and Publish/Subscribe Pattern•7 minutes
  • Code: Microservices Architecture w/ EDA and Publish/Subscribe Patter•21 minutes
  • The Scale Cube & Stateful Application Horizontal Scaling•5 minutes
  • Problem: Databases Create Bottlenecks When Scaling•5 minutes
1 assignment•Total 15 minutes
  • Microservices Asynchronous Communication & Event-driven Architecture - Assessment•15 minutes

In this module, we will explore the principles and patterns of microservices data management, including how to choose the right database. You will learn about database-per-service, polyglot persistence, and scaling strategies like sharding to ensure data consistency and high performance in your microservices.

What's included

11 videos1 assignment

11 videos•Total 63 minutes
  • Introduction - Microservices Data Management Patterns and Principles•2 minutes
  • The Database-per-Service Pattern•3 minutes
  • The Shared Database Anti-Pattern and Polyglot Persistence Principle•5 minutes
  • Relational and NoSQL Databases - Document, Key-value, Graph-based, Column-based•9 minutes
  • When to Use Relational or No-SQL Databases?•6 minutes
  • How to Choose a Database for Microservices and CAP Theorem•11 minutes
  • Problem: Single Database Server Performs Low Performance•3 minutes
  • Data Partitioning: Horizontal, Vertical, and Functional Data Partitioning•8 minutes
  • Database Sharding Pattern & Tinder System Design Example•7 minutes
  • Design: Microservices Architecture with Database Sharding Pattern•7 minutes
  • Problem: Cross-Service Queries and Write Commands on Distributed Scaled Database•2 minutes
1 assignment•Total 15 minutes
  • Microservices Data Management - Choosing the Right Database - Assessment•15 minutes

In this module, we will discuss advanced microservices data management patterns like CQRS and event sourcing. You will learn how to separate commands and queries to improve performance and scalability, and design a system that ensures eventual consistency across distributed transactions.

What's included

8 videos1 reading3 assignments

8 videos•Total 50 minutes
  • Introduction - Microservices Data Management Patterns and Principles•6 minutes
  • Materialized View Pattern•6 minutes
  • CQRS — Command Query Responsibility Segregation Pattern•8 minutes
  • How to Sync Read and Write Databases in CQRS?•6 minutes
  • Event Sourcing Pattern with CQRS and Eventual Consistency Principle•6 minutes
  • Design Instagram System & Database Architecture•7 minutes
  • Design: Microservices Architecture with CQRS, Event Sourcing, Eventual Consistency•8 minutes
  • Problem: Manage Consistency Across Microservices in Distributed Transactions•1 minute
1 reading•Total 10 minutes
  • Conclusion to the Course 'Microservices Architecture and Communication Patterns'•10 minutes
3 assignments•Total 90 minutes
  • Microservices Data Management - Commands and Queries - Assessment•15 minutes
  • Full Course Assessment•60 minutes
  • Full Course Practice Assessment•15 minutes

Earn a career certificate

Add this credential to your LinkedIn profile, resume, or CV. Share it on social media and in your performance review.

Instructor

Offered by

Explore more from Networking

Why people choose Coursera for their career

👁 Image

Felipe M.

Learner since 2018
"To be able to take courses at my own pace and rhythm has been an amazing experience. I can learn whenever it fits my schedule and mood."
👁 Image

Jennifer J.

Learner since 2020
"I directly applied the concepts and skills I learned from my courses to an exciting new project at work."
👁 Image

Larry W.

Learner since 2021
"When I need courses on topics that my university doesn't offer, Coursera is one of the best places to go."
👁 Image

Chaitanya A.

"Learning isn't just about being better at your job: it's so much more than that. Coursera allows me to learn without limits."

Frequently asked questions

Microservices architecture is a design approach where a software system is composed of small, independent services that can be developed, deployed, and maintained separately. This approach offers advantages over monolithic systems by enabling scalability, flexibility, and resilience. It is highly relevant in modern software development because it supports continuous delivery, allows for independent scaling of services, and enables faster development cycles.

This course focuses on the core principles and patterns in microservices architecture, with a particular emphasis on communication strategies. It covers synchronous and asynchronous communication types, including RESTful APIs, GraphQL, gRPC, and more. The course dives deep into the design and implementation of these communication patterns, exploring advanced techniques such as API gateways, event-driven architecture, and data management strategies. By the end, you'll be equipped to build scalable, efficient, and flexible microservices-based systems.

Upon completing this course, you will have a comprehensive understanding of microservices communication patterns and how to implement them effectively. You will be able to design microservices with appropriate communication mechanisms, such as RESTful APIs, GraphQL, and gRPC. Additionally, you'll be proficient in using API gateways, event-driven architecture, and managing data across microservices, enabling you to build and maintain scalable microservices-based applications.

A basic understanding of software development and programming is required, especially familiarity with APIs, databases, and general web development. No prior knowledge of microservices architecture is necessary, as the course covers foundational concepts and progresses to more advanced topics. However, experience with monolithic systems and distributed systems will be beneficial in grasping the concepts more quickly.

This course is designed for software developers, engineers, and architects who are looking to transition to or deepen their knowledge in microservices architecture. It is ideal for professionals who want to learn how to design, implement, and manage microservices systems, as well as those interested in mastering microservices communication patterns to build scalable applications.

The course contains 5 hours of video content. The time to complete the course may vary depending on how much time you dedicate to reviewing materials, coding exercises, and applying the concepts. On average, it can be completed in a few days, with time allocated for hands-on practice and exploration of the various patterns discussed.

Yes, you can preview the first video and view the syllabus before you enroll. You must purchase the course to access content not included in the preview.

If you decide to enroll in the course before the session start date, you will have access to all of the lecture videos and readings for the course. You’ll be able to submit assignments once the session starts.

Once you enroll and your session begins, you will have access to all videos and other resources, including reading items and the course discussion forum. You’ll be able to view and submit practice assessments, and complete required graded assignments to earn a grade and a Course Certificate.

If you complete the course successfully, your electronic Course Certificate will be added to your Accomplishments page - from there, you can print your Course Certificate or add it to your LinkedIn profile.

This course is currently available only to learners who have paid or received financial aid, when available.

Yes. In select learning programs, you can apply for financial aid or a scholarship if you can’t afford the enrollment fee. If fin aid or scholarship is available for your learning program selection, you’ll find a link to apply on the description page.

Financial aid available,