React Server Components: что это вообще такое и почему вокруг столько шума

•
Опубликовано
•
18 мин чтения

Текст написан с позиции апреля 2023 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.

Вокруг React Server Components очень легко почувствовать знакомую фронтенд-усталость. Стоит только появиться новой крупной идее в экосистеме React, как обсуждение почти мгновенно раскалывается на два лагеря. Одни говорят так, будто перед нами следующий большой шаг в развитии интерфейсов и почти неизбежное будущее всего React-мира. Другие реагируют с понятным раздражением: еще одна сложная концепция, еще одна попытка перемешать клиент и сервер, еще один слой абстракции, который обещает многое, но на практике наверняка заставит команды тратить месяцы на адаптацию и переучивание. И если смотреть на споры вокруг Server Components именно через призму таких привычных технологических качелей, легко либо переоценить идею, либо отмахнуться от нее слишком рано.

Самая вредная реакция на эту тему — услышать слова «сервер» и «компонент» рядом и решить, что речь о косметической доработке рендера, которую можно проигнорировать ещё пару лет. Но React Server Components интересны как раз не тем, что их можно быстро записать в очередной «революционный» лозунг. Они интересны потому, что пытаются ответить на очень старую и очень неудобную проблему React-приложений: слишком долго мы были вынуждены думать о компоненте как о сущности, которая почти по умолчанию живет на клиенте, даже если часть ее работы логичнее и дешевле происходила бы на сервере. Отсюда и огромное количество архитектурных компромиссов, которые за годы стали казаться нормой. Мы тянем данные на клиент. Мы сериализуем то, что могло бы остаться на сервере. Мы тащим в браузер логику, нужную лишь для подготовки представления. Мы отправляем пользователю JavaScript, который в действительности не нужен ему для интерактивности, а нужен только потому, что компонент как модель слишком долго был почти неотделим от клиентского исполнения.

Именно в этой точке Server Components начинают выглядеть не как очередная экзотическая фича, а как попытка пересобрать базовую интуицию о том, где вообще должен жить React-компонент. Не всякий компонент обязан быть клиентским только потому, что написан на React. Не всякая часть дерева интерфейса должна гидратироваться в браузере. Не всякая логика подготовки данных должна протаскиваться через API-слой в том виде, в каком это привычно клиентскому приложению. Если эту мысль принять всерьез, становится понятно, почему вокруг темы столько шума. Она трогает не один локальный паттерн, а очень глубокое предположение, на котором выросло несколько поколений React-разработки.

Проблема только в том, что такие идеи почти невозможно объяснить коротко без потери смысла. Как только кто-то пытается уложить React Server Components в одну фразу вроде «это компоненты, которые рендерятся на сервере», начинается путаница. Потому что React уже давно умеет рендериться на сервере в контексте SSR. И Server Components — это не просто очередное название для старой идеи server-side rendering. Здесь меняется не только место рендера, но и сама граница между тем, что входит в клиентский JavaScript, что остается на сервере, как компоненты компонуются между собой и что вообще считается частью клиентского приложения. Поэтому, чтобы не попасть в ловушку поверхностной реакции, о Server Components лучше говорить спокойно и поэтапно: что это такое, чем они не являются, почему они вообще появились и из-за чего реакция на них такая сильная.

Сначала самое важное: это не просто новый SSR

Самая первая путаница вокруг React Server Components возникает именно здесь. Раз слово «server» уже есть в названии, очень легко решить, что речь просто о новой форме серверного рендеринга. Но это было бы слишком грубым упрощением. SSR в классическом понимании отвечает на вопрос, как отдать пользователю HTML, собранный на сервере до того, как клиентское приложение полностью оживет в браузере. При этом сами компоненты по-прежнему, как правило, остаются частью клиентского дерева: они гидратируются, их код в той или иной форме попадает в браузер, а серверный рендер является скорее способом ускорить первый полезный ответ.

Server Components меняют не столько момент рендера, сколько сам статус части компонентов. Идея в том, что некоторые React-компоненты могут быть серверными по природе. Это значит, что они выполняются на сервере, могут напрямую обращаться к серверным ресурсам, не попадают в клиентский bundle как интерактивный код и не требуют гидрации в браузере. Они не просто «один раз отрендерились на сервере, а потом стали обычными клиентскими». Они вообще принадлежат другой стороне системы.

Именно поэтому React Server Components — это не ребрендинг SSR. Это попытка добавить в саму модель React-проекта новый класс компонентов, для которых сервер — не временная остановка перед гидрацией, а естественная среда существования. Когда это различие становится ясным, тема сразу начинает выглядеть серьезнее. Потому что теперь речь уже не о способе ускорить страницу, а о новом раскрое самого дерева приложения.

Обычный React-код так долго жил с лишним клиентским весом не по своей вине, а из-за инерции модели

Чтобы понять привлекательность Server Components, полезно честно посмотреть на то, как последние годы строились многие React-приложения. Даже когда часть логики очевидно имела серверную природу, компонентный стиль подталкивал к тому, чтобы почти все мышление оставалось клиентским. Компоненту нужны данные — значит где-то есть fetch. Компонент должен показать список — значит либо API возвращает все в форме, удобной для клиента, либо клиент сам склеивает данные. Компоненту нужно использовать информацию, доступную только на сервере, — значит появляется дополнительный уровень сериализации, прокси-эндпоинт или отдельный BFF-слой. Даже если UI в итоге не особенно интерактивен, сама инфраструктурная привычка заставляет тащить его в мир клиентского исполнения.

Такой подход долго был вполне естественным, потому что граница была простой: React-компоненты в основном принадлежат клиенту. Да, можно сделать SSR. Да, можно сделать SSG. Но сама сущность компонента по умолчанию все равно оставалась частью клиентского приложения. И отсюда вырос целый пласт компромиссов. Лишний JavaScript отправляется в браузер просто потому, что логика отображения и логика интерактивности живут в одном теле компонента. Данные проходят через клиентский слой даже там, где могли быть использованы ближе к источнику. Разработчики строят архитектуру не от природы конкретного элемента дерева, а от общего ограничения: если это React, значит в конечном счете оно должно вписаться в клиентскую модель.

Server Components звучат так заметно именно потому, что предлагают ослабить это ограничение. Они как будто задают вопрос, который слишком долго не задавали всерьез: а почему вообще этот конкретный компонент должен становиться клиентским кодом? Если ответ «не должен», то, возможно, и вся архитектура вокруг него была искусственно усложнена просто из-за исторической инерции.

Что значит «серверный компонент» в практическом смысле

Если отбросить полемику, то серверный компонент — это React-компонент, который исполняется на сервере и может напрямую использовать серверные возможности, не попадая как интерактивная единица в клиентский JavaScript. Это очень важная формулировка. Она означает сразу несколько вещей.

Во-первых, такой компонент может работать с данными ближе к источнику. Ему не нужно притворяться клиентом, который получает все через дополнительный сетевой вызов после загрузки страницы. Он может обращаться к базе, файловой системе, внутренним сервисам или другим серверным ресурсам там, где это допустимо в конкретной среде. Во-вторых, его код не обязательно становится частью клиентского bundle. Если компонент существует только ради подготовки представления, а не ради интерактивности, браузеру не нужно нести стоимость его присутствия как исполняемого кода. В-третьих, серверный компонент может быть частью того же React-дерева, что и клиентские компоненты, но при этом не обязан жить по их правилам.

Именно это делает идею по-настоящему мощной. Не потому, что «теперь можно делать fetch на сервере» — это и раньше было возможно множеством способов. А потому, что серверная природа может быть выражена на уровне самой компонентной модели, а не через внешнюю инфраструктурную обвязку. Это сильно отличается от привычного ощущения, где React-компонент почти всегда стартует как клиентская единица, даже если по смыслу он ею не является.

Почему это вызывает столько споров у React-разработчиков

Накал обсуждения вокруг Server Components связан не только с их технической новизной. Он связан с тем, что они затрагивают слишком много привычек сразу. Во-первых, меняется сам ментальный контракт о том, что такое React-компонент. Это уже не обязательно «кусок UI, который в итоге живет в браузере». Во-вторых, меняется граница между клиентом и сервером. Она перестает проходить только на уровне API и SSR, а начинает проходить прямо внутри компонентного дерева. В-третьих, меняется подход к производительности. Речь уже не только о том, чтобы отдать HTML быстрее, а о том, чтобы вообще не отправлять клиенту часть кода, которая не нужна для интерактивности.

Все это одновременно очень интересно и очень тревожно для экосистемы. Интересно — потому что открывает новые способы проектировать приложения. Тревожно — потому что ломает довольно большой объем накопленной интуиции. Многие React-команды за последние годы выстроили архитектуру, инструменты и даже культуру мышления вокруг довольно устойчивой модели: есть клиентское приложение, у него есть серверный помощник, SSR или SSG могут помочь с первым ответом, но в целом React — это клиентский мир. Теперь им предлагают гораздо менее линейную реальность.

Именно из-за этого обсуждение и выглядит таким заряженным. Здесь спорят не о новой библиотеке для таблиц и не о мелком API-хуке. Здесь спорят о том, нужно ли пересматривать очень глубокое основание React-мышления. А такие темы никогда не проходят тихо.

Идея созрела не на пустом месте, а как продолжение давних движений в экосистеме

React Server Components не свалились с неба в изоляции. Они выглядят логичным продолжением нескольких параллельных движений в React-экосистеме. Во-первых, сам React уже заметно сместился в сторону более сложной и гибкой модели рендера: concurrent features, Suspense, streaming SSR — все это подталкивало к мысли, что интерфейс не обязан быть монолитным синхронным объектом. Во-вторых, фронтенд в целом устал от чрезмерной клиентской тяжести. Накапливалось ощущение, что слишком много того, что можно было бы сделать ближе к серверу, по историческим причинам выполняется на клиенте. В-третьих, начали созревать метафреймворки и среды, готовые экспериментировать с новой архитектурой не как с отдельной абстракцией, а как с частью полного стека.

То есть React Server Components появились не потому, что команде React захотелось удивить всех новой громкой идеей, а потому, что в экосистеме накопилась реальная потребность ослабить старую привязку компонента к клиентскому миру. Когда приложения становятся сложнее, JavaScript-тяжелее, а граница между сервером и клиентом важнее для производительности и DX, тема перестает быть академической. Она становится очень практической.

Можно сказать, что Server Components — это ответ не только на технический долг, но и на культурную перегруженность client-first подхода. Реакция на них настолько сильная именно потому, что многие чувствовали проблему, просто не всегда называли ее одинаково.

«Старый React был про клиент, новый — про сервер» — карикатура, в которую легко поверить

Одна из самых опасных ошибок в разговоре о Server Components — сразу начать мыслить в логике «старый React был про клиент, новый React теперь будет про сервер». Это было бы такой же карикатурой, как когда-то идея, будто весь веб обязан быть либо чистым SPA, либо только SSR. На практике React Server Components интересны именно как новый слой дифференциации, а не как абсолютная замена клиентских компонентов.

Интерактивность никуда не исчезла. Все, что зависит от пользовательских событий, локального состояния интерфейса, браузерных API, анимаций, клиентских подписок и живого поведения в браузере, по-прежнему естественно относится к клиентскому миру. Прелесть идеи в другом: теперь не нужно тащить в этот мир и те части дерева, которым там делать нечего. Появляется возможность яснее отделять компоненты, существующие ради сервера и подготовки представления, от компонентов, существующих ради интерактивности.

Именно поэтому React Server Components нельзя честно обсуждать как войну клиента и сервера. Это скорее попытка сделать их отношения более выразимыми. Не все должны быть клиентскими. Но и не все должны становиться серверными только потому, что это новое направление кажется более «правильным». Зрелость здесь как раз в умении проводить границу осмысленно.

Выигрыш в производительности здесь не магия рендера, а экономия на ненужном коде

Производительность — одна из главных причин, почему идея вызывает интерес, но и здесь важно избегать магического мышления. Server Components не делают приложение быстрым по определению. Они просто позволяют убрать один из устойчивых источников лишнего веса: клиентский JavaScript там, где он на самом деле не нужен.

Во многих React-приложениях браузер получает гораздо больше кода, чем реально требует интерактивность страницы. Часть компонентов существует только для того, чтобы собрать данные, подготовить представление, применить серверные правила, склеить куски UI и передать их вниз. Но если вся эта логика живет в клиентском мире, пользователь в конечном счете платит за нее bundle size, гидрацией, временем инициализации и общей сложностью приложения. Server Components обещают ослабить именно эту проблему.

Их сила не в волшебной оптимизации рендера, а в том, что часть React-дерева может вообще не стать клиентским кодом. Это очень интересное изменение модели стоимости. Вы начинаете думать не только о том, как быстро выполнить компонент, но и о том, нужно ли вообще отправлять его в браузер как исполняемую единицу. Для многих типов интерфейсов это действительно может дать заметный выигрыш.

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

Это не только про скорость, но и про архитектуру данных

О Server Components часто говорят через bundle size и hydration cost, но не менее интересна архитектурная сторона вопроса. Когда компонент может естественно жить на сервере, меняется сам подход к работе с данными. Не обязательно строить все через клиентские fetch-циклы. Не обязательно сериализовать на клиент то, что нужно только для подготовки UI. Не обязательно создавать дополнительные прослойки только для того, чтобы компонент в браузере мог получить уже известную на сервере информацию.

Это открывает очень важную возможность: компоненты начинают мыслиться ближе к источнику своих данных. В каком-то смысле React получает шанс снова сблизить представление и данные, но уже не на клиенте, а на сервере. И для целого класса задач это выглядит очень естественно. Списки, карточки, фрагменты контента, составные блоки страниц, элементы, которым не нужна клиентская жизнь после рендера, — все это потенциально выигрывает от такого сближения.

Поэтому реакция на тему связана еще и с тем, что она задевает привычную архитектуру data fetching. Там, где раньше клиентское приложение казалось центром всей логики потребления данных, появляется более гибридная модель. Для кого-то это долгожданное облегчение. Для кого-то — тревожный сигнал о росте системной сложности. И обе реакции понятны.

За снятые ограничения приходится платить ростом ментальной сложности

Было бы нечестно рассказывать о React Server Components как о чистом архитектурном благословении. Да, идея мощная. Да, она потенциально снимает старые ограничения. Но цена этой свободы — рост ментальной сложности. Как только в одном React-дереве начинают жить компоненты разной природы, меняется очень многое. Нужно понимать, где проходит граница. Нужно помнить, что может использовать браузерные API, а что нет. Нужно проектировать передачу данных и композицию между слоями. Нужно держать в голове, какой код вообще попадет в клиентский bundle, а какой нет. Нужно учитывать ограничения среды и инструментов.

То есть споры вокруг Server Components вызваны не только обещаниями, но и реальным ростом требований к мышлению команды. Это не та идея, которую можно честно свести к «стало просто лучше». Скорее, это идея, которая обещает большие выгоды там, где команда готова к более сложной модели приложения. И неготовые команды, конечно, имеют право смотреть на это с опасением. Вопрос не в том, преувеличена ли сложность. Вопрос в том, окупается ли она под конкретный класс продуктов.

Для маленьких приложений или проектов, где основная боль не в клиентском весе и не в границе между сервером и клиентом, Server Components действительно могут казаться слишком тяжелой концепцией. И это нормально. Не всякая важная идея обязана немедленно становиться правильным выбором для каждого проекта.

React Server Components почти невозможно обсуждать в отрыве от метафреймворков

Еще одна причина споров в том, что Server Components почти невозможно обсуждать в полном отрыве от окружающей платформы. В абстрактном React-приложении идея сама по себе интересна, но как только дело доходит до реальной разработки, сразу возникает вопрос: кто организует этот мир? Как строится сборка? Как делится код? Как происходит серверное исполнение? Как оформляются границы? Где находятся маршруты, data fetching, кэширование, стриминг, сериализация и все остальное?

Именно поэтому тема очень быстро начала ассоциироваться не просто с React, а с экосистемой метафреймворков. Потому что они оказываются естественным местом, где такая модель может действительно жить. На уровне «голого React» Server Components выглядят как мощная, но довольно абстрактная возможность. На уровне полного стека они превращаются в конкретную архитектурную реальность, с которой уже надо работать каждый день.

Это, кстати, тоже подогревает дискуссию. Разговор сразу перестает быть только о библиотеке и превращается в разговор о траектории всего React-стека. А такие обсуждения почти всегда намного горячее, потому что затрагивают выбор фреймворка, инфраструктуры, обучения команды и долгосрочной архитектуры продукта.

Один лагерь видит возвращение к «толстому серверу», другой — новый виток усложнения веба

Интересно, что в Server Components разные разработчики видят разные культурные смыслы. Для кого-то это выглядит почти как возвращение старой мудрости: не все должно жить в браузере, сервер по-прежнему важен, веб не обязан быть гигантским SPA с бесконечной гидрацией. Для таких людей идея ощущается как долгожданное отрезвление. Как будто React наконец перестает делать вид, что клиентский код должен быть центром вселенной.

Для других это, наоборот, выглядит как новый виток усложнения. Еще один способ размыть границы. Еще один уровень, где разработчику придется помнить о среде выполнения. Еще одна архитектура, которая хороша в руках экспертов, но может породить массу плохо понятых проектов на уровне индустрии. И этот страх тоже не выдуман. История фронтенда полна примеров, когда сильная идея слишком быстро становилась объектом догматического внедрения без достаточной дисциплины.

Поэтому дискуссия здесь такая громкая еще и потому, что Server Components каждый лагерь читает через свои старые травмы. Одни видят спасение от клиентского перегруза. Другие — новую форму сложности, за которую снова придется платить командам. В реальности, скорее всего, правы и те и другие, просто в разных контекстах.

Как смотреть на это без истерики: инструмент с высокой отдачей и высокой ценой ошибки

Самый здоровый способ смотреть на React Server Components — не как на обязательное будущее любого React-приложения и не как на странную игрушку теоретиков. Полезнее видеть в них новый архитектурный инструмент для вполне конкретной проблемы: клиентская модель React слишком долго заставляла нас оплачивать клиентским кодом то, что в значительной степени принадлежит серверу. Server Components предлагают ослабить этот перекос.

Это значит, что к ним стоит относиться как к инструменту с высокой потенциальной отдачей, но и с высокой ценой неправильного применения. Они обещают особенно много там, где продукт выигрывает от более тонкого разделения серверного и клиентского, где bundle size и hydration действительно болят, где data fetching слишком искусственно протаскивается через клиент, где неинтерактивные части дерева тащат за собой непропорционально много JavaScript. Там же, где приложение в основном является богатым клиентским интерфейсом, а серверная природа компонентов выражена слабо, новая модель может оказаться не столь полезной.

Иными словами, Server Components — это не новый ответ на все. Это новый способ задать гораздо более точный вопрос: какие части нашего React-дерева действительно должны жить в браузере, а какие оказались там только по исторической привычке?

Итог

React Server Components — это не просто очередной способ отрендерить React на сервере и не модная вариация старого SSR. Это попытка добавить в саму компонентную модель новый класс сущностей: компоненты, которые по природе принадлежат серверу, могут работать ближе к данным, не должны гидратироваться в браузере и не обязаны входить в клиентский bundle. Именно поэтому вокруг темы столько обсуждения. Она задевает не локальный API, а очень глубокое допущение о том, что React-компонент почти по умолчанию является клиентской единицей.

Шум усиливается еще и потому, что идея одновременно обещает много и требует многого. Она может уменьшить лишний клиентский JavaScript, изменить архитектуру data fetching, сделать границу между сервером и клиентом более выразимой и изменить саму анатомию React-приложений. Но вместе с этим она повышает сложность модели, требует от команды новой дисциплины и тесно связана с развитием полного стека, а не только самой библиотеки React.

Если сформулировать все совсем прямо, то главный ответ на вопрос «что это вообще такое?» будет таким: React Server Components — это не новый SSR и не способ ускорить рендер, а отказ от молчаливого допущения, что любой React-компонент по умолчанию клиентский; они возвращают команде право решать, какая часть дерева вообще должна доезжать до браузера. А на вопрос «почему столько шума?» ответ еще проще: потому что это одна из тех идей, которые меняют не деталь, а саму привычную карту React-разработки. А такие вещи всегда вызывают и надежду, и тревогу одновременно.

Автор

Senior Principal JavaScript Developer, Tech Lead. Пишет о React, TypeScript, React Native, архитектуре фронтенда и бэкенда и о том, как AI меняет работу разработчика.

Обновлено

Читайте также