System Design Basics for Backend Developers · Pelajaran

Pemutus Sirkuit dan Degradasi Bertahap

Pelajari cara pemutus sirkuit mencegah kegagalan berantai dan cara degradasi bertahap menjaga sistem tetap berguna meskipun dependensinya gagal.

Pelajaran 4 dari 413 langkah

Pemutus Sirkuit dan Degradasi Bertahap adalah pelajaran System Design Basics for Backend Developers gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar System Design Basics for Backend Developers, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus System Design Basics for Backend Developers mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

The Cascading Failure Problem

In a system of dependent services, one slow service can drag down everything that calls it. Threads pile up waiting, queues fill, and the failure cascades across the whole system.

High availability means containing failures, not just preventing them.

What a Circuit Breaker Does

A circuit breaker wraps calls to a dependency. When failures cross a threshold, it opens and fails fast instead of waiting on a dead service.

  • Stops wasting threads on doomed calls
  • Gives the failing service time to recover

The Three States

A circuit breaker has three states:

  • Closed: calls flow normally, failures are counted
  • Open: calls fail immediately without hitting the dependency
  • Half-open: a few trial calls test whether the dependency recovered
CLOSED --(too many failures)--> OPEN
OPEN --(timeout elapsed)--> HALF_OPEN
HALF_OPEN --(trial succeeds)--> CLOSED
HALF_OPEN --(trial fails)--> OPEN

A Simple Breaker in Code

Here is the core idea: count failures, trip when a threshold is reached, and refuse calls while open.

class Breaker:
    def __init__(self, limit):
        self.fails = 0
        self.limit = limit
        self.open = False
    def call(self, ok):
        if self.open:
            return 'rejected'
        if ok:
            self.fails = 0
            return 'success'
        self.fails += 1
        if self.fails >= self.limit:
            self.open = True
        return 'failure'

b = Breaker(3)
for ok in [False, False, False, True]:
    print(b.call(ok))

Timeouts Are Essential

A breaker only helps if calls have timeouts. Without a timeout, a hung dependency holds a thread forever and failures are never counted. Always set aggressive, explicit timeouts on remote calls.

Retries and Backoff

Retries can help with transient errors but can also amplify an overload. Use exponential backoff with jitter and cap the retry count. Combine with a circuit breaker so retries stop entirely when the circuit is open.

import random
delay = 1
for attempt in range(4):
    wait = delay + random.uniform(0, delay)
    print('attempt', attempt, 'wait', round(wait, 2))
    delay *= 2

Graceful Degradation

Graceful degradation means the system still does something useful when a dependency is down, instead of returning an error.

  • Serve stale cached data
  • Hide a non-critical feature
  • Return a sensible default

Fallbacks

When the breaker is open, route to a fallback. For a product page, if the recommendations service is down, show a generic best-sellers list instead of failing the whole page.

def get_recommendations(breaker):
    if breaker.open:
        return ['bestseller-1', 'bestseller-2']
    return ['personalized-1', 'personalized-2']

Bulkheads

The bulkhead pattern isolates resources so one failing dependency cannot consume all threads or connections. Give each downstream dependency its own bounded pool — like watertight compartments in a ship.

Load Shedding

Under extreme load, it is better to reject some requests quickly than to slow down for everyone. Load shedding drops low-priority traffic to protect critical paths and keep latency bounded.

Putting It Together

Resilient services layer these patterns: tight timeouts, circuit breakers, bulkheads to isolate, fallbacks for degradation, and load shedding under pressure. Together they turn a potential outage into a minor, contained blip.

Quick Check

Test your understanding of circuit breakers.

Recap

You learned to contain failures for high availability:

  • Circuit breakers fail fast and cycle through closed, open, and half-open
  • Timeouts and capped backoff retries prevent overload amplification
  • Graceful degradation and fallbacks keep the system useful
  • Bulkheads and load shedding isolate and protect critical paths
Gratis untuk memulai

Belajar System Design Basics for Backend Developers dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus
12
Pelajaran
48

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pemutus Sirkuit dan Degradasi Bertahap” gratis?

Ya — teks lengkap “Pemutus Sirkuit dan Degradasi Bertahap” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus System Design Basics for Backend Developers, upgrade ke CoddyKit PRO. Kursus System Design Basics for Backend Developers mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pemutus Sirkuit dan Degradasi Bertahap”?

Pelajari cara pemutus sirkuit mencegah kegagalan berantai dan cara degradasi bertahap menjaga sistem tetap berguna meskipun dependensinya gagal. Kamu berlatih System Design Basics for Backend Developers dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai System Design Basics for Backend Developers?

Tidak diperlukan pengalaman sebelumnya. System Design Basics for Backend Developers di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Pemutus Sirkuit dan Degradasi Bertahap” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran System Design Basics for Backend Developers ini?

Ya. Setiap pelajaran System Design Basics for Backend Developers menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Mekanisme Redundansi dan Failover
  2. Perencanaan Pemulihan Bencana
  3. Pemantauan, Peringatan, dan Pencatatan
  4. Pemutus Sirkuit dan Degradasi Bertahap
← Kembali ke System Design Basics for Backend Developers