Inflearn brand logo image
Inflearn brand logo image
Inflearn brand logo image
Programming

/

Back-end

Building Robust Systems That Tolerate Failures

This is a practical course covering how to build systems robust against failures. From design fundamentals for service stability, various patterns to prevent failure propagation, asynchronous processing using message queues, to strategies for maintaining distributed data consistency, you will learn the core technologies and concepts required for a stable backend system.

(4.9) 8 reviews

229 learners

  • foo
장애
이론 실습 모두
resilience4j
예외처리
Spring Boot
transaction
Kafka
data-consistency

Reviews from Early Learners

What you will learn!

  • Robust fault-tolerant system design

  • Kafka for Event-Driven Architecture Building Basics

  • Basics of Handling Transactions in a Distributed Environment

"I only changed one line of code, so why did unrelated services stop working too?"

Every developer faces such overwhelming moments at least once. You know the logic seems fine, but a small change spreads like a butterfly effect, threatening the stability of the entire system. Many developers initially focus on these availability issues - that is, 'keeping the server from going down.' This course starts with this fundamental problem, teaching you how to diagnose the causes of failures and build a solid foundation for robust systems through essential patterns like server redundancy, retry mechanisms, and circuit breakers.

However, the concerns of modern system design don't end here. As systems grow in scale and complexity, we introduce event-driven architecture where we divide services into smaller units and connect them through messaging systems like Kafka. This is a powerful way to reduce dependencies between services and gain flexibility, but it also creates new types of problems.

Here we encounter a more cunning and difficult question.

"What if the order request message is lost due to a network error?"

"What if the payment completion message is sent multiple times and the customer gets charged twice?"

"The order processing succeeded, but if inventory processing fails, how do we reconcile the data?"

As systems become distributed in this way, we face a more sophisticated and challenging problem beyond simple server 'failures': data consistency. This course takes it one step further, directly addressing reliability issues in distributed environments. You'll learn techniques for operating Kafka reliably while preventing message loss and duplication, and deeply explore how to ensure data consistency between distributed services through advanced patterns such as transactional outbox, compensating transactions, and idempotency handling.

Through this course, you will gain a comprehensive perspective on design that goes beyond simply creating code that 'functions' to building systems that operate 'reliably' even in exceptional circumstances. From incident response to distributed data processing, embark on a journey to secure the true 'stability' that modern backend systems demand.

Features of this course

📌 Shifting Perspective on Failures: This lecture doesn't simply list techniques for resolving errors. It views failures as an unavoidable property of systems and explores design perspectives on how to maintain overall system stability when failures occur.

📌 Core Principles and Patterns for Stability: Starting with server redundancy and scalability concepts that form the foundation of robust systems, we focus on understanding and applying the operating principles of stability patterns frequently used in practice, such as Retry and Circuit Breaker.

📌 Balance of Theory and Practice: First understand why each concept is necessary, then immediately apply what you've learned to hands-on practice. Through the process of directly creating failure scenarios and solving them, the course is structured to help you develop real problem-solving skills.

Course Content Preview




You'll learn this content

Principles of Robust System Design

Why do failures occur? Learn the reasons for dividing applications within services, the concepts of redundancy and replication, and scalability. Study key patterns that prevent cascading failure propagation, including exception and response status code handling, Retry, Timeout, Circuit Breaker, Fallback, Graceful Degradation, Rate Limit, and Bulkhead.

Messaging Systems and Event-Driven Architecture

What are the ways to reduce coupling between services and flexibly handle traffic surges? This course covers in-depth practical topics including Kafka's basic concepts and asynchronous communication implementation, message loss and delivery guarantee levels, DLQ (Dead Letter Queue) and ordering guarantees, handling message duplication that can occur in consumers, and key Kafka configurations that backend developers need to know.

Data Consistency in Distributed Environments

How can data maintain consistency in a microservices environment? Learn advanced patterns that ensure data integrity, including the causes of data consistency failures, the role of transactions and @Transactional, database concurrency issues and isolation levels.

Pre-enrollment Reference Information

Practice Environment

  • Operating System and Version (OS): Windows 10

  • Tools used: IntelliJ Community 2023.2, Google Chrome, Docker Desktop


Learning Materials

Prerequisites and Important Notes

  • This course is conducted based on Java and Spring Boot applications. However, since the main content of the course focuses on concepts rather than code-level details, after practicing with Java and Spring Boot, there shouldn't be much difficulty in applying it to other languages and frameworks. (Some features may not be supported by the libraries themselves)

  • We will not be uploading to a server for the practice, but will only conduct the practice in a local development environment. Necessary components such as Kafka, Database, etc. will be run through Docker Desktop.

  • If you have any questions while taking the course, please leave your questions. If there is content that needs to be updated, I will update it.

Recommended for
these people

Who is this course right for?

  • Those who want to design robust systems and prevent failure spread using Retry, Timeout, Circuit Breaker, etc.

  • For new Kafka users, or those desiring to build stable asynchronous communication architectures beyond messaging queue basics.

  • A backend developer who wants to understand transactions and idempotency in a distributed environment, and learn methods to ensure data consistency.

Need to know before starting?

  • Spring Boot Backend Development Experience

Hello
This is

5,206

Learners

220

Reviews

104

Answers

4.9

Rating

9

Courses

안녕하세요.

멘토링을 하면서 주니어 개발자들이 어려워 하는 개념들에 대해 어떻게 하면 쉽게 전달할 수 있을지에 대해서 많은 고민을 하고 있는 푸(Foo)라고 합니다.

잘 부탁 드리겠습니다.


이력

  • 2019. 08 ~ 현재 : 카카오 자바 백엔드 개발자

  • 2021. 08 ~ 현재 : programmers 백엔드 데브코스 멘토

  • 2021. 12 ~ 현재 : F-Lab 자바 백엔드 멘토

 

  • 이것이 취업을 위한 백엔드 개발이다 with 자바(링크)

 

기타 이력 및 타 플랫폼 강의들은 아래 GitHub 링크에서 확인할 수 있습니다.

GitHub - https://github.com/lleellee0

Curriculum

All

32 lectures ∙ (8hr 45min)

Course Materials:

Lecture resources
Published: 
Last updated: 

Reviews

All

8 reviews

4.9

8 reviews

  • s9285s님의 프로필 이미지
    s9285s

    Reviews 2

    Average Rating 5.0

    5

    32% enrolled

    • jsl님의 프로필 이미지
      jsl

      Reviews 2

      Average Rating 5.0

      5

      100% enrolled

      Tôi nghĩ đây là khóa học bắt buộc đối với các nhà phát triển backend.

      • tails님의 프로필 이미지
        tails

        Reviews 8

        Average Rating 5.0

        5

        63% enrolled

        • brunobi9004님의 프로필 이미지
          brunobi9004

          Reviews 4

          Average Rating 4.0

          5

          100% enrolled

          Bài giảng tuyệt vời

          • dongbinyoon3448님의 프로필 이미지
            dongbinyoon3448

            Reviews 3

            Average Rating 5.0

            5

            78% enrolled

            Mã thực hành được viết rất tỉ mỉ và chi tiết nên rất tốt. Phần giải thích cũng rất rõ ràng và gọn gàng nữa~

            $42.90

            foo's other courses

            Check out other courses by the instructor!

            Similar courses

            Explore other courses in the same field!