Bagaimana untuk melaksanakan corak pemutus litar di GO?

Untuk melaksanakan corak pemutus litar di GO, gunakan perpustakaan sedia ada seperti hystrix-go atau daya tahan untuk kesederhanaan. 1. Gunakan perpustakaan untuk menentukan arahan dengan ambang untuk waktu tamat, permintaan serentak, dan peratusan ralat. 2. Memahami dan mengkonfigurasi ketiga-tiga negeri yang ditutup, terbuka, dan setengah terbuka-untuk menguruskan aliran permintaan dan pemulihan. 3. Secara pilihan membina versi asas sendiri untuk memahami mekanik dalaman seperti penjejakan kegagalan dan peralihan negeri. 4. Melaksanakan pemantauan dan metrik untuk menjejaki tingkah laku pemutus dalam pengeluaran dan memastikan setiap pergantungan mempunyai pemutus sendiri.

Melaksanakan corak pemutus litar di GO adalah cara yang kukuh untuk meningkatkan daya tahan perkhidmatan anda, terutama ketika berurusan dengan kebergantungan luaran. Idea ini mudah: jika panggilan atau panggilan API terus gagal, sementara berhenti membuat panggilan tersebut dan bukannya membiarkan kegagalan menumpuk dan berpotensi menurunkan seluruh sistem.

GO tidak mempunyai sokongan terbina dalam pemutus litar, tetapi tidak sukar untuk melaksanakannya-terutamanya dengan bantuan pakej sedia ada seperti hystrix atau resilience .

Gunakan perpustakaan yang ada untuk kesederhanaan

Cara yang paling mudah dan paling boleh dipercayai untuk memulakan adalah dengan menggunakan perpustakaan yang terawat dengan baik. Dua pilihan popular adalah:

• Hystrix-Go -Diilhamkan oleh Netflix Hystrix.
• Ketahanan - alternatif yang lebih mudah dan ringan.

Perpustakaan ini menyediakan pelaksanaan pemutus litar yang sedia ada, jadi anda tidak perlu membina segala-galanya dari awal.

Sebagai contoh, dengan hystrix , anda boleh menentukan arahan seperti ini:

 hystrix.configureCommand ("my_command", hystrix.commandconfig {
    Timeout: 1000,
    MaxConcurrentRequests: 100,
    Errorpercentthreshold: 25,
})

rentetan chan respons var

Respons = Make (Chan String, 1)

hystrix.do ("my_command", func () ralat {
    // Buat panggilan luaran anda di sini
    resp, err: = http.get ("https://some-api.com")
    jika err! = nil {
        kembali err
    }
    menangguhkan resp.body.close ()
    // respons proses ...
    Respons <- "Kejayaan"
    kembali nih
}, ralat func (err ralat) {
    // Logik Fallback
    Respons <- "Fallback"
    kembali nih
})

Keputusan: = <-response

Ini menubuhkan perintah yang dinamakan dengan ambang kegagalan dan tingkah laku sandaran.

Memahami negeri pemutus litar

Pemutus litar biasanya mempunyai tiga negeri:

• Ditutup - Permintaan melalui biasanya. Jika kegagalan melebihi ambang, ia akan dibuka.
• Terbuka - semua permintaan gagal cepat (tiada panggilan sebenar dibuat). Selepas tamat tempoh, bergerak ke setengah terbuka.
• Separuh terbuka -membolehkan permintaan terhad untuk memeriksa sama ada kebergantungannya sihat lagi.

Memahami negeri -negeri ini membantu anda mengkonfigurasi pemutus dengan betul. Sebagai contoh, anda mungkin mahu masa yang singkat jika anda menjangkakan pemulihan cepat, atau ambang ralat yang lebih tinggi jika perkhidmatan hiliran dikenali sebagai flaky.

Pilihan konfigurasi biasa termasuk:

• Tamat tempoh setiap permintaan
• Permintaan serentak maksimum
• Ambang peratusan ralat untuk perjalanan pemutus
• Tingkap tidur sebelum mencuba semula

Bina versi asas sendiri (untuk belajar)

Jika anda ingin tahu bagaimana ia berfungsi di bawah tudung, menulis versi minimum adalah latihan yang baik.

Pada terasnya, pemutus litar asas memerlukan:

• Kaunter untuk kegagalan baru -baru ini
• Pelacak Negeri (tertutup/terbuka/setengah terbuka)
• Pemasa untuk menetapkan semula selepas tersandung
• Mutex untuk melindungi akses serentak

Inilah garis besar versi mudah:

 Taipkan keadaan int

const (
    Keadaan tertutup = iota
    Dibuka
    Separuhopen
)

Taipkan litar struktur {
    Negeri Negeri
    FailureCount Int
    MaxFailures int
    LastFailure Time.Time
    Resettimeout Time.Duration
    mu sync.mutex
}

Func (CB *circuitbreaker) Panggilan (Ralat FunctFunc () Ralat) {
    cb.mu.lock ()
    jika cb.state == dibuka && time.since (cb.lastfailure)> cb.resetTimeout {
        cb.State = HalfOpen
    }
    jika cb.state == dibuka {
        cb.mu.unlock ()
        Kembali FMT.Errorf ("Breaker Circuit Open")
    }
    cb.mu.unlock ()

    err: = requestfunc ()
    cb.mu.lock ()
    menangguhkan cb.mu.unlock ()

    jika err! = nil {
        cb.failureCount  
        cb.lastFailure = time.now ()
        jika cb.failureCount> = cb.maxfailures {
            cb.state = dibuka
        }
        kembali err
    }

    cb.failureCount = 0
    kembali nih
}

Anda boleh mengembangkan ini dengan lebih banyak ciri seperti pemeriksaan kejayaan setengah terbuka atau penjejakan metrik.

Pertimbangkan pemantauan dan metrik

Malah pemutus litar yang dikonfigurasikan dengan baik tidak boleh dilepaskan kecuali anda tahu apa yang berlaku dalam pengeluaran. Sekurang -kurangnya, trek:

• Bilangan kegagalan dari masa ke masa
• Acara tersandung
• Penggunaan sandaran

Sesetengah perpustakaan sudah menawarkan integrasi dengan prometheus atau cangkuk pembalakan, yang menjadikan pemantauan lebih mudah.

Juga, elakkan meletakkan terlalu banyak operasi yang berbeza di belakang pemutus yang sama. Setiap harus diasingkan berdasarkan kebergantungan yang mereka targetkan.

Baiklah, itulah intipati melaksanakan pemutus litar di Go. Sama ada anda menggunakan perpustakaan atau gulung sendiri, kunci adalah untuk mengelakkan kegagalan cascading dan memberi peluang kepada sistem untuk pulih.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan corak pemutus litar di GO?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!