К содержимому
Войти

Python Road Map

🚪 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 и RibbonService в 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 и взвешенные варианты для экземпляров разной мощности

📚 Что почитать