# Вопросы на собеседовании по gRPC

55 вопросов с реальных собеседований. Здесь открытые: первые вопросы каждой подтемы с коротким ответом (первый абзац эталона) и источником. Все вопросы с ответами и AI-разбором — в тренажёре JobJump.

Страница: https://jobjump.app/questions/grpc

## Модель вызова и HTTP/2

### Чем вызов метода gRPC отличается от REST-запроса к ресурсу: что задаёт контракт, что возвращается в случае ошибки и что клиент знает о сервере заранее?

Контракт gRPC задаёт операции сервиса и типы их сообщений, ошибка приходит как один из фиксированных кодов статуса gRPC, а клиент знает методы и типы заранее: его заглушка сгенерирована из того же `.proto`. В REST операцию задаёт метод HTTP над ресурсом, ошибку — код статуса HTTP, а форму тела сам протокол не определяет.

Источник: https://grpc.io/docs/what-is-grpc/core-concepts/

### Клиент вызывает `orders.v1.OrderService/CreateOrder`. Какие кадры HTTP/2 несут сам вызов в одну и в другую сторону (служебные кадры соединения не считаем) и где в них окажется само сообщение?

Клиент отправляет HEADERS и DATA, сервер отвечает HEADERS, DATA и ещё одним HEADERS; само сообщение лежит в DATA и идёт после пяти служебных байтов.

Источник: https://github.com/grpc/grpc/blob/df3dd4dcb1409c826341a0df6eb808f741e58dea/doc/PROTOCOL-HTTP2.md

### Прокси логирует для каждого вызова gRPC код HTTP 200, а клиенты жалуются на ошибки. Почему код HTTP не совпадает с исходом вызова и где искать настоящий статус?

Потому что gRPC передаёт исход вызова в поле `grpc-status` трейлеров, а HTTP-статус ответа остаётся 200 и для успеха, и для ошибки. Настоящий код лежит в последнем блоке HEADERS ответа, рядом с `grpc-message`.

Источник: https://github.com/grpc/grpc/blob/df3dd4dcb1409c826341a0df6eb808f741e58dea/doc/PROTOCOL-HTTP2.md

## Protobuf и эволюция схемы

### Почему одно и то же сообщение в protobuf обычно занимает меньше байтов, чем в JSON, и что получатель не сможет сделать без файла схемы?

В protobuf на проводе нет имён полей, кавычек и скобок: сообщение — последовательность записей «номер поля и тип кодирования, затем значение», а целые числа занимают столько байтов, сколько нужно. Без схемы получатель разберёт только номера, типы кодирования и значения, а имён и точных типов полей не узнает.

Источник: https://protobuf.dev/programming-guides/encoding/

### В proto3 поле `int32 discount_percent = 7;`. Сервер получил запрос, где поле равно 0. Как отличить «скидку 0 %» от «клиент поле не заполнил» и что для этого поменять в схеме?

Пометьте поле как `optional`: `optional int32 discount_percent = 7;`. Тогда сообщение хранит признак «поле задано», и 0 отличается от отсутствия.

Источник: https://protobuf.dev/programming-guides/field_presence/

### Почему первым значением enum `OrderStatus` ставят `ORDER_STATUS_UNSPECIFIED = 0`, а не `ORDER_STATUS_CREATED = 0`? Что получит старый клиент, если сервер пришлёт значение enum, которого клиент не знает?

Нулевое значение — это то, что получает незаполненное поле, и то, что в proto3 не передаётся по сети. Поэтому в нём не должно быть бизнес-смысла: с `ORDER_STATUS_CREATED = 0` любое сообщение без статуса читалось бы как «создан». Старый клиент неизвестное значение не потеряет и не заменит нулём: оно сохранится как число.

Источник: https://protobuf.dev/programming-guides/proto3/

## Кодогенерация, линт и ломающие изменения

### Что генерируют `protoc-gen-go` и `protoc-gen-go-grpc` из `orders.proto` и почему это два плагина, а не один?

`protoc-gen-go` создаёт `orders.pb.go`: структуры сообщений, типы и константы enum и код сериализации. `protoc-gen-go-grpc` создаёт `orders_grpc.pb.go`: интерфейс клиента с конструктором `NewOrderServiceClient`, интерфейс сервера `OrderServiceServer`, встраиваемую заготовку `UnimplementedOrderServiceServer` и функцию `RegisterOrderServiceServer`. Плагинов два, потому что генератор сообщений protobuf для Go по умолчанию сервисов не обрабатывает, а код gRPC выпускает отдельная программа из проекта grpc-go.

Источник: https://protobuf.dev/reference/go/go-generated/

### Пять сервисов вызывают сервис заказов. Как им получать актуальный `orders.proto` и сгенерированный код и чем плох вариант «каждый копирует файл к себе»?

Держите `orders.proto` в одном месте и выдавайте потребителям версионируемый артефакт, модуль схемы или сгенерированный пакет, а не файл. Тогда у всех пяти сервисов одна схема, а версия контракта видна в зависимостях.

Источник: https://buf.build/docs/generate/

### Как настроить CI, чтобы пулреквест, который ломает совместимость `orders.proto`, не прошёл, и с чем именно сравнивается схема?

Добавьте в CI шаг `buf breaking`: при ломающем изменении он завершается с ошибкой, и пулреквест не проходит проверку. Схема из пулреквеста сравнивается с базовой версией: веткой, тегом или коммитом Git, модулем BSR или архивом.

Источник: https://buf.build/docs/breaking/usage/

## Коды статуса и ошибки

### Какой код статуса вернуть, если заказ не найден, заказ уже отменён и его нельзя оплатить, у пользователя нет прав на заказ, база данных недоступна? Как клиент должен реагировать на каждый?

Заказ не найден — `NOT_FOUND`, оплата отменённого заказа — `FAILED_PRECONDITION`, нет прав на заказ — `PERMISSION_DENIED`, база недоступна — `UNAVAILABLE`. Код выбирают по тому, что должен сделать клиент после ответа.

Источник: https://github.com/grpc/grpc/blob/v1.85.1/doc/statuscodes.md

### Чем отличаются `FAILED_PRECONDITION`, `ABORTED` и `UNAVAILABLE` с точки зрения клиента, который решает, повторять ли вызов?

Они отвечают на вопрос, на каком уровне повторять. `UNAVAILABLE`: можно повторить только упавший вызов. `ABORTED`: повторять нужно уровнем выше, начав операцию заново. `FAILED_PRECONDITION`: не повторять, пока состояние системы явно не исправили. Так различает три кода документация gRPC.

Источник: https://github.com/grpc/grpc/blob/v1.85.1/doc/statuscodes.md

### Какие коды статуса может вернуть сама библиотека gRPC, даже если код приложения их никогда не возвращает, и что теряет клиент, если приложение возвращает такой код от своего имени?

Библиотека сама порождает `CANCELLED`, `DEADLINE_EXCEEDED`, `UNIMPLEMENTED`, `UNAVAILABLE`, `UNKNOWN`, `INTERNAL`, `UNAUTHENTICATED` и `RESOURCE_EXHAUSTED`, а при сбросе потока HTTP/2 с кодом `INADEQUATE_SECURITY` ещё и `PERMISSION_DENIED`. Если приложение возвращает такой же код, клиент перестаёт отличать статус приложения от статуса библиотеки.

Источник: https://github.com/grpc/grpc/blob/v1.85.1/doc/statuscodes.md

## Дедлайны, отмена и повторы

### Клиент вызывает сервис заказов без дедлайна, а сервис завис на запросе к базе. Что будет с клиентом и с ресурсами обеих сторон?

Клиент будет ждать ответа практически вечно, а ресурсы обеих сторон останутся занятыми, пока вызов кто-то не оборвёт. По умолчанию gRPC не ставит дедлайн, и документация требует задавать реалистичный срок явно.

Источник: https://grpc.io/docs/guides/deadlines/

### Шлюз вызывает сервис заказов с дедлайном 800 мс, тот тратит 300 мс и вызывает сервис оплаты. Какой срок получит сервис оплаты и что будет, если сервис заказов создаст для этого вызова новый контекст без срока?

Сервис оплаты получит около 500 мс, потому что библиотека переводит дедлайн в оставшееся время и передаёт его в заголовке `grpc-timeout`. Если сервис заказов создаст новый контекст без срока, срок цепочки потеряется: оплата получит вызов без `grpc-timeout`, а такой срок сервер считает бесконечным.

Источник: https://grpc.io/docs/guides/deadlines/

### Клиент получил `DEADLINE_EXCEEDED` на `CreateOrder`. Можно ли считать, что заказ не создан, и что делать с повтором?

Нельзя: `DEADLINE_EXCEEDED` не доказывает, что заказ не создан, поэтому слепо повторять `CreateOrder` нельзя.

Источник: https://grpc.io/docs/guides/deadlines/

## Соединение, остановка и health

### Почему клиентский канал gRPC создают один раз на процесс и переиспользуют, а не открывают на каждый вызов?

Канал дорогой и долгоживущий: он хранит резолвер, соединение и политику балансировки, а все вызовы мультиплексируются через него по HTTP/2. Создание канала на каждый вызов оплачивает всё это каждый раз. Документация по производительности формулирует правило прямо: по возможности всегда переиспользуйте заглушки и каналы.

Источник: https://grpc.io/docs/guides/performance/

### Сервер заказов перезапускается, и клиенты в эти секунды получают `UNAVAILABLE`. Что меняет режим wait-for-ready и когда его включать не стоит?

Wait-for-ready заставляет вызов ждать, пока не определится исход попытки соединения, вместо немедленной ошибки при `TRANSIENT_FAILURE` (в сценарии вопроса это `UNAVAILABLE`). Ожидание ограничивает дедлайн вызова; постоянный сбой канала прерывает вызов и в этом режиме.

Источник: https://grpc.io/docs/guides/wait-for-ready/

### Зачем gRPC keepalive, если у TCP есть свой, и почему сервер может разорвать соединение клиента со слишком частыми пингами?

gRPC keepalive отправляет кадры PING протокола HTTP/2 и проверяет, что собеседник на другом конце соединения отвечает. Сервер разрывает соединение клиента, который шлёт PING чаще разрешённого, потому что частые пинги от множества клиентов сами становятся нагрузкой: по оценке в gRFC A8, миллион телефонов с пингом раз в 10 секунд дают 100 тысяч запросов в секунду без полезной работы.

Источник: https://grpc.io/docs/guides/keepalive/

## Интерцепторы и валидация

### В сервер grpc-go добавили интерцепторы восстановления после паники, логирования и аутентификации. Лог должен записывать каждый вызов с итоговым кодом, включая отказы аутентификации и вызовы с паникой, а паника в проверке токена или в обработчике должна стать ошибкой `INTERNAL`, а не уронить процесс. В каком порядке передать их в `grpc.ChainUnaryInterceptor` и что изменится, если логирование окажется после аутентификации?

Порядок такой: `grpc.ChainUnaryInterceptor(logUnary, recoverUnary, authUnary)`. Первый в списке стоит снаружи, последний ближе всех к обработчику (так сказано в документации `ChainUnaryInterceptor`). Лог снаружи видит итог любого вызова, восстановление внутри него превращает панику в ошибку до записи в лог, а аутентификация стоит внутри восстановления, поэтому паника в проверке токена тоже перехватывается.

Источник: https://grpc.io/docs/guides/interceptors/

### Почему для потокового метода не сработает унарный интерцептор и как потоковому интерцептору увидеть каждое сообщение потока?

Сервер вызывает унарный интерцептор только для унарных методов, а метод с потоком в любом направлении идёт через потоковый интерцептор. Сообщения потока интерцептор видит через обёртку: он встраивает `grpc.ServerStream` в свою структуру, переопределяет `RecvMsg` и `SendMsg` и передаёт обработчику её вместо исходного потока.

Источник: https://raw.githubusercontent.com/grpc/grpc-go/v1.85.0/server.go

### Как передать с вызовом идентификатор запроса и токен, не меняя сообщения в схеме, и где сервер их прочитает?

Передайте их метаданными вызова: это пары «ключ — значение», которые gRPC отправляет заголовками HTTP/2 раньше первого сообщения, поэтому схема сообщений не меняется. Токен кладут в ключ `authorization`, идентификатор запроса — в свой ключ, например `x-request-id`. Сервер читает их из метаданных контекста входящего вызова.

Источник: https://grpc.io/docs/guides/metadata/

## Стриминг

### Какой вид вызова gRPC выбрать для выгрузки всей истории заказов одним запросом клиента, для пакетного импорта заказов с одним итогом в конце и для чата поддержки по заказу и почему?

Выгрузка истории — серверный поток, пакетный импорт — клиентский поток, чат поддержки — двунаправленный. Вид определяет, кто пишет много сообщений: сервер, клиент или обе стороны независимо.

Источник: https://grpc.io/docs/what-is-grpc/core-concepts/

### Сервер шлёт поток событий быстрее, чем клиент их читает. Что ограничит отправителя и где будут копиться данные?

Отправителя ограничит управление потоком HTTP/2: пока получатель не прочитал данные, окно заполнено, и вызов записи в поток ждёт. Из того, как работает окно, следует, что данные копятся у отправителя, а у получателя остаётся не больше окна.

Источник: https://grpc.io/docs/guides/flow-control/

### Серверный поток отдал 500 сообщений из 1000 и упал с ошибкой. Что увидит клиент, и как ему понять, какие сообщения уже обработаны?

Клиент прочитает все 500 присланных сообщений, а следующий `Recv` вернёт ошибку со статусом сервера вместо `io.EOF`. Прочитанное остаётся прочитанным, вызов ничего не откатывает. Какие сообщения обработаны, gRPC не отслеживает: это знает только клиент по своему учёту, например по идентификатору последнего обработанного сообщения.

Источник: https://grpc.io/docs/what-is-grpc/core-concepts/

## gRPC-Gateway и граница с REST

### Как gRPC-Gateway превращает `GET /v1/orders/{id}` в вызов `GetOrder` и откуда берёт это отображение?

Отображение лежит в аннотации `google.api.http` на методе в `.proto`. gRPC-Gateway — плагин компилятора protoc: он читает аннотации и генерирует обратный прокси, который переводит запросы HTTP и JSON в вызовы gRPC.

Источник: https://github.com/grpc-ecosystem/grpc-gateway

### Внешний клиент получает заказ через REST-шлюз. Почему поле `int64 amount_minor` пришло строкой, а имя поля `customer_id` — как `customerId`, и что сломается у клиента при переименовании поля в схеме?

Шлюз кодирует тело по правилам канонического JSON для protobuf (ProtoJSON): `int64` выводится строкой, а ключ объекта — `lowerCamelCase` от имени поля. Переименование поля безопасно для бинарного protobuf, где поле опознаётся номером, но меняет ключ JSON и ломает REST-клиентов.

Источник: https://protobuf.dev/programming-guides/json/

### Сервис вернул `NOT_FOUND` и `UNAVAILABLE`. Какие коды HTTP увидит клиент шлюза и где это отображение настраивается?

`NOT_FOUND` станет `404 Not Found`, `UNAVAILABLE` станет `503 Service Unavailable`. Отображение делает функция `runtime.HTTPStatusFromCode`, а заменить его можно собственным обработчиком ошибок через `runtime.WithErrorHandler` при создании `ServeMux`.

Источник: https://raw.githubusercontent.com/grpc-ecosystem/grpc-gateway/v2.33.0/runtime/errors.go

## Балансировка

### Сервис заказов масштабировали с трёх до шести подов, но новые поды почти не получают вызовов. Почему так происходит за L4-балансировщиком?

L4-балансировщик раскладывает по подам TCP-соединения, а не вызовы, и клиент gRPC пускает все вызовы по одному долгому соединению HTTP/2. Под выбран один раз, при подключении, поэтому новые поды вызовов не получают, пока это соединение не закроется.

Источник: https://grpc.io/blog/grpc-load-balancing/

### Сервисы заказов и оплаты работают в одном кластере, оба написаны вашей командой, клиентам можно доверять, а лишний переход через прокси на пути каждого вызова нежелателен. Чем клиентская балансировка gRPC отличается от балансировки на прокси L7 и что выбрать для этих внутренних вызовов?

При клиентской балансировке для каждого вызова сервер выбирает сам клиент, при балансировке на прокси L7 его выбирает прокси, а клиент ничего не знает о бэкендах. В описанных условиях, когда клиентам можно доверять, а лишний переход нежелателен, берут клиентскую балансировку.

Источник: https://grpc.io/blog/grpc-load-balancing/

### Какая политика балансировки работает в канале gRPC по умолчанию, как включить `round_robin` и откуда клиент возьмёт адреса всех экземпляров?

По умолчанию работает `pick_first`: он подключается к первому доступному адресу, и все вызовы канала идут на него. `round_robin` включают в service config канала, а адреса всех экземпляров клиенту должен отдать резолвер, например DNS по имени headless-сервиса Kubernetes.

Источник: https://github.com/grpc/grpc/blob/v1.85.1/doc/load-balancing.md

## Наблюдаемость

### Какие метрики снимать с gRPC-сервера и клиента, чтобы увидеть рост ошибок и задержки, и почему код статуса должен быть измерением метрики?

С сервера снимают `grpc.server.call.started` и гистограмму `grpc.server.call.duration`, с клиента `grpc.client.call.duration` и пару `grpc.client.attempt.started` и `grpc.client.attempt.duration`. Код статуса `grpc.status` делают меткой, потому что исход вызова лежит не в коде HTTP, а в трейлере `grpc-status`.

Источник: https://grpc.io/docs/guides/opentelemetry-metrics/

### Чем длительность вызова отличается от длительности попытки и почему при включённых повторах важны обе?

Длительность вызова (`grpc.client.call.duration`) записывается один раз на вызов и считается от старта вызова приложением до выдачи ему статуса, поэтому охватывает все попытки и паузы между ними. Длительность попытки (`grpc.client.attempt.duration`) записывается на каждую отправку вызова на сервер и включает выбор подканала. При повторах нужны обе: метрика вызова не показывает попытки, которые закончились ошибкой, но повтор их спас.

Источник: https://grpc.io/docs/guides/opentelemetry-metrics/

### Как контекст трассы переходит от сервиса заказов к сервису оплаты через вызов gRPC и что нужно подключить на обеих сторонах?

Контекст трассы едет в метаданных вызова, то есть в заголовках HTTP/2: клиентская сторона записывает заголовок `traceparent` (W3C Trace Context) в исходящие метаданные, серверная достаёт его из входящих и делает свой спан дочерним. На обеих сторонах нужна трассировка с одним и тем же форматом передачи, а обработчик сервиса заказов должен вызывать оплату со своим `ctx`.

Источник: https://www.w3.org/TR/trace-context/

## TLS, mTLS и аутентификация

### Что доказывает обычный TLS при вызове gRPC, что добавляет mTLS и чего mTLS между внутренними сервисами не говорит серверу о вызывающем?

Обычный TLS доказывает клиенту, что сервер владеет сертификатом на нужное имя, и шифрует данные, но сервер не узнаёт, кто звонит. mTLS добавляет подлинность клиента: сервер запрашивает сертификат клиента и проверяет его по доверенным центрам. Он показывает серверу вызывающий сервис, но не говорит, разрешён ли этому сервису вызов метода, и не называет ни пользователя, от имени которого сервис звонит, ни его права.

Источник: https://grpc.io/docs/guides/auth/

### Как передать токен пользователя с каждым вызовом gRPC и где на сервере его проверять, чтобы не повторять проверку в каждом обработчике?

Токен передают в метаданных вызова, в заголовке `authorization` со схемой `Bearer`, а на сервере проверяют в интерцепторе: он срабатывает до обработчика, поэтому проверка не дублируется в каждом методе. Для потоковых методов нужен отдельный потоковый интерцептор.

Источник: https://grpc.io/docs/guides/auth/

### Чем учётные данные уровня соединения отличаются от учётных данных уровня вызова в gRPC и почему токен без TLS передавать нельзя?

Учётные данные соединения (в grpc-go `TransportCredentials`) задают защиту канала: TLS подтверждает сервер, при mTLS и клиента, и шифрует данные. Учётные данные вызова (`PerRPCCredentials`) добавляют секрет, например токен, в метаданные каждого вызова. Токен без TLS передавать нельзя, потому что токен предъявителя даёт доступ любому, у кого он оказался, а RFC 6750 называет отправку без TLS причиной многих атак на токен. grpc-go такую отправку блокирует.

Источник: https://grpc.io/docs/guides/auth/
