🚪 API Gateway и service discovery
Когда сервисов десять, а экземпляров у каждого от двух до двадцати, у системы появляются две задачи. Мобильному приложению нужен один адрес вместо десяти, это работа API Gateway. Сервису заказов нужно найти живой экземпляр оплаты, хотя поды переезжают и меняют IP при каждом деплое, это service discovery вместе с балансировкой. На собеседовании это спрашивают как «зачем нужен API Gateway», «что такое BFF» и «как сервисы находят друг друга в Kubernetes»
🚪 Что делает шлюз
API Gateway — единая точка входа для внешних клиентов. Клиент знает один адрес, api.shop.ru, а шлюз решает, в какой сервис отправить запрос. Шлюз делает четыре вещи:
- маршрутизация.
/orders/*уходит в сервис заказов,/users/*в сервис пользователей. Клиент не знает, как система поделена на сервисы, и её можно переделить, не выпуская новую версию приложения - сквозные задачи. TLS, проверка токена, rate limiting, логи доступа, CORS. Их делают один раз на входе, а не в каждом сервисе. Сервисы за шлюзом при этом всё равно проверяют права на свои данные: шлюз знает, кто пришёл, но не знает, чей это заказ
- агрегация. Экран товара требует карточку, цену, остатки и отзывы. Без шлюза телефон делает четыре запроса по мобильной сети, со шлюзом один, а четыре идут внутри дата-центра по быстрой и стабильной сети
- перевод протоколов. Снаружи REST и JSON, внутри gRPC. Шлюз переводит одно в другое, и внутренние сервисы не обязаны держать публичный API
Плата — ещё один сетевой прыжок и ещё один компонент, который надо выкатывать, масштабировать и чинить. Шлюз стоит на пути каждого запроса, поэтому его запускают в нескольких экземплярах за балансировщиком
Готовые решения: Envoy и шлюзы на нём, Kong, NGINX, облачные API Gateway. Для своей логики агрегации часто пишут небольшой сервис на Go: стандартная библиотека уже умеет проксировать
BFF: шлюз под каждый клиент
Один общий шлюз на веб, iOS, Android и партнёров со временем разрастается. Каждой команде нужен свой эндпоинт и своя форма ответа, все правят один репозиторий, и шлюз превращается в узкое место релизов. Сэм Ньюман описал в 2015 году альтернативу: Backend for Frontend, отдельный бэкенд под каждый вид клиента. Его правило «один опыт, один BFF»: мобильному приложению свой, вебу свой, партнёрскому API свой
BFF держит та команда, что делает интерфейс. Она меняет экран и его API в одном релизе, ни с кем не договариваясь. Обратная сторона — похожий код в нескольких BFF. Ньюман советует не спешить выносить его в общую библиотеку: общая библиотека связывает команды сильнее, чем дублирование
| Что делает | Где живёт | Пример | |
|---|---|---|---|
| Балансировщик L4 | Раскидывает TCP-соединения, в HTTP не смотрит | Перед кластером, в каждой ноде Kubernetes | облачный NLB, kube-proxy |
| Reverse proxy, L7-балансировщик | Терминирует TLS, маршрутизирует по пути и заголовкам | На входе | NGINX, Envoy |
| API Gateway | То же плюс авторизация, лимиты, агрегация, перевод протоколов | На входе | Kong, Envoy Gateway, свой сервис |
| BFF | Шлюз под один клиент, API под его экраны | На входе, по одному на клиента | mobile-bff, web-bff |
| Service mesh | Балансировка, ретраи и mTLS между сервисами | Сайдкар или агент рядом с каждым сервисом | Istio, Linkerd |
Шлюз отвечает за трафик снаружи внутрь (north-south), mesh за трафик между сервисами (east-west). В Kubernetes вход описывают ресурсом Ingress или более новым Gateway API. Популярный контроллер ingress-nginx перестал получать обновления, в том числе исправления уязвимостей, в марте 2026 года, и проект Kubernetes советует переходить на Gateway API
🧭 Service discovery
Сервису заказов нужен адрес оплаты. Прописать IP в конфиг нельзя: под пересоздаётся при каждом деплое, автоскейлер добавляет и убирает экземпляры, упавший экземпляр надо перестать использовать за секунды. Нужен реестр сервисов, где лежит актуальный список живых экземпляров, и способ им пользоваться
Экземпляры попадают в реестр двумя путями. Сервис регистрируется сам при старте и шлёт heartbeat, так работают Consul и Eureka. Или его регистрирует платформа: в Kubernetes контроллер следит за подами по селектору сервиса и сам обновляет список адресов в объектах EndpointSlice
Дальше два способа найти экземпляр:
| Клиентский discovery | Серверный discovery | |
|---|---|---|
| Кто выбирает экземпляр | Клиент сам читает реестр и балансирует | Клиент шлёт на постоянный адрес, выбирает роутер |
| Сетевые прыжки | Прямо в экземпляр | Через прокси или балансировщик |
| Что нужно клиенту | Библиотека под каждый язык | Ничего, обычный HTTP или gRPC |
| Примеры | gRPC с round_robin, Consul API, Eureka и Ribbon | Service в Kubernetes, облачный балансировщик |
Как это сделано в Kubernetes
У обычного Service есть ClusterIP, виртуальный адрес, и DNS-имя вида payments.shop.svc.cluster.local. Имя резолвится в этот один адрес. На каждой ноде kube-proxy прописывает правила iptables или nftables, и пакет на ClusterIP уходит на случайный под из готовых. Под, который не прошёл readiness-пробу, из списка выпадает, трафик на него не идёт
kube-proxy выбирает под один раз на соединение, а не на запрос. Для HTTP/1.1 с короткими соединениями нагрузка ложится ровно. Для gRPC, который держит одно долгое HTTP/2-соединение, весь трафик клиента уходит в один под, даже если их десять. Подробнее об этом на странице «gRPC и Protocol Buffers»
У headless Service (clusterIP: None) виртуального адреса нет, и kube-proxy его не обслуживает. DNS возвращает IP всех готовых подов, клиент выбирает сам. Это и есть клиентский discovery на средствах Kubernetes
⚖️ Как выбрать экземпляр
Список живых экземпляров есть. Каким отдать запрос, решает алгоритм балансировки:
- round robin — по кругу. Просто и честно, пока все экземпляры одинаковые и запросы примерно равные по цене. Если один запрос строит отчёт минуту, а другой отдаёт кэш за миллисекунду, круг даёт перекос
- random — случайный экземпляр. В Envoy отмечают, что без health checks он ведёт себя лучше round robin
- least request — туда, где меньше активных запросов. Полный перебор на каждом запросе дорог, поэтому Envoy берёт два случайных экземпляра и отдаёт запрос менее загруженному из двух. Это power of two choices: по документации Envoy, почти так же хорошо, как полный перебор, но за постоянное время, и без стада, когда все клиенты разом бросаются на один свободный экземпляр
- consistent hashing — экземпляр выбирается по хэшу ключа, например
user_id. Один пользователь всегда попадает в один экземпляр, где лежит его локальный кэш. Когда экземпляр добавляют или убирают, переезжает только часть ключей, а не все. Варианты в Envoy: ring hash и Maglev
Балансировщик должен узнать, что экземпляр умер. Активные проверки — он сам дёргает /healthz или gRPC Health раз в несколько секунд. Пассивные — смотрит на ответы живого трафика и выкидывает экземпляр после серии ошибок 5xx или таймаутов. Пассивные ловят сбои, которые /healthz не видит: экземпляр жив, а запросы падают. Зато про экземпляр без трафика они ничего не знают. Обычно включают оба вида
🛠️ На практике
Маленький шлюз на стандартной библиотеке: проверка токена, маршрут по префиксу, round robin по экземплярам и X-Forwarded-For. Rewrite в httputil.ReverseProxy появился в Go 1.20, старый Director в документации помечен устаревшим: он пропускает входящие X-Forwarded-* от клиента, и тот может подделать свой IP
Go · Шлюз на httputil.ReverseProxy
type pool struct {
targets []*url.URL
next atomic.Uint64
}
func (p *pool) pick() *url.URL {
n := p.next.Add(1)
return p.targets[n%uint64(len(p.targets))]
}
type route struct {
prefix string
proxy *httputil.ReverseProxy
}
func newRoute(prefix string, p *pool) route {
return route{prefix, &httputil.ReverseProxy{
Rewrite: func(r *httputil.ProxyRequest) {
r.SetURL(p.pick()) // каждый запрос — следующему экземпляру
r.SetXForwarded()
},
}}
}
func gateway(routes []route) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Header.Get("Authorization") == "" {
http.Error(w, "unauthorized", http.StatusUnauthorized)
return
}
for _, rt := range routes {
if strings.HasPrefix(r.URL.Path, rt.prefix) {
rt.proxy.ServeHTTP(w, r)
return
}
}
http.NotFound(w, r)
})
}Два экземпляра заказов и один пользователей, четыре запроса с токеном и один без него:
200 orders-2 /orders/42 xff=127.0.0.1
200 orders-1 /orders/43 xff=127.0.0.1
200 users-1 /users/7 xff=127.0.0.1
404 404 page not found
401 без токенаМаршрут ищется до прокси, поэтому /payments/1 получает 404. Без этой проверки запрос ушёл бы в прокси без адреса назначения и получил 502 Bad Gateway, ответ ReverseProxy по умолчанию на любую ошибку. В настоящем шлюзе сюда же добавляют таймауты транспорта, ErrorHandler со своим форматом ошибки и метрики по маршрутам
Клиентская балансировка в gRPC включается одной строкой конфигурации. По умолчанию политика pick_first: клиент подключается к первому адресу, который ответил, и шлёт всё туда. Чтобы ходить по кругу, нужен round_robin и адрес headless Service:
conn, err := grpc.NewClient(
"dns:///payments-headless.shop.svc.cluster.local:50051",
grpc.WithTransportCredentials(insecure.NewCredentials()),
grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"round_robin": {}}]}`),
)На двух локальных серверах и 100 вызовах это выглядит так: pick_first дал 100 и 0, round_robin 50 и 50
С DNS есть подвох. Резолвер grpc-go перечитывает адреса, когда рвётся соединение, а не по таймеру. Добавили пять подов, а старые клиенты о них не узнают, пока у них не порвутся соединения. Лечат на сервере: keepalive.ServerParameters{MaxConnectionAge: 5 * time.Minute} раз в пять минут закрывает соединение через GOAWAY, клиент переподключается и заново спрашивает DNS. По умолчанию возраст соединения не ограничен
⚠️ Где ошибаются
- Бизнес-логика в шлюзе. Сначала в шлюз кладут проверку токена, потом «если у пользователя нет подписки, не отдавать курс», потом расчёт скидки. Через год шлюз знает правила всех доменов, и любое изменение в продукте требует его релиза. Шлюз решает, кто пришёл и куда отправить, а правила домена живут в сервисах
- Один шлюз на всех клиентов. Веб, мобильные и партнёры правят один код, и релиз одного ждёт тестов всех. Если клиенты сильно различаются, делят на BFF
- Шлюз как единственная проверка прав. Шлюз проверил токен, а сервис заказов верит любому
user_idв заголовке. Любой, кто достучится до сервиса внутри сети в обход шлюза, получит чужие данные. Сервис проверяет подпись токена или mTLS сам - Ретраи на каждом слое. Шлюз делает до трёх попыток, сервис внутри тоже до трёх, его клиент к базе ещё до трёх. Медленная база получает 27 запросов вместо одного. Повторы делают в одном месте, об этом страница «Таймауты, ретраи и circuit breaker»
- Адрес, разрезолвленный один раз. Сервис при старте получает IP из DNS, кладёт в переменную и ходит туда до рестарта. Под переехал, а клиент стучится в пустоту. Отдавай клиенту имя и пусть резолвит библиотека:
dns:///в gRPC, имя Service в HTTP-клиенте
🎯 Вопросы с собеседований
Зачем нужен API Gateway?
Это единая точка входа для внешних клиентов. Он маршрутизирует запросы по сервисам и скрывает от клиента, как система поделена. На входе один раз делают TLS, проверку токена, rate limiting и логи доступа. Ещё шлюз может собрать ответ из нескольких сервисов за один запрос клиента и перевести REST снаружи в gRPC внутри. Плата — лишний сетевой прыжок и компонент, который сам должен быть отказоустойчивым
Что такое BFF и когда он нужен?
Backend for Frontend — отдельный шлюз под каждый вид клиента: веб, мобильное приложение, партнёров. Каждый отдаёт API под свои экраны, и его держит команда этого интерфейса, поэтому она выпускает экран и API вместе, без согласований. Нужен, когда клиенты сильно различаются по данным и сценариям или когда общий шлюз стал узким местом релизов. Если клиент один и агрегации почти нет, хватит обычного шлюза
Чем API Gateway отличается от балансировщика и от service mesh?
Балансировщик раскидывает трафик по экземплярам одного сервиса, L4 по соединениям, L7 по запросам. Шлюз сверху добавляет маршрутизацию между разными сервисами, авторизацию, лимиты и агрегацию. Оба обычно стоят на входе и обслуживают трафик снаружи. Service mesh работает между сервисами: прокси рядом с каждым сервисом дают балансировку, ретраи, mTLS и метрики без изменения кода
Что такое service discovery и какие бывают виды?
Это способ узнать актуальные адреса живых экземпляров сервиса, потому что они постоянно меняются. Адреса лежат в реестре: сервис регистрируется сам, как в Consul, или его регистрирует платформа, как Kubernetes через EndpointSlice. При клиентском discovery клиент читает реестр и сам выбирает экземпляр, прыжков меньше, но нужна библиотека под каждый язык. При серверном клиент шлёт на постоянный адрес, а экземпляр выбирает балансировщик, как Service в Kubernetes
Как сервисы находят друг друга в Kubernetes?
Через DNS и Service. Имя payments.shop.svc.cluster.local резолвится в ClusterIP, а kube-proxy на каждой ноде направляет соединение на один из готовых подов. Список подов Kubernetes ведёт сам по селектору и readiness-пробам. Если нужно балансировать на клиенте, делают headless Service с clusterIP: None: тогда DNS возвращает IP всех подов
Почему gRPC плохо балансируется через обычный Service?
kube-proxy выбирает под один раз на TCP-соединение, а gRPC держит одно долгое HTTP/2-соединение и гонит по нему все вызовы. В итоге клиент нагружает один под, остальные простаивают. Решения: L7-прокси или mesh, которые балансируют каждый запрос, или клиентская балансировка через headless Service и политику round_robin. Во втором случае на сервере ставят MaxConnectionAge, чтобы клиенты периодически переподключались и узнавали о новых подах
Какие алгоритмы балансировки знаешь?
Round robin по кругу, хорош для одинаковых экземпляров и запросов. Least request отправляет туда, где меньше активных запросов, на практике через power of two choices: берут два случайных экземпляра и выбирают менее загруженный. Consistent hashing привязывает ключ, например пользователя, к экземпляру, это нужно для локального кэша или сессий, и при изменении числа экземпляров переезжает только часть ключей. Ещё есть random и взвешенные варианты для экземпляров разной мощности
📚 Что почитать
- Pattern: API Gateway / Backends for Frontends — Крис Ричардсон коротко о задачах шлюза, его плюсах и минусах
- Pattern: Backends For Frontends — Сэм Ньюман о том, зачем делить шлюз по клиентам и кто его держит
- DNS for Services and Pods — какие DNS-записи Kubernetes создаёт для обычного и headless Service
- Supported load balancers — документация Envoy: round robin, least request с P2C, ring hash и Maglev