Какие паттерны и подходы используются в Go для реализации Graceful Degradation (грациозной деградации)?

А, слушай, смотри, вот эта ваша "Graceful Degradation" — это, блядь, такая штука, когда система, вместо того чтобы накрыться медным тазом и всем сказать "пиздец, я умерла", начинает, типа, прикидываться шлангом, но в рабочем режиме. Ну, знаешь, как в жизни: интернет отвалился, а ты не рыдаешь, а идёшь книжку почитать. Вот и тут так же.

1. Тайм-ауты, ёпта!

Это основа основ, хули. Нельзя ждать ответа от какого-нибудь левого микросервиса до второго пришествия, а то все ресурсы сожрёт. В Go это делается через context, и это, блядь, охуенно удобно.

// Ставим таймер на две секунды, и всё, приехали
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel() // Обязательно отменяй, а то память потечёт

// Кидаем этот контекст в какую-нибудь долгую операцию
result, err := someSlowOperation(ctx)
if err != nil {
    // Если нас просто прибили тайм-аутом — это не конец света
    if errors.Is(err, context.DeadlineExceeded) {
        // Да похуй, вернём что-нибудь из кэша или дефолтное
        return fallbackValue, nil
    }
    return nil, err
}

2. Повторные попытки (Retry)

Ну, бывает же — споткнулся, упал. Сервис чихнул на миллисекунду и отвалился. Так что, сразу вешаться? Не, давай попробуем ещё разочек, аккуратненько. Главное — не долбить его как маньяк, а то он вообще обидится. Используем Exponential Backoff, чтобы между попытками делать паузу всё больше и больше.

Вот, смотри, как с библиотекой retry-go:

err := retry.Do(
    func() error {
        return unreliableOperation() // Наш шаткий дружок
    },
    retry.Attempts(3),        // Три раза стукнем
    retry.Delay(200*time.Millisecond), // Начнём с небольшой паузы
    retry.DelayType(retry.BackOffDelay), // А потом будем ждать всё дольше
)

3. Предохранитель (Circuit Breaker)

Это, блядь, гениальная штука, прям как в электрике. Если соседний сервис начал сыпаться как сумасшедший, мы не будем продолжать тыкаться в него палкой. Мы скажем: "всё, дружок, отдыхай", и на время закроем ему доступ. Запросы к нему просто не пойдут, а мы сразу вернём какую-нибудь заглушку. Дадим ему прийти в себя. Через некоторое время осторожненько пошлём один запрос-пробник. Если ок — снова пускаем трафик. Если нет — опять в бан.

Работает это на трёх состояниях, как у нормального человека:

• Closed: Всё работает, запросы летят.
• Open: Всё, пиздец, запросы не пускаем, сразу отбой.
• Half-Open: Ну-ка, один разочек попробуем, живой ли ты ещё.

Глянь пример с gobreaker:

cb := gobreaker.NewCircuitBreaker(gobreaker.Settings{
    Name:        "my-service",
    MaxRequests: 1, // В полуоткрытом состоянии пустим только один запрос
    Timeout:     30 * time.Second, // Сколько сидеть в состоянии Open
})

_, err := cb.Execute(func() (interface{}, error) {
    return someUnstableService.Call() // Вызов нашего проблемного чувака
})

if err != nil {
    // Ага, предохранитель сработал! Быстренько даём fallback
    return cachedData, nil
}

4. Изоляция (Bulkhead)

Представь себе корабль. Если в одном отсеке пробоина, вода не должна залить весь корабль, потому что есть переборки. Вот и тут так же. Нужно изолировать разные типы операций или ресурсы друг от друга. Например, чтобы сбой в модуле "Отправка спама" не положил весь сервер и не сломал модуль "Приём платежей". В Go часто делают на семафорах — это как ограниченное количество пропусков в клуб.

// Делаем семафор на 10 горутин. Больше не влезет.
var semaphore = make(chan struct{}, 10)

func HandleRequest(req *http.Request) {
    semaphore <- struct{}{} // Занимаем место. Если мест нет — ждём.
    defer func() { <-semaphore }() // Выходим — освобождаем место.

    // ... вот тут делаем свою опасную хуйню ...
}

5. Fallback (Запасной аэродром)

Ну, а если всё-таки приплыли, и основной путь отвалился? Надо же что-то клиенту ответить, а не морозить его в ожидании. Вот тут и включается запасной план:

• Достать из кэша: Дать данные, которые были актуальны пять минут назад. Лучше устаревшие, чем никакие.
• Значение по умолчанию: "Извините, сервис временно недоступен, но вы можете посмотреть вот это".
• Позвать другого: Обратиться к какому-нибудь простенькому, но стабильному резервному сервису.

6. Health Checks (Измеряем пульс)

А как мы узнаем, что сервис-зависимость сдох? Надо же его периодически щупать, проверять, дышит ли. Эти проверки здоровья — они как раз и кормят информацией все предыдущие паттерны, особенно Circuit Breaker.

Итог, блядь: Если накидать всё это вместе — тайм-ауты, повторные попытки, предохранители, изоляцию и запасные варианты — получается система, которую о-о-очень сложно полностью убить. Она будет хромать, косить, плеваться, но какую-то работу делать будет. А это, в общем-то, и есть цель.