WisarWisar
Dasturlash kitobi/5-QISM — Nodejs15 daqiqa

5.8-bob: Environment variables — dotenv, config

5-QISM — Node.js Backend · 8-mavzu

1. Kirish va motivatsiya

API yozishni (5.5–5.6) va dizaynni 5.7-bob bildik. Endi muhim, lekin ko'pincha e'tibordan chetda qoladigan mavzuni o'rganamiz: konfiguratsiya — sozlamalarni boshqarish. Har bir real ilovada muhitga bog'liq qiymatlar bor: DB parol, API kalit (5.18: SMS, 5.19: email), JWT maxfiy kaliti 5.15-bob, port, DB ulanish manzili. Bularni koddan ajratish — xavfsizlik va moslashuvchanlikning asosi.

Environment variables (muhit o'zgaruvchilari) — operatsion tizim 0.2-bob yoki ishga tushirish muhiti beradigan qiymatlar; ular process.env 5.1-bob orqali o'qiladi. .env fayl 4.5-bob va dotenv kutubxonasi bilan ularni qulay boshqaramiz.

Nega koddan ajratish? Ikki sabab. Birinchi — xavfsizlik (14): DB parolini kodga yozsangiz va kod GitHub'ga ketsa 4.3-bob — parol hammaga ochiq (falokat). Ikkinchi — moslashuvchanlik (10): dev kompyuteringizda DB localhost, production serverda boshqa manzil; kodni o'zgartirmasdan, faqat env'ni almashtirasiz. Bu — 12-Factor App prinsipi: "konfiguratsiyani koddan ajrat".

O'xshatish: kod — universal qurilma (masalan telefon zaryadlagich); env — mamlakatga mos vilka (adapter). Bir xil qurilma (kod) har mamlakatda (muhitda) ishlaydi — faqat adapter (env) o'zgaradi. Yoki: kod — retsept; env — masalliq miqdori (har oshxonada boshqacha). Retseptni o'zgartirmaysiz, masalliqni moslaysiz.

Nega muhim?

  • Xavfsizlik (14) — maxfiy ma'lumotni (parol, kalit) koddan/git'dan ajratish.
  • Turli muhitlar (10) — dev/test/production — bir kod, har xil sozlama.
  • 12-Factor App — zamonaviy ilova dizayni standarti.
  • DB (6), auth 5.15-bob, SMS/email (5.18, 5.19), deploy (10) — hammasi env bilan.

2. Nazariya — chuqur tushuntirish

2.1. Environment variable nima?

Environment variable — operatsion tizim 0.2-bob yoki process 5.1-bob muhitida saqlanadigan nom-qiymat juftligi. Node'da ular process.env obyekti orqali o'qiladi 5.1-bob:

js
process.env.PORT          // "3000" (har doim STRING!)
process.env.NODE_ENV      // "development" / "production"
process.env.DATABASE_URL  // "postgres://..."

process.env qiymatlari — DOIM string 0.1-bob. process.env.PORT — "3000" (matn, son emas). Son kerak bo'lsa — Number(process.env.PORT) (2.6-JS); boolean uchun === "true".

2.2. Env'ni qanday o'rnatish (uch usul)

bash
# 1. Terminal'da inline (bir martalik — 0.3)
PORT=8080 NODE_ENV=production node app.js

# 2. Export (sessiya uchun — 0.3)
export PORT=8080        # (Windows: $env:PORT="8080")
node app.js

# 3. .env fayl (eng qulay — 2.4)
# .env faylga yoziladi, dotenv yuklaydi

Production'da (10) env'lar server/hosting platforma (Vercel, AWS — 10.6) sozlamalarida beriladi (.env fayl emas — 2.11).

2.3. NODE_ENV — maxsus o'zgaruvchi

NODE_ENV — eng muhim env: ilova qaysi muhitda ishlayotganini bildiradi:

text
  NODE_ENV=development  — lokal ishlab chiqish (batafsil log, error stack)
  NODE_ENV=production   — real server (optimallashgan, log kam, xato yashirin)
  NODE_ENV=test         — test (8.11)

Ko'p kutubxona (Express ham) NODE_ENVga qarab xulqini o'zgartiradi (production'da tezroq, xavfsizroq):

js
if (process.env.NODE_ENV === "production") {
  app.use(helmet());                    // production'da xavfsizlik (5.6, 14)
} else {
  app.use(morgan("dev"));               // dev'da batafsil log (5.6)
}

2.4. .env fayl va dotenv

.env — loyiha ildizidagi fayl 4.5-bob; KALIT=qiymat ko'rinishida:

text
# .env (4.5: gitignore'da!)
PORT=3000
NODE_ENV=development
DATABASE_URL=postgres://user:parol@localhost:5432/mydb
JWT_SECRET=juda-maxfiy-kalit-123
REDIS_URL=redis://localhost:6379

dotenv — bu faylni o'qib, process.envga yuklaydigan kutubxona:

bash
npm install dotenv          # (5.2)
js
import "dotenv/config";     // ENG TEPADA — boshqa importlardan oldin (2.6)
// yoki: import dotenv from "dotenv"; dotenv.config();

console.log(process.env.PORT);   // endi ".env"dagi qiymat o'qiladi

dotenv'ni eng tepada yukla — boshqa modullardan oldin (entry fayl boshida). Aks holda, env'ga muhtoj modul process.envni bo'sh ko'radi (hali yuklanmagan). Bu — eng ko'p uchraydigan dotenv xatosi.

2.5. .env sintaksisi

text
PORT=3000                          # oddiy
NAME="Ali Valiyev"                 # tirnoq (bo'shliqli qiymat)
DB_URL=postgres://localhost/db     # maxsus belgilar
# Bu — izoh 4.5-bob
MULTILINE="qator1\nqator2"
EXPANDED=${PORT}/api               # ${} — boshqa o'zgaruvchiga havola (dotenv'da)

2.6. Native --env-file (zamonaviy Node)

Yangi Node (20.6+; 22.21/24.10 dan barqaror) .envni dotenv'siz, native yuklaydi:

bash
node --env-file=.env app.js        # dotenv KERAK EMAS (native)
node --env-file=.env.production app.js

dotenv vs native: native (--env-file) — paketsiz, sodda. Lekin ${VAR} kengaytirishni qo'llamaydi 2.5-bob. dotenv — boyroq (kengaytirish, dinamik yuklash). Loyiha ehtiyojiga qarab tanlang; ikkalasi ham keng tarqalgan.

2.7. Turli muhitlar uchun alohida .env

12-Factor: har muhit uchun alohida .env (12factor):

text
  .env                — lokal/dev (default)
  .env.development    — dev
  .env.test           — test 8.11-bob
  .env.production     — production (lekin odatda real env, 2.11)
  .env.local          — lokal, shaxsiy override (git'ga emas — 4.5)
  .env.example        — namuna (kalitsiz — git'ga, 4.5)

.env.local: ko'p loyiha (Next.js, Vite — 11) .env.local ni qo'llab-quvvatlaydi — bu shaxsiy, mashinangizga xos override (umumiy .env ustidan). U doim gitignore'da 4.5-bob: jamoadosh sizning lokal kalitingizni ko'rmaydi. Yuklash tartibi odatda: .env.local > .env.${muhit} > .env (oldingisi keyingisini override qiladi).

js
// NODE_ENV'ga qarab tegishli faylni yuklash (dotenv bilan)
import dotenv from "dotenv";
const muhit = process.env.NODE_ENV || "development";
dotenv.config({ path: `.env.${muhit}` });   // .env.development / .env.production

2.7. .env.example — jamoa uchun namuna (4.5)

.env (maxfiy) git'ga ketmaydi 4.5-bob, lekin yangi dasturchi qaysi o'zgaruvchilar kerakligini bilishi uchun .env.example (kalitsiz namuna) git'ga qo'shiladi:

text
# .env.example (git'ga — 4.5)
PORT=3000
DATABASE_URL=          # bo'sh (har kim o'zinikini qo'yadi)
JWT_SECRET=

2.8. Markazlashtirilgan config obyekti (eng yaxshi amaliyot)

process.envni butun kodda tarqatish — yomon (tip yo'q, validatsiya yo'q, typo'ga moyil). Bitta config moduli yarating — env'ni bir joyda o'qing, tekshiring, eksport qiling:

js
// config/index.js
import "dotenv/config";

export const config = {
  port: Number(process.env.PORT) || 3000,        // string  number (2.1)
  nodeEnv: process.env.NODE_ENV || "development",
  db: {
    url: process.env.DATABASE_URL,
  },
  jwt: {
    secret: process.env.JWT_SECRET,
    expiresIn: process.env.JWT_EXPIRES || "1h",
  },
  isProd: process.env.NODE_ENV === "production",  // qulaylik (2.3)
};

Nega config moduli: (1) env'ni bir joyda o'qish — typo va tarqalishdan saqlaydi; (2) tur aylantirish (Number/boolean — 2.1) bir joyda; (3) default qiymatlar; (4) butun kod config.port ishlatadi (process.env.PORT emas) — toza, test qilish oson (5.6: 9.1).

2.9. Env validatsiyasi (Zod bilan)

Eng muhim best practice: ishga tushishda kerakli env'lar borligini tekshiring. Aks holda, masalan JWT_SECRET yo'q bo'lsa, ilova ishlaydi, lekin auth (5.15) jim buziladi (xavfli — 14):

js
import { z } from "zod";              // (5.9 da chuqur; npm install zod)

const envSchema = z.object({
  PORT: z.coerce.number().default(3000),       // string  number (2.1)
  NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
  DATABASE_URL: z.string().url(),              // MAJBURIY — yo'q bo'lsa xato
  JWT_SECRET: z.string().min(32),              // kamida 32 belgi (14)
});

// Ishga tushishda tekshir (fail fast — 2.12-JS)
const parsed = envSchema.safeParse(process.env);
if (!parsed.success) {
  console.error(" Env xato:", parsed.error.format());
  process.exit(1);                              // darrov to'xta (5.1)
}
export const env = parsed.data;                 // tur-xavfsiz (7: TS bilan)

Fail fast — kerakli env yo'q bo'lsa, ilova darrov, aniq xato bilan to'xtasin (ishlab, keyin jim buzilgandan ko'ra). Bu — production'da (10) hayotni saqlaydi.

2.10. 12-Factor App: konfiguratsiya prinsipi

12-Factor App — zamonaviy, bulutga mos ilova dizayni (12factor.net). Uning 3-omili — konfiguratsiya:

"Konfiguratsiyani environment'da sakla, kodda emas."

Bu degani: bir xil kod (artefakt) — dev, staging, production'da o'zgarmasdan ishlaydi; faqat env farq qiladi 2.2-bob. Kod git'da (4), env esa har muhitda alohida.

2.11. Production'da .env ishlatma (xavfsizlik — 14)

Production serverda (10) odatda .env fayl ishlatilmaydi. O'rniga env'lar platforma sozlamalarida beriladi (12factor, xavfsizlik — 14):

text
  Vercel/Netlify:  dashboard  Environment Variables 13.11-bob
  AWS/server:      systemd, Docker env, secrets manager (10.6, 10.11)
  Docker:          docker run -e PORT=3000  yoki  env_file (10.3)

Nega: .env fayl diskda 0.2-bob — agar server buzilsa, fayl o'qilishi mumkin. Platforma secrets — shifrlangan, boshqariladigan. Kichik loyihada .env mayli, lekin jiddiy production'da secrets manager (10.11, 14).

2.12. Maxfiy vs ochiq konfiguratsiya

  • Maxfiy (secret): DB parol, JWT kalit, API kalit 5.18-bob — env'da, hech qachon kodda/git'da (14).
  • Ochiq (non-secret): port, log darajasi, feature flag — env'da bo'lishi mumkin, lekin maxfiy emas.
  • Frontend env: brauzerga ketadigan env (React — 11) maxfiy bo'lolmaydi (foydalanuvchi ko'radi); faqat ochiq qiymat (API URL).

Frontend'da maxfiy kalit ishlatma — brauzerga yuborilgan hamma narsa ochiq (0.5, 14). Maxfiy ish — faqat backend'da (5).

3. Sintaksis — tez ma'lumotnoma

bash
# .env yuklash
import "dotenv/config";              # dotenv (eng tepada — 2.4)
node --env-file=.env app.js          # native (2.6)

# O'qish 5.1-bob — har doim string!
process.env.PORT                     # "3000"  Number(...) (2.1)
process.env.NODE_ENV === "production"
text
.env:       KALIT=qiymat  (4.5: gitignore'da)
.env.example: KALIT=      (git'ga — namuna, 2.7)
config:     bir joyda o'qi, tekshir (Zod), eksport (2.8, 2.9)
production: platforma secrets (.env emas — 2.11)

4. Batafsil kod namunalari

Misol 1 — dotenv asosiy ishlatish (2.4)

js
// .env
// PORT=4000
// DATABASE_URL=postgres://localhost:5432/mydb

// app.js — dotenv ENG TEPADA (2.4)
import "dotenv/config";              // boshqa importlardan OLDIN!
import express from "express";       // (5.6)

const app = express();
const PORT = Number(process.env.PORT) || 3000;   // string  number (2.1)

app.listen(PORT, () => {
  console.log(`Server ${PORT}-portda (${process.env.NODE_ENV || "dev"})`);
});

Misol 2 — Markazlashtirilgan config moduli (2.8)

js
// config/index.js
import "dotenv/config";

export const config = {
  port: Number(process.env.PORT) || 3000,
  nodeEnv: process.env.NODE_ENV || "development",
  isProd: process.env.NODE_ENV === "production",      // qulaylik (2.3)
  db: { url: process.env.DATABASE_URL },
  jwt: {
    secret: process.env.JWT_SECRET,
    expiresIn: process.env.JWT_EXPIRES_IN || "1h",
  },
  sms: { apiKey: process.env.ESKIZ_API_KEY },         // (5.18)
};

// app.js — endi config orqali (process.env emas)
import { config } from "./config/index.js";
app.listen(config.port, () => console.log(`Port: ${config.port}`));
// Butun kod config.* ishlatadi — toza, bir manba (2.8)

Misol 3 — Env validatsiyasi (Zod — 2.9, fail fast)

js
// config/env.js
import "dotenv/config";
import { z } from "zod";             // (5.9)

const schema = z.object({
  PORT: z.coerce.number().default(3000),
  NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
  DATABASE_URL: z.string().url(),                    // MAJBURIY
  JWT_SECRET: z.string().min(32, "JWT_SECRET kamida 32 belgi"),   // (14)
  REDIS_URL: z.string().optional(),                  // ixtiyoriy (5.21)
});

const result = schema.safeParse(process.env);
if (!result.success) {
  console.error(" Environment xato:");
  console.error(result.error.flatten().fieldErrors);  // aniq qaysi env xato
  process.exit(1);                                    // fail fast (2.9, 5.1)
}

export const env = result.data;        // tur-xavfsiz, default'lar bilan
// Endi env.PORT — NUMBER (string emas — Zod coerce qildi)

Misol 4 — NODE_ENV bo'yicha xulq (2.3)

js
import express from "express";
import { config } from "./config/index.js";

const app = express();

if (config.isProd) {                                 // (2.3, 2.8)
  // Production: xavfsizlik + minimal log (14, 5.12)
  const helmet = (await import("helmet")).default;
  app.use(helmet());
  app.set("trust proxy", 1);                         // reverse proxy ortida (10.2)
} else {
  // Development: batafsil log + xato stack (5.10)
  const morgan = (await import("morgan")).default;
  app.use(morgan("dev"));
}

// Xato javobida 5.10-bob: dev'da stack, prod'da yashir
app.use((err, req, res, next) => {
  res.status(500).json({
    xato: err.message,
    ...(config.isProd ? {} : { stack: err.stack }),  // prod'da stack YASHIRIN (14)
  });
});

Misol 5 — Turli muhit fayllari (2.7)

js
// config/index.js — NODE_ENV'ga qarab fayl tanlash
import dotenv from "dotenv";

const muhit = process.env.NODE_ENV || "development";
dotenv.config({ path: `.env.${muhit}` });            // .env.development / .env.production
dotenv.config({ path: ".env" });                     // umumiy (override qilmaydi)

export const config = { /* ... */ };
// NODE_ENV=production node app.js  .env.production yuklanadi

Misol 6 — .env.example va README (2.7, jamoa)

text
# .env.example (git'ga — 4.5)
# Loyihani ishga tushirish: nusxa ol  .env qil  qiymatlarni to'ldir
PORT=3000
NODE_ENV=development
DATABASE_URL=postgres://user:password@localhost:5432/dbname
JWT_SECRET=                         # kamida 32 belgi (crypto.randomBytes — 5.3)
ESKIZ_API_KEY=                      # SMS (5.18)
bash
# Yangi dasturchi:
cp .env.example .env                # nusxa (0.3)
# .env'ni to'ldirib, npm run dev

Misol 7 — Native --env-file (dotenv'siz — 2.6)

js
// app.js — dotenv import YO'Q (native yuklaydi)
import express from "express";
const app = express();
app.listen(process.env.PORT || 3000);
bash
node --env-file=.env app.js                          # native (2.6)
node --env-file=.env.production app.js                # production fayl
json
// package.json (5.2)
{ "scripts": {
  "dev": "node --env-file=.env --watch app.js",
  "start": "node --env-file=.env.production app.js"
}}

Misol 8 — Secret yaratish (5.3 bilan)

js
// JWT_SECRET kabi kuchli maxfiy kalit yaratish (5.3: crypto)
import crypto from "node:crypto";
console.log(crypto.randomBytes(32).toString("hex"));  // 64 belgili kalit (5.3)
// Buni .env'dagi JWT_SECRET'ga qo'ying (qo'lda yozmang — kuchsiz bo'ladi, 14)

5. To'g'ri va noto'g'ri holatlar

1) Maxfiy ma'lumotni kodda yozish

js
//  kodga yozilgan parol  git'ga ketadi  ochiq (14, 4.3)
const dbUrl = "postgres://admin:parol123@server/db";

//  env'da
const dbUrl = process.env.DATABASE_URL;

2) .env'ni git'ga qo'shish

text
 .env commit qilingan  maxfiy ma'lumot ochiq (4.5, 14)
 .gitignore'da .env; .env.example (kalitsiz) git'ga (2.7)

3) dotenv'ni kech yuklash

js
//  env'ga muhtoj modul dotenv'dan OLDIN
import { db } from "./db.js";        // db process.env'ni bo'sh ko'radi!
import "dotenv/config";

//  dotenv eng tepada (2.4)
import "dotenv/config";
import { db } from "./db.js";

4) Env'ni tekshirmaslik

js
//  JWT_SECRET yo'q  auth jim buziladi (xavfli — 2.9)
const secret = process.env.JWT_SECRET;   // undefined!

//  ishga tushishda tekshir (fail fast — Misol 3)

5) process.env qiymatini son deb ishlatish

js
//  string  "3000" + 1 = "30001" (2.1)
const port = process.env.PORT + 1;

//  Number
const port = Number(process.env.PORT) + 1;

6. Keng tarqalgan xatolar va yechimlari

Xato 1 — process.env.X undefined

Sababi: .env yuklanmagan (dotenv yo'q/kech — 2.4), yoki kalit nomi typo. Yechimi: import "dotenv/config" eng tepada; kalit nomini tekshir; .env to'g'ri papkada (loyiha ildizi).

Xato 2 — Maxfiy ma'lumot git'ga ketdi

Sababi: .gitignore'da .env yo'q 4.5-bob. Yechimi: .gitignorega qo'sh; kalitni darrov bekor qil (yangisini yarat — 4.5, 14).

Xato 3 — Production'da ilova ishlamaydi (env yo'q)

Sababi: server env'lari sozlanmagan 2.11-bob. Yechimi: platforma sozlamalarida env qo'sh (Vercel/Docker — 2.11); validatsiya (fail fast — 2.9) bilan aniq xato.

Xato 4 — Boolean env noto'g'ri

js
if (process.env.DEBUG) {...}   // "false" ham TRUTHY! (2.2-JS)

Sababi: string "false" — truthy 2.1-bob. Yechimi: process.env.DEBUG === "true".

Xato 5 — Dev sozlama production'da

Sababi: NODE_ENV o'rnatilmagan 2.3-bob. Yechimi: production'da NODE_ENV=production; config'da default va tekshiruv.

7. Integratsiya — bu mavzu stack'ning qayerida uchraydi

  • process.env 5.1-bob: env'lar shu yerda.
  • .gitignore 4.5-bob: .env himoyasi.
  • crypto 5.3-bob: kuchli secret yaratish (Misol 8).
  • Validatsiya/Zod 5.9-bob: env tekshirish.
  • DB (6), auth 5.15-bob, SMS/email (5.18, 5.19): ulanish/kalitlar env'da.
  • Xavfsizlik (14): secrets boshqaruvi.
  • Deploy (10, 13.11): platforma env'lari; Docker 10.3-bob.
  • NestJS 8.14-bob: @nestjs/config — shu g'oya.

8. Eng yaxshi amaliyotlar (best practices)

  • Maxfiy ma'lumotni hech qachon kodda/git'da — env'da (14, 4.5).
  • dotenv'ni eng tepada yuklang (entry fayl boshida — 2.4); yoki native --env-file 2.6-bob.
  • Markazlashtirilgan config moduli — process.envni tarqatmang 2.8-bob.
  • Env'ni ishga tushishda tekshiring (Zod, fail fast — 2.9).
  • String'ni to'g'ri tur'ga aylantiring (Number/boolean — 2.1, config'da bir joyda).
  • .env.example (kalitsiz) git'ga — jamoa uchun 2.7-bob.
  • Turli muhit uchun alohida (.env.development/.env.production — 2.7); 12-Factor 2.10-bob.
  • Production'da platforma secrets (.env fayl emas — 2.11).
  • Frontend'da maxfiy kalit ishlatmang (brauzer ochiq — 2.12, 14).
  • Kuchli secret — crypto.randomBytes (qo'lda yozmang — Misol 8).

9. Amaliy loyiha: "Konfiguratsiya va Muhit Boshqaruvi"

Env va config'ni professional darajada mustahkamlash.

Maqsad

dotenv, markazlashtirilgan config, env validatsiyasi va turli muhit boshqaruvini birlashtirib, xavfsiz, moslashuvchan sozlama tizimini qurish.

Talablar (requirements)

  1. .env + .env.example: PORT, NODE_ENV, DATABASE_URL, JWT_SECRET, va h.k.; .env gitignore'da, .env.example git'ga (2.7, 4.5).
  2. dotenv yuklash: entry faylda eng tepada (yoki native --env-file — 2.4, 2.6).
  3. Markazlashtirilgan config: config/index.js — env'ni bir joyda o'qi, tur'ga aylantir (Number/boolean), default qiymatlar, isProd (2.8, Misol 2).
  4. Env validatsiyasi: Zod bilan — kerakli env'lar borligini, formatini tekshir; yo'q bo'lsa fail fast (Misol 3, 2.9).
  5. NODE_ENV bo'yicha xulq: dev'da batafsil log, prod'da xavfsizlik + stack yashirish (Misol 4, 2.3).
  6. Secret generator: crypto bilan JWT_SECRET yaratuvchi skript (Misol 8, 5.3).
  7. package.json scripts: dev/start (turli env — Misol 7, 5.2).
  8. README: o'rnatish yo'riqnomasi (.env.example nusxa olish — Misol 6).
  9. Butun kod config.* ishlatsin (process.env tarqatilmasin — 2.8).

Maslahatlar (hint)

  • dotenv eng tepada (2.4, 3-xato).
  • config'da Number(process.env.X) — stringnumber 2.1-bob.
  • Zod: z.coerce.number(), z.string().url(), z.string().min(32) 2.9-bob.
  • isProd = process.env.NODE_ENV === "production" 2.3-bob.
  • .envni gitignore'ga 4.5-bob; kalitlarni .env.exampleda bo'sh qoldiring.
  • Secret: crypto.randomBytes(32).toString("hex") 5.3-bob.

"Tayyor" mezonlari (acceptance criteria)

  • .env (gitignore) + .env.example (git) bor.
  • dotenv/native to'g'ri yuklanadi (eng tepada).
  • Markazlashtirilgan config; tur aylantirish; default.
  • Env validatsiyasi (Zod) — yo'q env'da fail fast.
  • NODE_ENV bo'yicha dev/prod xulq farqi.
  • Secret generator ishlaydi.
  • Butun kod config.* ishlatadi (process.env tarqatilmagan).
  • README o'rnatish yo'riqnomasi bilan.

Yechim kodi ataylab berilmagan — bu loyihani o'zingiz yozib ko'ring.

10. Xulosa va keyingi bobga ko'prik

Bu bobda konfiguratsiyani professional boshqarishni o'rgandik:

  • Environment variables — process.env 5.1-bob orqali; doim string (Number/boolean'ga aylantir).
  • .env + dotenv (eng tepada yukla) yoki native --env-file; .env gitignore'da, .env.example git'da 4.5-bob.
  • NODE_ENV — muhit (dev/prod/test); kutubxonalar xulqini o'zgartiradi.
  • Markazlashtirilgan config moduli — env'ni bir joyda o'qi/tekshir/aylantir; butun kod config.*.
  • Env validatsiyasi (Zod, fail fast) — kerakli env yo'q bo'lsa darrov to'xta.
  • 12-Factor — config env'da, kodda emas; production'da platforma secrets (.env emas); maxfiy ma'lumot — faqat backend (14).

Keyingi bob — 5.9-bob: Validatsiya — express-validator, Joi, Zod, class-validator. Konfiguratsiyani bildik; endi foydalanuvchi yuborgan ma'lumotni (so'rov body, query — 5.6) tekshirishni o'rganamiz. "Hech qachon foydalanuvchiga ishonma" (14) — validatsiya backend'ning birinchi himoya chizig'i. Zod (5.8'da env uchun ko'rdik), Joi, express-validator — to'liq ochamiz.

Foydalanilgan rasmiy/ishonchli manbalar

  • github.com/motdotla/dotenv — dotenv hujjatlari
  • 12factor.net — Config (III omil)
  • nodejs.org — process.env, --env-file; zod.dev — env validatsiya

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
5.8-bob: Environment variables — dotenv, config — Wisar