Chegarani mustahkamlash: React'ning eksperimental Taint API'lariga ishlab chiquvchining chuqur sho'ng'ishi

Veb-ishlab chiqish evolyutsiyasi chegaralarning o'zgarishi haqidagi hikoyadir. Ko'p yillar davomida server va mijoz o'rtasidagi chiziq aniq va ravshan edi. Bugungi kunda, React Server Komponentlari (RSC) kabi arxitekturalar paydo bo'lishi bilan bu chiziq ko'proq o'tkazuvchan membranaga aylanmoqda. Ushbu kuchli yangi paradigma server tomonidagi mantiq va mijoz tomonidagi interaktivlikni uzluksiz integratsiya qilish imkonini beradi va ajoyib ishlash va ishlab chiquvchi tajribasi afzalliklarini va'da qiladi. Biroq, bu yangi kuch bilan xavfsizlik bo'yicha yangi turdagi mas'uliyat paydo bo'ladi: sezgir server tomonidagi ma'lumotlarning beixtiyor mijoz tomonidagi dunyoga o'tishini oldini olish.

Tasavvur qiling-a, sizning ilovangiz ma'lumotlar bazasidan foydalanuvchi obyektini oladi. Ushbu obyektda foydalanuvchi nomi kabi ommaviy ma'lumotlar, shuningdek, parol xeshi, sessiya tokeni yoki shaxsiy identifikatsiya ma'lumotlari (PII) kabi juda sezgir ma'lumotlar bo'lishi mumkin. Ishlab chiqish jarayonida ishlab chiquvchining ushbu butun obyektni Client Componentga prop sifatida o'tkazishi xavfli darajada oson. Natija? Sezgir ma'lumotlar seriyalashtiriladi, tarmoq orqali yuboriladi va to'g'ridan-to'g'ri mijoz tomonidagi JavaScript yukiga o'rnatiladi va brauzerning ishlab chiquvchi vositalariga ega bo'lgan har bir kishi uchun ko'rinadi. Bu gipotetik tahdid emas; bu zamonaviy freymvorklar hal qilishi kerak bo'lgan nozik, ammo muhim zaiflikdir.

React'ning yangi, eksperimental Taint API'lariga kiring: experimental_taintObjectReference va experimental_taintUniqueValue. Ushbu funktsiyalar server-mijoz chegarasida xavfsizlik qo'riqchisi vazifasini bajaradi va ma'lumotlarning tasodifiy sizib chiqishining aniq turlarini oldini olish uchun mustahkam, o'rnatilgan mexanizmni ta'minlaydi. Ushbu maqola butun dunyo bo'ylab ishlab chiquvchilar, xavfsizlik muhandislari va arxitektorlar uchun keng qamrovli qo'llanmadir. Biz muammoni chuqur o'rganamiz, ushbu yangi API'lar qanday ishlashini tahlil qilamiz, amaliy amalga oshirish strategiyalarini taqdim etamiz va ularning xavfsizroq, global miqyosda mos ilovalarni yaratishdagi rolini muhokama qilamiz.

"Nega": Server komponentlaridagi xavfsizlik bo'shligini tushunish

Ushbu ma'lumotlar oqimi zaiflik manbaidir. Ma'lumotlarni server muhitidan mijoz muhitiga o'tkazish jarayoni seriyalashtirish deb ataladi. React buni avtomatik ravishda bajaradi, obyektingizni va proplaringizni tarmoq orqali uzatilishi va mijozda qayta hidratlanishi mumkin bo'lgan formatga aylantiradi. Jarayon samarali, ammo ajratib ko'rsatmaydi; u qaysi ma'lumotlar sezgir va qaysi biri xavfsizligini bilmaydi. U shunchaki berilgan narsani seriyalashtiradi.

Klassik ssenariy: Oqadigan foydalanuvchi obyekti

Keling, Next.js kabi freymvorkda App Router-dan foydalangan holda umumiy misol bilan tasvirlaylik. Server tomonidagi ma'lumotlarni olish funktsiyasini ko'rib chiqing:

            // app/data/users.js
import { db } from './database';

export async function getUser(userId) {
  const user = await db.user.findUnique({ where: { id: userId } });
  // The 'user' object might look like this:
  // {
  //   id: 'user_123',
  //   name: 'Alice',
  //   email: 'alice@example.com',       // Safe to display
  //   passwordHash: '...',              // EXTREMELY SENSITIVE
  //   apiKey: 'secret_key_...',         // EXTREMELY SENSITIVE
  //   twoFactorSecret: '...',           // EXTREMELY SENSITIVE
  //   internalNotes: 'VIP customer'   // Sensitive business data
  // }
  return user;
}
            

              
                Copy
              
            
          

Endi, ishlab chiquvchi foydalanuvchining profil sahifasini ko'rsatish uchun Server Komponentini yaratadi:

            // app/profile/[id]/page.js (Server Component)
import { getUser } from '@/app/data/users';
import UserProfileCard from '@/app/components/UserProfileCard'; // This is a Client Component

export default async function ProfilePage({ params }) {
  const user = await getUser(params.id);

  // The critical mistake is here:
  return <UserProfileCard user={user} />; // Qator qo'shildi
}
            

              
                Copy
              
            
          

Va nihoyat, ushbu ma'lumotlarni iste'mol qiladigan Client Component:

            // app/components/UserProfileCard.js
'use client';

export default function UserProfileCard({ user }) {
  // This component only needs user.name and user.email
  return (
    <div>
      <h1>{user.name}</h1>
      <p>Email: {user.email}</p>
    </div>
  );
}
            

              
                Copy
              
            
          

Yuzaki qaraganda, bu kod begunoh ko'rinadi va mukammal ishlaydi. Profil sahifasida foydalanuvchining ismi va elektron pochtasi ko'rsatiladi. Biroq, ichki tomondan xavfsizlik falokat yuz berdi. Butun `user` obyekti UserProfileCard ga prop sifatida o'tkazilganligi sababli, React'ning seriyalashtirish jarayoni har bir maydonni o'z ichiga oldi: `passwordHash`, `apiKey`, `twoFactorSecret` va `internalNotes`. Ushbu sezgir ma'lumotlar endi mijozning brauzer xotirasida joylashgan va osonlik bilan tekshirilishi mumkin, bu esa katta xavfsizlik teshigini yaratadi.

Bu aynan Taint API'lari hal qilish uchun mo'ljallangan muammodir. Ular Reactga "Ushbu aniq ma'lumotlar sezgir. Agar siz uni mijozga yuborishga urinishni ko'rsangiz, to'xtashingiz va xato qilishingiz kerak", deb aytishning bir usulini ta'minlaydi.

Taint API'lari bilan tanishish: Mudofaaning yangi qatlami

"Tainting" kontseptsiyasi klassik xavfsizlik tamoyilidir. U ishonchsiz yoki bu holda imtiyozli manbadan kelgan ma'lumotlarni belgilashni o'z ichiga oladi. Ushbu buzilgan ma'lumotlardan sezgir kontekstda (uni mijozga yuborish kabi) foydalanishga har qanday urinish bloklanadi. React ushbu g'oyani ikkita oddiy, ammo kuchli funktsiya bilan amalga oshiradi.

• <b>experimental_taintObjectReference(message, object)</b>: Ushbu funktsiya butun obyektdagi havola zaharli hisoblanadi.
• <b>experimental_taintUniqueValue(message, object, value)</b>: Ushbu funktsiya qaysi obyektda bo'lishidan qat'i nazar, o'ziga xos, noyob qiymatni (masalan, maxfiy kalit) zaharli hisoblanadi.

Buni raqamli bo'yoq to'plami deb o'ylang. Siz uni serverdagi sezgir ma'lumotlaringizga biriktirasiz. Agar ushbu ma'lumotlar xavfsiz server muhitini tark etishga va mijozga chegarani kesib o'tishga harakat qilsa, bo'yoq to'plami portlaydi. U jimjitlik bilan ishlamay qolmaydi; u server tomonidagi xatoni tashlaydi, so'rovni to'xtatadi va ma'lumotlarning sizib chiqishini oldini oladi. Siz taqdim etgan xabar ham kiritilgan bo'lib, disk raskadrovkasini osonlashtiradi.

Chuqur sho'ng'ish: `experimental_taintObjectReference`

Bu butunlay mijozga yuborilmasligi kerak bo'lgan murakkab obyektlarni bo'yash uchun ishchi kuchidir.

Maqsad va sintaksis

Uning asosiy maqsadi obyekt nusxasini faqat server uchun belgilashdir. Ushbu aniq obyektga havola Client Componentga o'tkazishga har qanday urinish seriyalashtirish paytida muvaffaqiyatsizlikka uchraydi.

Sintaksis: experimental_taintObjectReference(message, object)

• message: Agar sizib chiqishning oldi olinsa, xato xabariga kiritiladigan satr. Bu ishlab chiquvchilarning disk raskadrovkasi uchun juda muhimdir.
• object: Siz bo'yashingiz kerak bo'lgan obyektga havola.

Amalda qanday ishlaydi

Keling, ushbu himoya vositasini qo'llash orqali oldingi misolimizni qayta ishlaylik. Ma'lumotlarni bo'yash uchun eng yaxshi joy - bu manbaning o'zida - u yaratilgan yoki olingan joyda.

            // app/data/users.js (Endi bo'yash bilan)
import { experimental_taintObjectReference } from 'react';
import { db } from './database';

export async function getUser(userId) {
  const user = await db.user.findUnique({ where: { id: userId } });

  if (user) {
    // Taint the object as soon as we get it!
    experimental_taintObjectReference(
      'Security Violation: The full user object should not be passed to the client. ' +
      'Instead, create a sanitized DTO (Data Transfer Object) with only the necessary fields.',
      user
    );
  }

  return user;
}
            

              
                Copy
              
            
          

Ushbu bitta qo'shimcha bilan bizning ilovamiz endi xavfsiz. Bizning asl ProfilePage Server Komponentimiz ishga tushishga harakat qilganda nima bo'ladi?

            // app/profile/[id]/page.js (Server Component - BU YERDA HECH QANDAY O'ZGARISH KERAK EMAS)
export default async function ProfilePage({ params }) {
  const user = await getUser(params.id);

  // This line will now cause a server-side error!
  return <UserProfileCard user={user} />; // Qator qo'shildi
}
            

              
                Copy
              
            
          

React UserProfileCard uchun proplarni seriyalashtirishga harakat qilganda, u `user` obyekti buzilganligini aniqlaydi. Ma'lumotlarni mijozga yuborish o'rniga, u serverda xato tashlaydi va so'rov muvaffaqiyatsizlikka uchraydi. Ishlab chiquvchi biz taqdim etgan matnni o'z ichiga olgan aniq xato xabarini ko'radi: "Xavfsizlik qoidabuzarligi: To'liq foydalanuvchi obyekti mijozga o'tkazilmasligi kerak..."

Bu muvaffaqiyatsiz xavfsizlikdir. U jimjitlikdagi ma'lumotlarning sizib chiqishini baland ovozli, o'tkazib yuborib bo'lmaydigan server xatosiga aylantiradi va ishlab chiquvchilarni ma'lumotlarni to'g'ri qayta ishlashga majbur qiladi.

To'g'ri naqsh: Sanitarizatsiya

            // app/profile/[id]/page.js (Server Component - TO'G'RILANDI)
import { getUser } from '@/app/data/users';
import UserProfileCard from '@/app/components/UserProfileCard';

export default async function ProfilePage({ params }) {
  const user = await getUser(params.id);

  // If user not found, handle it (e.g., notFound() in Next.js)
  if (!user) { ... }

  // Create a new, clean object for the client
  const userForClient = {
    name: user.name,
    email: user.email
  };

  // This is safe because userForClient is a brand new object
  // and its reference is not tainted.
  return <UserProfileCard user={userForClient} />; // Qator qo'shildi
}
            

              
                Copy
              
            
          

Ushbu naqsh Data Transfer Obyektlaridan (DTO) yoki View Modellardan foydalanish sifatida tanilgan xavfsizlik bo'yicha eng yaxshi amaliyotdir. Taint API ushbu amaliyot uchun kuchli majburiy mexanizm vazifasini bajaradi.

Chuqur sho'ng'ish: `experimental_taintUniqueValue`

`taintObjectReference` konteyner haqida bo'lsa, `taintUniqueValue` tarkib haqidadir. U aniq primitiv qiymatni (masalan, satr yoki raqam) buzadi, shunda u qanday qadoqlanishidan qat'i nazar, mijozga hech qachon yuborilmaydi.

Maqsad va sintaksis

Bu qiymatlar uchun juda sezgir, ularni radioaktiv deb hisoblash kerak - API kalitlari, tokenlar, sirlar. Agar ushbu qiymat mijozga yuborilayotgan ma'lumotlarda ko'rinsa, jarayon to'xtatilishi kerak.

Sintaksis: experimental_taintUniqueValue(message, object, value)

• message: Tavsiflovchi xato xabari.
• object: Qiymatni saqlaydigan obyekt. Bu React tomonidan buzilishni qiymat bilan bog'lash uchun ishlatiladi.
• value: Bo'yash uchun haqiqiy sezgir qiymat.

Amalda qanday ishlaydi

Ushbu funktsiya juda kuchli, chunki buzilish qiymatning o'zidan kelib chiqadi. Serverda muhit o'zgaruvchilarini yuklashni ko'rib chiqing.

            // app/config.js (Faqat server moduli)
import { experimental_taintUniqueValue } from 'react';

export const serverConfig = {
  DATABASE_URL: process.env.DATABASE_URL,
  API_SECRET_KEY: process.env.API_SECRET_KEY,
  PUBLIC_API_ENDPOINT: 'https://api.example.com/public'
};

// Taint the secret key immediately after loading it
if (serverConfig.API_SECRET_KEY) {
  experimental_taintUniqueValue(
    'CRITICAL: API_SECRET_KEY must never be exposed to the client.',
    serverConfig, // The object holding the value
    serverConfig.API_SECRET_KEY // The value itself
  );
}
            

              
                Copy
              
            
          

Endi, tasavvur qiling-a, ishlab chiquvchi kod bazasining boshqa joyida xato qiladi. Ular ommaviy API nuqtasini mijozga o'tkazishlari kerak, lekin tasodifan maxfiy kalitni ham nusxalashadi.

            // app/some-page/page.js (Server Component)
import { serverConfig } from '@/app/config';
import SomeClientComponent from '@/app/components/SomeClientComponent';

export default function SomePage() {
  // Developer creates an object for the client
  const clientProps = {
    endpoint: serverConfig.PUBLIC_API_ENDPOINT,
    // The mistake:
    apiKey: serverConfig.API_SECRET_KEY
  };

  // This will throw an error!
  return <SomeClientComponent config={clientProps} />; // Qator qo'shildi
}
            

              
                Copy
              
            
          

`clientProps` butunlay yangi obyekt bo'lishiga qaramay, React-ning seriyalashtirish jarayoni uning qiymatlarini skanerlaydi. U `serverConfig.API_SECRET_KEY` qiymatiga duch kelganda, uni buzilgan qiymat sifatida taniydi va biz belgilagan server tomonidagi xatoni tashlaydi: "CRITICAL: API_SECRET_KEY hech qachon mijozga oshkor qilinmasligi kerak." Bu ma'lumotlarni nusxalash va qayta qadoqlash orqali tasodifiy sizib chiqishdan himoya qiladi.

Amaliy amalga oshirish strategiyasi: Global yondashuv

Ushbu API'lardan samarali foydalanish uchun ularni vaqti-vaqti bilan emas, balki tizimli ravishda qo'llash kerak. Ularni integratsiya qilish uchun eng yaxshi joy - bu sezgir ma'lumotlar ilovangizga kiradigan chegaralarda.

1. Ma'lumotlarga kirish qatlami

Bu eng muhim joy. Siz ma'lumotlar bazasi mijozi (Prisma, Drizzle va boshqalar kabi) dan foydalanasizmi yoki ichki API'dan olasizmi, natijalarni buzadigan funktsiyaga o'rang.

            // app/lib/security.js
import { experimental_taintObjectReference } from 'react';

const SENSITIVE_OBJECT_MESSAGE = 
  'Security Violation: This object contains sensitive server-only data and cannot be passed to a client component. ' +
  'Please create a sanitized DTO for client use.';

export function taintSensitiveObject(obj) {
  if (process.env.NODE_ENV === 'development' && obj) {
    experimental_taintObjectReference(SENSITIVE_OBJECT_MESSAGE, obj);
  }
  return obj;
}

// Now use it in your data fetchers
import { db } from './database';
import { taintSensitiveObject } from './security';

export async function getFullUser(userId) {
  const user = await db.user.findUnique({ where: { id: userId } });
  return taintSensitiveObject(user);
}
            

              
                Copy
              
            
          

Eslatma: `process.env.NODE_ENV === 'development'` uchun tekshirish keng tarqalgan naqshdir. U ushbu himoya vositasi xatolarni erta ushlash uchun ishlab chiqish vaqtida faol ekanligini ta'minlaydi, lekin ishlab chiqarishda har qanday potentsial (garchi ehtimoli yo'q bo'lsa ham) ortiqcha xarajatlardan qochadi. React jamoasi ushbu funktsiyalar juda kam xarajatli bo'lishi uchun mo'ljallanganligini ko'rsatdi, shuning uchun siz ularni qattiqlashtirilgan xavfsizlik chorasi sifatida ishlab chiqarishda ishga tushirishni tanlashingiz mumkin.

2. Muhit o'zgaruvchisi va konfiguratsiyani yuklash

Ilovangiz ishga tushishi bilanoq barcha maxfiy qiymatlarni bo'yang. Konfiguratsiyani boshqarish uchun maxsus modul yarating.

            // app/config/server-env.js
import { experimental_taintUniqueValue } from 'react';

const env = {
  STRIPE_SECRET_KEY: process.env.STRIPE_SECRET_KEY,
  SENDGRID_API_KEY: process.env.SENDGRID_API_KEY,
  // ... other secrets
};

function taintEnvSecrets() {
  for (const key in env) {
    const value = env[key];
    if (value) {
      experimental_taintUniqueValue(
        `Security Alert: Environment variable ${key} cannot be sent to the client.`, 
        env, 
        value
      );
    }
  }
}

taintEnvSecrets();

export default env;
            

              
                Copy
              
            
          

3. Autentifikatsiya va sessiya obyektlari

Ko'pincha kirish tokenlari, yangilash tokenlari yoki boshqa sezgir metadata ni o'z ichiga olgan foydalanuvchi sessiyasi obyektlari bo'yash uchun asosiy nomzodlardir.

            // app/lib/auth.js
import { getSession } from 'next-auth/react'; // Misol kutubxona
import { taintSensitiveObject } from './security';

export async function getCurrentUserSession() {
  const session = await getSession(); // This might contain sensitive tokens
  return taintSensitiveObject(session);
}
            

              
                Copy
              
            
          

"Eksperimental" ogohlantirish: Ong bilan qabul qilish

`experimental_` prefiksi muhim. Bu ushbu API hali barqaror emasligini va React-ning kelajakdagi versiyalarida o'zgarishi mumkinligini bildiradi. Funktsiya nomlari o'zgarishi, ularning argumentlari o'zgartirilishi yoki ularning xatti-harakatlari yaxshilanishi mumkin.

Bu ishlab chiqarish muhitidagi ishlab chiquvchilar uchun nimani anglatadi?

• Ehtiyotkorlik bilan davom eting: Xavfsizlik foydasi juda katta bo'lsa-da, React-ni yangilaganingizda buzilish mantiqingizni qayta ishlashingiz kerak bo'lishi mumkinligini biling.
• Mantiqingizni ajratib oling: Yuqoridagi misollarda ko'rsatilganidek, eksperimental qo'ng'iroqlarni o'zingizning yordamchi funktsiyalaringizga o'rang (masalan, `taintSensitiveObject`). Shunday qilib, agar React API o'zgarsa, siz uni butun kod bazasida emas, balki faqat bitta markaziy joyda yangilashingiz kerak bo'ladi.
• Xabardor bo'lib turing: Yaqinlashib kelayotgan o'zgarishlardan oldinda bo'lish uchun React jamoasining yangilanishlari va RFC'larini (Izohlar uchun so'rovlar) kuzatib boring.

Eksperimental bo'lishiga qaramay, ushbu API'lar React jamoasining server birinchi davrida "xavfsiz standart" arxitekturasiga sodiqligi haqidagi kuchli bayonotdir.

Buzilishdan tashqari: RSC xavfsizligiga yaxlit yondashuv

1. Ma'lumotlarni uzatish obyektlari (DTO) standart amaliyot sifatida: Asosiy mudofaa har doim xavfsiz kod yozish bo'lishi kerak. Hech qachon xom ma'lumotlar bazasi modellarini yoki to'liq API javoblarini mijozga o'tkazmaslikni butun jamoa siyosati qiling. Doimiy ravishda faqat UIga kerak bo'lgan ma'lumotlarni o'z ichiga olgan aniq, sanitarizatsiya qilingan DTO'larni yarating. Keyin buzilish inson xatosini ushlaydigan mexanizmga aylanadi.
2. Eng kam imtiyoz tamoyili: Kerak bo'lmagan ma'lumotlarni hatto olmang ham. Agar sizning komponentingizga faqat foydalanuvchining ismi kerak bo'lsa, so'rovingizni `SELECT *` o'rniga `SELECT name FROM users...` ga o'zgartiring. Bu sezgir ma'lumotlarning hatto server xotirasiga yuklanishiga yo'l qo'ymaydi.
3. Qat'iy kodni ko'rib chiqish: Server komponentidan Client Componentga o'tkazilgan proplar muhim xavfsizlik chegarasidir. Buni jamoangizning kodni ko'rib chiqish jarayonining asosiy nuqtasi qiling. "Ushbu prop obyektdagi har bir ma'lumot xavfsiz va mijoz uchun zarurmi?" degan savolni bering.
4. Statik tahlil va linting: Kelajakda biz ushbu tushunchalar asosida asboblar yaratishni kutishimiz mumkin. Kodingizni statik tahlil qila oladigan va potentsial sanitarizatsiya qilinmagan obyektni `'use client'` komponentiga o'tkazganingizda sizni ogohlantira oladigan ESLint qoidalarini tasavvur qiling.

Ma'lumotlar xavfsizligi va muvofiqligi bo'yicha global nuqtai nazar

Xalqaro miqyosda faoliyat yurituvchi tashkilotlar uchun ushbu texnik himoya vositalari bevosita huquqiy va moliyaviy oqibatlarga olib keladi. Evropadagi Ma'lumotlarni himoya qilish bo'yicha umumiy nizom (GDPR), Kaliforniya iste'molchilarining maxfiyligi to'g'risidagi qonun (CCPA), Braziliyaning LGPD va boshqalar shaxsiy ma'lumotlarni qayta ishlash bo'yicha qat'iy qoidalarni belgilaydi. PII ning tasodifiy sizib chiqishi, hatto beixtiyor bo'lsa ham, ma'lumotlarning buzilishini tashkil qilishi mumkin, bu esa jiddiy jarimalarga va mijozlarning ishonchini yo'qotishga olib keladi.

React'ning Taint API'larini amalga oshirish orqali siz "Ma'lumotlarni himoya qilish orqali loyihalash va standart bo'yicha" tamoyillarini (GDPRning asosiy tamoyili) amalga oshirishga yordam beradigan texnik nazoratni yaratmoqdasiz. Bu foydalanuvchi ma'lumotlarini himoya qilishda zarur g'ayratni namoyish etadigan, sizning global muvofiqlik majburiyatlaringizni bajarishni osonlashtiradigan faol qadamdir.

Xulosa: Veb uchun xavfsizroq kelajakni qurish

React Server Komponentlari veb-ilovalarini qanday yaratishimizda monumental o'zgarishni ifodalaydi, server tomonidagi quvvat va mijoz tomonidagi boylikning eng yaxshi tomonlarini birlashtiradi. Eksperimental Taint API'lari ushbu yangi dunyoga muhim va kelajakni o'ylab ko'rish qo'shimchasidir. Ular nozik, ammo jiddiy xavfsizlik zaifligini hal qiladi va standartni "tasodifan xavfsiz emas" dan "standart bo'yicha xavfsiz" ga aylantiradi.

Manbaidagi sezgir ma'lumotlarni experimental_taintObjectReference va experimental_taintUniqueValue bilan belgilash orqali biz Reactga bizning hushyor xavfsizlik hamkorimiz vazifasini bajarishga imkon beramiz. U ishlab chiquvchilarning xatolarini ushlaydigan va eng yaxshi amaliyotlarni amalga oshiradigan xavfsizlik tarmog'ini ta'minlaydi va sezgir server ma'lumotlarining hech qachon mijozga etib borishiga yo'l qo'ymaydi.

Ishlab chiquvchilarning global hamjamiyati sifatida bizning harakatga chaqirig'imiz aniq: ushbu API'lar bilan tajriba o'tkazishni boshlang. Ularni ma'lumotlarga kirish qatlamlaringizga va konfiguratsiya modullaringizga joriy qiling. API'lar yetuklashganda React jamoasiga fikr-mulohazalaringizni bildiring. Eng muhimi, jamoalaringizda xavfsizlik birinchi navbatda turadigan fikrni rivojlantiring. Zamonaviy vebda xavfsizlik keyinroq o'ylab topilgan narsa emas; bu sifatli dasturiy ta'minotning asosiy ustunidir. Taint API'lari kabi vositalar bilan React bizga ushbu poydevorni har qachongidan ham mustahkamroq qurishimiz uchun zarur bo'lgan arxitektura yordamini bermoqda.