ഞാൻ കാപ്പി കുടിക്കുന്നതിന് മുൻപ് ഒരു ബാക്കെൻഡ് ഉണ്ടാക്കാൻ ശ്രമിച്ച ദിവസം
തിങ്കളാഴ്ച രാവിലെ ഒരു ബാക്കെൻഡ് ഉണ്ടാക്കാൻ ശ്രമിച്ചിട്ടുണ്ടോ? നിങ്ങളുടെ API ഗേറ്റ്വേ 403 Forbidden-ൽ വെക്കേഷൻ ആഘോഷിക്കുമ്പോൾ, ഡാറ്റാബേസിന് എന്തോ പ്രശ്നങ്ങളുണ്ടെന്നും തോന്നിയാൽ എങ്ങനെയിരിക്കും? ഒരിക്കൽ എനിക്കങ്ങനെ ഒരനുഭവമുണ്ടായി. എനിക്ക് ഒരു ചെറിയ endpoint മതിയായിരുന്നു—ഒരു /hello—പക്ഷേ ഞാൻ VPC-കളെക്കുറിച്ച് Hogwarts വീടുകൾ തിരഞ്ഞെടുക്കുന്നതുപോലെ തർക്കിക്കേണ്ടിവന്നു.
ഇതാ ഒരു സന്തോഷവാർത്ത: Lovable Cloud “ഒരു ബാക്കെൻഡ് ഉണ്ടാക്കുക” എന്ന ഭാഗം കൂടുതൽ ഇഷ്ടമുള്ളതാക്കാൻ ശ്രമിക്കുന്നു... അല്ലെങ്കിൽ കുറഞ്ഞത് ദേഷ്യം കുറയ്ക്കാൻ. നിങ്ങൾക്ക് 30 മിനിറ്റും Wi-Fi കണക്ഷനും കുറച്ച് രൂപകങ്ങളെ സഹിക്കാനുള്ള മനസ്സുമുണ്ടെങ്കിൽ, Lovable Cloud ഉപയോഗിച്ച് ഒരു ബാക്കെൻഡ് എങ്ങനെ ഉണ്ടാക്കാമെന്ന് ഞാൻ നിങ്ങൾക്ക് ഘട്ടം ഘട്ടമായി പറഞ്ഞുതരാം—എന്തൊക്കെ ശ്രദ്ധിക്കണം, എങ്ങനെ endpoints-കളുടെ ഒരു നൂഡിൽ സൂപ്പ് ആകാതെ സൂക്ഷിക്കാം എന്നെല്ലാം.
ശ്രദ്ധിക്കുക: ഇതൊരു പ്രാക്ടിക്കൽ, ഹാൻഡ്സ്-ഓൺ ഗൈഡാണ്. വെറുതെ വാചകമടിക്കുന്നതിന് പകരം, കൂടുതൽ “ഇവിടെ ക്ലിക്ക് ചെയ്യുക, ഇത് ടൈപ്പ് ചെയ്യുക, അത് ചെയ്യരുത്” എന്ന രീതിയിലുള്ള നിർദ്ദേശങ്ങൾ നൽകുന്നു. അതേ, നമ്മൾ ഇവിടെ ഒരു യഥാർത്ഥ പ്രോജക്റ്റ് ഉണ്ടാക്കാൻ പോകുന്നു: auth, ഡാറ്റാബേസ്, എൻവയോൺമെൻ്റ് സീക്രട്ട്സ്, ഡിപ്ലോയ്മെൻ്റ്, മോണിറ്ററിംഗ്, കൂടാതെ സ്കെയിൽ ചെയ്യാനുള്ള എളുപ്പവഴിയുമുള്ള ഒരു API. ഒരു സ്നാക്ക് എടുത്തോളൂ. നമ്മൾ തുടങ്ങാൻ പോകുവാണ്.
എന്താണ് Lovable Cloud, നിങ്ങളുടെ ബാക്കെൻഡ് എന്തിന് ശ്രദ്ധിക്കണം?
Lovable Cloud-നെ ഒരു ആധുനിക ബാക്കെൻഡ് സ്വിസ് ആർമി കത്തിയായി കണക്കാക്കുക: സെർവർലെസ് ഫംഗ്ഷനുകൾ, API റൂട്ടിംഗ്, ഡാറ്റാബേസ് കണക്ഷനുകൾ, എൻവയോൺമെൻ്റ് സീക്രട്ട്സ്, CI/CD—ഇവയെല്ലാം YAML ഫയലുകളുടെ ഒരു പൊടിപിടിച്ച മൃഗശാലയെ പരിപാലിക്കുന്നതിൽ നിന്ന് നിങ്ങളെ രക്ഷിക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ്.
- നിങ്ങൾ കോഡ് എഴുതുന്നു (Node/TypeScript, Python—ഏതാണ് ഇപ്പോഴത്തെ ട്രെൻഡിംഗ് എന്ന് ഡോക്സിൽ പരിശോധിക്കുക).
- നിങ്ങൾ റൂട്ടുകൾ നിർവചിക്കുന്നു (REST). നിങ്ങൾക്ക് ഇഷ്ടമുള്ള GraphQL ഉപയോഗിക്കാം അല്ലെങ്കിൽ JSON-ൽ തുടരാം.
- നിങ്ങൾ ഒരു മാനേജ്ഡ് ഡാറ്റാബേസ് കണക്ട് ചെയ്യുന്നു (PostgreSQL ആണ് ഇവിടുത്തെ സ്ഥിരം താരം).
- നിങ്ങൾ ഡിപ്ലോയ് ചെയ്യുന്നു. അത് സ്കെയിൽ ചെയ്യുന്നു. കൂടുതൽ സെർവറുകൾ ചേർക്കാൻ പുലർച്ചെ 3 മണിക്ക് എഴുന്നേൽക്കുന്നതിനെക്കുറിച്ച് നിങ്ങൾ വിഷമിക്കേണ്ടതില്ല.
നിങ്ങളുടെ മനസ്സിലെ “ബാക്കെൻഡ്” എന്ന ആശയം endpoints + auth + data + deploy + logs ആണെങ്കിൽ, Lovable Cloud കുറഞ്ഞ ബീപ് ശബ്ദങ്ങളോടും കൂടുതൽ രസീതുകളോടും കൂടിയ എക്സ്പ്രസ്സ് ലൈൻ ആകാൻ ശ്രമിക്കുന്നു.
Lovable Cloud ഉപയോഗിച്ച് ഒരു ബാക്കെൻഡ് ഉണ്ടാക്കുന്നതിനുള്ള ഗെയിം പ്ലാൻ
- ഒരു Lovable Cloud പ്രോജക്റ്റും റിപ്പോസിറ്ററിയും ഉണ്ടാക്കുക.
- ഒരു പബ്ലിക്, ഒരു പ്രൊട്ടക്റ്റഡ് റൂട്ട് എന്നിവ ഉപയോഗിച്ച് ഒരു API സ്കഫോൾഡ് ചെയ്യുക.
- ഒരു PostgreSQL ഡാറ്റാബേസ് ചേർത്ത് ഒരു മൈഗ്രേഷൻ റൺ ചെയ്യുക.
- എൻവയോൺമെൻ്റ് വേരിയബിളുകളും ഒരു ലളിതമായ ORM-ഉം വയർ ചെയ്യുക.
- Authentication ചേർക്കുക (JWT, സെഷൻ ടോക്കണുകൾ, അല്ലെങ്കിൽ OAuth—നിങ്ങളുടെ ഇഷ്ടം).
- ഒരു സ്റ്റേജിംഗ് എൻവയോൺമെൻ്റിലേക്ക് ഡിപ്ലോയ് ചെയ്യുക.
- മോണിറ്ററിംഗ്/ലോഗിംഗ്, ഒരു ഓട്ടോമേറ്റഡ് ടെസ്റ്റ് എന്നിവ ചേർക്കുക.
- നിങ്ങളുടെ ഭാവിയിലെ ബുദ്ധിമുട്ടുകൾ ഇല്ലാതെ പ്രൊഡക്ഷനിലേക്ക് പ്രൊമോട്ട് ചെയ്യുക.
അതെ, ഇത് ഒരുപാട് കാര്യങ്ങൾ ഉള്ളതുപോലെ തോന്നുന്നു. ഇല്ല, ഇതിന് ഒരാഴ്ച എടുക്കില്ല.
ഘട്ടം 1: നിങ്ങളുടെ Lovable Cloud പ്രോജക്റ്റ് ആരംഭിക്കുക (A.K.A. പുതിയ പ്രോജക്റ്റിന്റെ തുടക്കം)
- ഒരു അക്കൗണ്ട് ഉണ്ടാക്കി ഒരു പുതിയ പ്രോജക്റ്റ് ആരംഭിക്കുക. പിന്നീട് നിങ്ങൾക്ക് തിരിച്ചറിയാൻ കഴിയുന്ന ഒരു പേര് നൽകുക—“not_final_backend_v7” എന്നൊന്നും കൊടുത്ത് കുടുങ്ങരുത്.
- നിങ്ങളുടെ റൺടൈം തിരഞ്ഞെടുക്കുക (API-കൾക്കായി Node/TypeScript ആണ് സാധാരണയായി എല്ലാവർക്കും ഇഷ്ടമുള്ളത്).
- ലഭ്യമാണെങ്കിൽ ഒരു ടെംപ്ലേറ്റ് തിരഞ്ഞെടുക്കുക: “REST API” അല്ലെങ്കിൽ “Serverless Functions” എന്നിവ ഒരു ബ്ലാങ്ക് പേജിൽ നിന്ന് തുടങ്ങുന്നതിനേക്കാൾ വേഗത്തിൽ നിങ്ങൾക്ക് നല്ല റിസൾട്ട് തരും.
നിങ്ങൾക്ക് ഒരു Git റിപ്പോസിറ്ററി (നിങ്ങളുടേത് അല്ലെങ്കിൽ അവരുടേത്) ഒരു ഡെവലപ്മെന്റ് എൻവയോൺമെൻ്റും ലഭിക്കും. ഉടൻ തന്നെ ഒരു ബ്രാഞ്ച് ഉണ്ടാക്കുകയാണെങ്കിൽ (“feature/hello-api”) നിങ്ങളുടെ പ്രധാന ബ്രാഞ്ച് തെറ്റുകളുടെ ഒരു മ്യൂസിയം ആകാതെ സൂക്ഷിക്കാം.
ഘട്ടം 2: നിങ്ങളുടെ ആദ്യത്തെ Endpoint സ്കഫോൾഡ് ചെയ്യുക (Hello World ഇപ്പോളും മികച്ചതാണ്)
ഒരു അടിസ്ഥാന റൂട്ട് ഉണ്ടാക്കുക: /api/hello. ഇത് ലളിതവും മനോഹരവുമായി സൂക്ഷിക്കുക.
- റൂട്ട് ഫയൽ:
routes/hello.ts
- ഫംഗ്ഷൻ:
{ message: "Hello, world" } പോലുള്ള JSON നൽകുന്നു
- പ്രാദേശികമായി ടെസ്റ്റ് ചെയ്യുക: cURL അല്ലെങ്കിൽ നിങ്ങളുടെ ഇഷ്ടപ്പെട്ട HTTP ക്ലയിന്റ് ഉപയോഗിക്കുക. നിങ്ങൾക്ക് 200 ലഭിച്ചില്ലെങ്കിൽ, നിങ്ങളുടെ സ്റ്റെപ്പുകൾ വീണ്ടും പരിശോധിക്കുകയും ലോഗുകൾ പരിശോധിക്കുകയും ചെയ്യുക.
പ്രോ ടിപ്പ്: നിങ്ങളുടെ റൂട്ട് ഹാൻഡിലറുകൾ ചെറുതായി സൂക്ഷിക്കുക—endpoint-നുള്ളിൽ ബിസിനസ്സ് ലോജിക് ഒന്നും ഇടരുത്. ലോജിക് സർവീസുകളിൽ ഇടുക. നിങ്ങളുടെ ഭാവിയിലെ മാറ്റങ്ങൾ നിങ്ങൾക്ക് നന്ദി പറയും.
ഘട്ടം 3: പുരാതന DevOps സ്പിരിറ്റുകളെ വിളിക്കാതെ ഒരു ഡാറ്റാബേസ് ചേർക്കുക
PostgreSQL തിരഞ്ഞെടുക്കുക. ഇത് വിശ്വസനീയമാണ്, റിലേഷണലാണ്, കൂടാതെ ജോയിനുകളോട് വെറുപ്പില്ല.
- Lovable Cloud-ൽ, ഒരു മാനേജ്ഡ് Postgres ഇൻസ്റ്റൻസ് ഉണ്ടാക്കുക.
- ക്രെഡൻഷ്യലുകൾ എൻവയോൺമെൻ്റ് വേരിയബിളുകളായി സൂക്ഷിക്കുക:
DATABASE_URL, DB_USER, DB_PASS, DB_HOST, DB_NAME.
- ഒരു ORM അല്ലെങ്കിൽ ക്വറി ബിൽഡർ തിരഞ്ഞെടുക്കുക (Prisma, Drizzle, Knex). വേഗതയ്ക്കും സ്കീമയുടെ കൃത്യതയ്ക്കും വേണ്ടി ഞാൻ Prisma-യെ ആണ് കൂടുതൽ ഇഷ്ടപ്പെടുന്നത്.
അത് പ്രവർത്തിക്കുന്നു എന്ന് തെളിയിക്കാൻ ഒരു ചെറിയ users ടേബിൾ ഉണ്ടാക്കുക:
- സ്കീമ:
id (uuid), email (unique), created_at (timestamp).
- നിങ്ങളുടെ ഡെവലപ്മെന്റ് എൻവയോൺമെൻ്റിൽ നിന്ന് മൈഗ്രേഷൻ റൺ ചെയ്യുക.
- ഒരു ലിസ്റ്റ് നൽകുന്ന ഒരു
GET /api/users endpoint എഴുതുക. പുതിയൊരെണ്ണം ചേർക്കാൻ ഒരു POST /api/users ചേർക്കുക. Auth ഉപയോഗിച്ച് സംരക്ഷിക്കുക (അടുത്ത ഘട്ടം), പക്ഷേ തൽക്കാലം ഒരു ടെസ്റ്റ് ഇൻസേർട്ട് ഉപയോഗിച്ച് പരിശോധിക്കുക.
നിങ്ങൾക്ക് ടൈംഔട്ടുകളോ കണക്ഷൻ റീസെറ്റുകളോ കാണുകയാണെങ്കിൽ, ശരിയായ പോർട്ട്, SSL മോഡ്, നിങ്ങളുടെ ഡെവലപ്മെന്റ് എൻവയോൺമെൻ്റിന് DB-യുമായി സംസാരിക്കാൻ അനുമതിയുണ്ടോയെന്ന് പരിശോധിക്കുക (VPC നിയമങ്ങളും IP അലൗലിസ്റ്റുകളും പ്രശ്നമുണ്ടാക്കാൻ ഇഷ്ടപ്പെടുന്നവരാണ്).
ഘട്ടം 4: ഉപയോക്താക്കളെ കരയിക്കാത്ത Authentication ചേർക്കുക
നിങ്ങൾക്ക് ധാരാളം ഓപ്ഷനുകളുണ്ട്:
- സ്റ്റേറ്റ്ലെസ്സ് API-കൾക്കായി JWT അടിസ്ഥാനമാക്കിയുള്ള auth
- സുരക്ഷിതമായ കുക്കികളുള്ള സെഷൻ ടോക്കണുകൾ (വെബ് ആപ്ലിക്കേഷനുകൾക്ക് മികച്ചത്)
- Google, GitHub മുതലായവ ഉപയോഗിച്ചുള്ള OAuth (പാസ്വേഡ് പ്രശ്നങ്ങൾ ഒഴിവാക്കാൻ മികച്ചത്)
വേഗത്തിൽ കാര്യങ്ങൾ നേടാൻ, JWT-ൽ നിന്ന് ആരംഭിക്കുക:
- ലോഗിൻ ചെയ്യുമ്പോൾ ടോക്കണുകൾ ഉണ്ടാക്കുക (
POST /api/auth/login).
- Lovable Cloud-ന്റെ സീക്രട്ട്സ് മാനേജറിൽ സൈനിംഗ് സീക്രട്ട് സൂക്ഷിക്കുക.
- ഒരു
Authorization: Bearer <token> ഹെഡർ വായിക്കുന്ന ഒരു മിഡിൽവെയർ ഉണ്ടാക്കുക.
POST /api/users പോലുള്ള റൂട്ടുകളും ഡാറ്റ മാറ്റം വരുത്തുന്ന എന്തിനെയും സംരക്ഷിക്കുക.
ഓർക്കുക: കുറഞ്ഞ ടോക്കൺ ലൈഫ് ടൈം + റിഫ്രഷ് ടോക്കണുകൾ = ഉപകരണങ്ങൾ നഷ്ടപ്പെടുമ്പോഴോ അല്ലെങ്കിൽ ഡെവലപ്പർമാർ YouTube കമൻ്റിൽ ഒരു ടോക്കൺ ഇട്ട കാര്യം മറന്നുപോകുമ്പോഴോ ഉണ്ടാകുന്ന തലവേദന കുറയ്ക്കും (ചോദിക്കരുത്).
ഘട്ടം 5: എൻവയോൺമെൻ്റ് വേരിയബിളുകൾ: രഹസ്യങ്ങൾ, ഓർമ്മയ്ക്കുള്ള സൂവനീറുകളല്ല
Lovable Cloud-ൻ്റെ എൻവയോൺമെൻ്റ് മാനേജർ ഉപയോഗിച്ച് രഹസ്യങ്ങൾ കേന്ദ്രീകരിക്കുക:
APP_ORIGIN (CORS-ന് വേണ്ടി)
- മൂന്നാം കക്ഷി API കീകൾ (ഇമെയിൽ പ്രൊവൈഡർ, പേയ്മെന്റുകൾ)
ഓരോ എൻവയോൺമെൻ്റിനും (dev, staging, prod) വേണ്ടി അവ സെറ്റ് ചെയ്യുക. ഒന്നും ഹാർഡ്കോഡ് ചെയ്യരുത്. ചെയ്യരുത്. “ഇപ്പോൾ തൽക്കാലത്തേക്ക്” എന്ന് പോലും കരുതരുത്. അങ്ങനെയാണ് പേടിപ്പെടുത്തുന്ന കഥകൾ ആരംഭിക്കുന്നത്.
ഘട്ടം 6: നിങ്ങളുടെ ഭാവിയിലെ ഡോക്ടർക്ക് വിശദീകരിക്കാതെ സ്റ്റേജിംഗിലേക്ക് ഡിപ്ലോയ് ചെയ്യുക
Deploy-ൽ ക്ലിക്ക് ചെയ്യുക. ലോഗുകൾ കാണുക. ശ്വാസമെടുക്കുക.
- ഹെൽത്ത് ചെക്കുകൾ വാലിഡേറ്റ് ചെയ്യുക: നിങ്ങളുടെ റൂട്ട് അല്ലെങ്കിൽ
/api/health ok എന്ന് നൽകുന്നുണ്ടോ?
- ഒരു സ്മോക്ക് ടെസ്റ്റ് റൺ ചെയ്യുക:
GET /api/hello, GET /api/users.
- ഒരു ടെസ്റ്റ് ടോക്കൺ ഉപയോഗിച്ച് ഒരു പ്രൊട്ടക്റ്റഡ് റൂട്ട് പരീക്ഷിക്കുക—അത് ഇല്ലാതെ 401 ആണോ എന്നും, അത് വെച്ച് 200 ആണോ എന്നും ഉറപ്പാക്കുക.
കോൾഡ് സ്റ്റാർട്ടുകൾ മന്ദഗതിയിലാണെങ്കിൽ, ചെറിയ ഫംഗ്ഷനുകളെ ഒരു സിംഗിൾ സർവീസായി മാറ്റുക. സെർവർലെസ് മികച്ചതാണ്, പക്ഷേ 400 ചെറിയ ഫംഗ്ഷനുകൾ കണ്ടക്ടർ ഇല്ലാത്ത ഒരു ഓർക്കസ്ട്ര പോലെയാകാം.
ഘട്ടം 7: മോണിറ്ററിംഗ് ചേർക്കുക, അതിനാൽ പുലർച്ചെ 2 മണിക്ക് നിങ്ങൾ ഊഹിക്കേണ്ടി വരില്ല
- റിക്വസ്റ്റ് ലോഗിംഗ് എനേബിൾ ചെയ്യുക (സ്ട്രക്ചേർഡ് ലോഗുകൾ വേണം).
- Error capture സെറ്റ് ചെയ്യുക (റിക്വസ്റ്റ് ID-യോടുകൂടിയ സ്റ്റാക്ക് ട്രെയ്സുകൾ).
- ലേറ്റൻസി ഡാഷ്ബോർഡുകൾ ചേർക്കുക. p50 മാത്രമല്ല p95 കൂടി ശ്രദ്ധിക്കുക. നിങ്ങളുടെ ഉപയോക്താക്കൾ ശരാശരി അനുഭവങ്ങളല്ല ഉണ്ടാകുന്നത്.
- 5xx സ്പൈക്കുകൾക്കും DB കണക്ഷൻ പ്രശ്നങ്ങൾക്കും അലേർട്ടുകൾ ഉണ്ടാക്കുക.
ഓരോ ലെയറിലുമുള്ള റിക്വസ്റ്റ് ID-യോടുകൂടിയ ഒരൊറ്റ ലോഗ് ലൈൻ “ആരെങ്കിലും ഇത് കാണുന്നുണ്ടോ?” എന്ന് തുടങ്ങുന്ന 10,000 സ്ലാക്ക് മെസ്സേജുകൾക്ക് തുല്യമാണ്.
ഘട്ടം 8: ഒരു ടെസ്റ്റ് എഴുതുക. പിന്നെ രണ്ട്. എന്നിട്ട് ഓട്ടോമേറ്റ് ചെയ്യുക.
ചെറുതായി തുടങ്ങുക:
- യൂണിറ്റ് ടെസ്റ്റ്: ഇമെയിലുകൾ വാലിഡേറ്റ് ചെയ്യുന്ന അല്ലെങ്കിൽ ടോട്ടലുകൾ കണക്കാക്കുന്ന ഒരു സർവീസ് ഫംഗ്ഷൻ.
- ഇന്റഗ്രേഷൻ ടെസ്റ്റ്: ഒരു ടെസ്റ്റ് DB ഉപയോഗിച്ച്
/api/users വിളിക്കുക.
CI-യെ പുൾ റിക്വസ്റ്റുകളിൽ ടെസ്റ്റുകൾ റൺ ചെയ്യാൻ വയർ ചെയ്യുക. റെഡ് ടെസ്റ്റുകളുള്ള PR മെർജ് ചെയ്യരുത്. നിങ്ങൾക്ക് ഇന്ന് ആയിരം ടെസ്റ്റുകൾ ആവശ്യമില്ല—പ്രധാനപ്പെട്ട വഴികൾ മാത്രം മതി. സീറ്റ് ബെൽറ്റുകൾ പോലെ.
ഘട്ടം 9: പ്രൊഡക്ഷനിലേക്ക് പ്രൊമോട്ട് ചെയ്യുക (ശ്രദ്ധയോടെ)
- ഒരു മണിക്കൂർ നേരത്തേക്ക് മെയിൻ ഫ്രീസ് ചെയ്യുക. ആദ്യം സ്റ്റേജിംഗിലേക്ക് ഫിക്സുകൾ ഇറക്കുക.
- ബിൽഡ് പ്രൊമോട്ട് ചെയ്യുക. പോസ്റ്റ്-ഡിപ്ലോയ് സ്മോക്ക് ടെസ്റ്റ് റൺ ചെയ്യുക.
- പബ്ലിക് എൻഡ്പോയിന്റുകളിൽ റേറ്റ് ലിമിറ്റിംഗ് എനേബിൾ ചെയ്യുക.
- നിങ്ങൾ കാഷെ ചെയ്യുകയാണെങ്കിൽ, TTL-കൾ സെറ്റ് ചെയ്യുക. നിങ്ങൾ കാഷെ ചെയ്യുന്നില്ലെങ്കിൽ, നിങ്ങളുടെ DB നിങ്ങളെ ക്ഷീണിച്ച കണ്ണുകളോടെ നോക്കാൻ തയ്യാറെടുക്കുക.
ഒരു റോൾബാക്ക് പ്ലാൻ ചേർക്കുക: ഒരെണ്ണം ഉണ്ടാക്കുന്നതിലൂടെ നിങ്ങൾ അതിനെ ശപിക്കുന്നില്ല. നിങ്ങൾ ഒരു മുതിർന്ന വ്യക്തിയായി പെരുമാറുകയാണ്.
ഒരു ലളിതമായ, യഥാർത്ഥ ബാക്കെൻഡ്, നിങ്ങൾക്ക് ഉച്ചകഴിഞ്ഞ് ഷിപ്പ് ചെയ്യാൻ കഴിയും
ഒരു ചെറിയ—എന്നാൽ യഥാർത്ഥ—ഫീച്ചർ സെറ്റ് ഉണ്ടാക്കാം:
- പബ്ലിക്
GET /api/hello (ആരോഗ്യവും കൃത്യതയും).
- പ്രൊട്ടക്റ്റഡ്
POST /api/users (ഉപയോക്താവിനെ ഉണ്ടാക്കുക), GET /api/me (auth ചെയ്ത ഉപയോക്താവിനെ നൽകുന്നു).
GET /api/users/:id ഡയറക്ട് ലുക്കപ്പുകൾക്ക്.
- സോഫ്റ്റ് ഡിലീറ്റ്:
DELETE /api/users/:id deleted_at ടോഗിൾ ചെയ്യുന്നു.
/api/auth/login-ൽ റേറ്റ് ലിമിറ്റിംഗ് ചേർക്കുക, അതിനാൽ ബോട്ടുകൾ നിങ്ങളുടെ ബാക്കെൻഡ് കാർഡിയോ വ്യായാമത്തിനായി ഉപയോഗിക്കില്ല.
തുടർന്ന് നിങ്ങളുടെ ഇമെയിൽ പ്രൊവൈഡർ വഴി ഒരു വെൽക്കം ഇമെയിൽ അയക്കുക. സന്ദേശം ട്രാൻസാക്ഷണൽ ആയും സൗഹൃദപരമായും സൂക്ഷിക്കുക—മാർക്കറ്റിംഗ് റൂട്ടുകൾക്ക് വേണ്ടി മാർക്കറ്റിംഗ് മാറ്റിവയ്ക്കുക.
Lovable Cloud ഉപയോഗിച്ച് ഒരു ബാക്കെൻഡ് ഉണ്ടാക്കുമ്പോൾ ഉണ്ടാകുന്ന സാധാരണ കെണികൾ
- സെർവർലെസ്സിൽ ഷെയർഡ് സ്റ്റേറ്റ്: ഇൻവോക്കേഷനുകൾക്കിടയിൽ ഇൻ-മെമ്മറി കാഷെകളെ ആശ്രയിക്കരുത്. Redis (മാനേജ്ഡ്) അല്ലെങ്കിൽ നിങ്ങളുടെ DB ഉപയോഗിക്കുക.
- CORS കോൺഫിഗറേഷൻ നഷ്ടമാകുന്നത്: അനുവദനീയമായ ഒറിജിനുകൾ സെറ്റ് ചെയ്യുക. നിങ്ങളുടെ ആപ്പിന്റെ ഡൊമെയ്നുകളിലേക്ക് പരിമിതപ്പെടുത്തുക. പ്രൊഡക്ഷനിൽ വൈൽഡ്കാർഡ് ഉപയോഗിക്കരുത്.
- നീണ്ട കോൾഡ് സ്റ്റാർട്ടുകൾ: ഡിപൻഡൻസികൾ കൃത്യമായി ബണ്ടിൽ ചെയ്യുക, ഓരോ ഫംഗ്ഷന്റെയും ബ്ലോട്ട് കുറയ്ക്കുക അല്ലെങ്കിൽ ഹോട്ട് പാതകൾ ഏകീകരിക്കുക.
- ഇൻഡെക്സ് ചെയ്യാത്ത ക്വറികൾ: നിങ്ങളുടെ
GET /api/users ഇഴയുകയാണെങ്കിൽ, email-ലും created_at-ലും ഒരു ഇൻഡെക്സ് ചേർക്കുക. നിങ്ങളുടെ ഭാവി നിങ്ങൾക്കു നന്ദി പറയും.
- നിശബ്ദമായ പരാജയങ്ങൾ: എപ്പോഴും കോൺടെക്സ്റ്റ് സഹിതം എററുകൾ ലോഗ് ചെയ്യുക. “എന്തോ തകരാറിലായി” എന്നത് DevOps കവിതയല്ല.
പിന്നീട് കരയാതിരിക്കാൻ കോഡ് എങ്ങനെ ഘടന ചെയ്യാം
routes/ എൻഡ്പോയിന്റുകൾക്ക്
services/ ബിസിനസ് ലോജിക്കിന്
repositories/ അല്ലെങ്കിൽ db/ ഡാറ്റ ആക്സസ് ചെയ്യാൻ
middlewares/ auth, റേറ്റ് ലിമിറ്റ്, ഇൻപുട്ട് വാലിഡേഷന്
lib/ ഹെൽപ്പേഴ്സിനു (ഇമെയിൽ, ക്രിപ്റ്റോ, മൂന്നാം കക്ഷി API-കൾ)
സാധ്യമെങ്കിൽ ഫംഗ്ഷനുകൾ പ്യുവറായി സൂക്ഷിക്കുക. സൈഡ് ഇഫക്റ്റുകൾ അരികുകളിൽ വെക്കുക. ഇത് ടെസ്റ്റിംഗ് എളുപ്പമാക്കുകയും ഡീബഗ്ഗിംഗ് ഒരു ക്രൈം ഷോ പോലെ തോന്നാതിരിക്കാനും സഹായിക്കും.
ശരിക്കും പ്രധാനപ്പെട്ട പെർഫോമൻസ് ട്വീക്കുകൾ
- ഏത് ലിസ്റ്റ് എൻഡ്പോയിന്റിലും പേജിനേഷൻ ഉപയോഗിക്കുക. വലിയ ഡാറ്റാസെറ്റുകൾ ഉണ്ടെങ്കിൽ കർസർ അടിസ്ഥാനമാക്കിയുള്ള പേജിനേഷൻ ഉപയോഗിക്കുക.
- ഓരോ അഭ്യർത്ഥനയിലും എല്ലാം വീണ്ടും അയക്കുന്നത് ഒഴിവാക്കാൻ ETags അല്ലെങ്കിൽ ലാസ്റ്റ്-മോഡിഫൈഡ് ഹെഡറുകൾ ചേർക്കുക.
- ചിലവേറിയ ക്വറികൾക്കായി കമ്പ്യൂട്ട് ചെയ്ത പ്രതികരണങ്ങൾ കാഷെ ചെയ്യുക.
- സാധിക്കുമ്പോഴെല്ലാം റൈറ്റുകൾ ബാച്ച് ചെയ്യുക. N+1 ക്വറികൾ ബാക്കെൻഡ് ബഗുകളുടെ ഗ്ലിറ്റർ പോലെയാണ്—അവ എല്ലായിടത്തും ഉണ്ടാകും.
നിങ്ങൾക്ക് അവഗണിക്കാൻ കഴിയാത്ത സുരക്ഷാ അടിസ്ഥാനകാര്യങ്ങൾ (നിങ്ങൾ ആഗ്രഹിച്ചാൽ പോലും)
- ഓരോ റൂട്ടിലും ഇൻപുട്ട് വാലിഡേറ്റ് ചെയ്യുക. JSON സ്കീമ അല്ലെങ്കിൽ ഒരു വാലിഡേഷൻ ലൈബ്രറി എന്നിവ ഉപയോഗിച്ച് അപ്രതീക്ഷിതമായ ആക്രമണങ്ങളെ തടയാം.
- Argon2 അല്ലെങ്കിൽ bcrypt ഉപയോഗിച്ച് പാസ്വേഡുകൾ ഹാഷ് ചെയ്യുക. ഒരിക്കലും സ്വന്തമായി ക്രിപ്റ്റോ ഉണ്ടാക്കരുത്. ഒരിക്കലുമില്ല. ദയവായി.
- ഒരു ഷെഡ്യൂളിൽ കീകൾ, രഹസ്യങ്ങൾ എന്നിവ മാറ്റുക. ലംഘനങ്ങളെക്കാൾ വിലകുറഞ്ഞതാണ് കലണ്ടർ റിമൈൻഡറുകൾ.
- ഏറ്റവും കുറഞ്ഞ privilege ഉള്ള ഡാറ്റാബേസ് റോളുകൾ ഉപയോഗിക്കുക. നിങ്ങളുടെ API-ക്ക് സൂപ്പർ യൂസർ അധികാരങ്ങൾ ആവശ്യമില്ല—ആർക്കും ആവശ്യമില്ല.
വിലയിരുത്തൽ: വളർച്ചയ്ക്ക് വേണ്ടി പ്ലാൻ ചെയ്യുക, നെഞ്ചെരിച്ചിലിനല്ല
സെർവർലെസ് സൗജന്യമാണെന്ന് തോന്നും... അത് അല്ലാതാകുന്നതുവരെ. നിരീക്ഷിക്കുക:
- ട്രാഫിക് കൂടുമ്പോൾ കോൾഡ് സ്റ്റാർട്ട് പ്രശ്നങ്ങൾ.
- സംസാരിക്കുന്ന API-കൾക്കുള്ള എഗ്രസ് ചെലവുകൾ.
- ബാക്ക്ഗ്രൗണ്ട് ജോലികളായി പ്രവർത്തിക്കേണ്ട ദീർഘകാല ഫംഗ്ഷനുകൾ.
ബഡ്ജറ്റുകളും അലേർട്ടുകളും സെറ്റ് ചെയ്യുക. നിങ്ങളുടെ CFO ഒരു തീയുടെ ഇമോജി ടെക്സ്റ്റ് ചെയ്താൽ, അത് വൈകിപ്പോയി എന്ന് കരുതുക.
നിങ്ങൾക്ക് ഡോക്യുമെന്റുകളും, ഉദാഹരണങ്ങളും, ഒരു ഉറപ്പുവരുത്തലും ആവശ്യമായി വരുമ്പോൾ
ഞാൻ രണ്ട് സത്യങ്ങളിൽ വിശ്വസിച്ച് ജീവിക്കുന്നു: നിങ്ങൾ ഒരു കാര്യം എങ്ങനെ കോൺഫിഗർ ചെയ്തു എന്ന് മറന്നുപോകും, നിങ്ങൾ അത് വീണ്ടും രാത്രി 11 മണിക്ക് സെറ്റ് ചെയ്യേണ്ടി വരും. നിങ്ങളുടെ റിപ്പോസിറ്ററിയിൽ ഒരു README സൂക്ഷിക്കുക:
- എൻവയോൺമെൻ്റ് സെറ്റപ്പ് സ്റ്റെപ്പുകൾ
- സാധാരണ കമാൻഡുകൾ (മൈഗ്രേഷനുകൾ, ടെസ്റ്റുകൾ, ഡിപ്ലോയ്)
- ഉദാഹരണ അഭ്യർത്ഥനകളുള്ള എൻഡ്പോയിന്റ് ലിസ്റ്റ്
മൂന്ന് മാസത്തിനുള്ളിലെ പുതിയ നിങ്ങൾക്കോ—അല്ലെങ്കിൽ അടുത്ത ആഴ്ചയിലെ പുതിയ ടീംമേറ്റിനോ ഇത് എളുപ്പമാക്കുക.
ശ്രദ്ധിക്കേണ്ടത്: ഗവേഷണത്തിനും കോഡ് അവലോകനങ്ങൾക്കുമുള്ള ഒരു കുറുക്കുവഴി
ശ്രദ്ധിക്കുക: നിങ്ങൾക്ക് ആർക്കിടെക്ചർ ചോയിസുകളിൽ ഒരു അഭിപ്രായം അറിയണമെങ്കിൽ അല്ലെങ്കിൽ മികച്ച രീതികൾ താരതമ്യം ചെയ്യാൻ ആഗ്രഹമുണ്ടെങ്കിൽ, Sider.AI നിങ്ങളുടെ പ്ലാൻ അവലോകനം ചെയ്യുന്ന, പ്രശ്നങ്ങളെക്കുറിച്ച് ചൂണ്ടിക്കാണിക്കുന്ന, നിങ്ങൾ ഷിപ്പ് ചെയ്യുന്നതിന് മുമ്പ് ഒരു ചെക്ക്ലിസ്റ്റ് നൽകുന്ന ഒരു ടീംമേറ്റ് പോലെ പ്രവർത്തിക്കും. ഇത് നിങ്ങൾക്കായി Deploy-ൽ ക്ലിക്ക് ചെയ്യില്ല—പക്ഷേ “അയ്യോ” എന്ന സ്ലാക്ക് ത്രെഡ് ഒഴിവാക്കാൻ ഇത് നിങ്ങളെ സഹായിക്കും. ദ്രുത റഫറൻസ്: നിങ്ങളുടെ Lovable Cloud ബാക്കെൻഡ് ചെക്ക്ലിസ്റ്റ്
- പ്രോജക്റ്റ് ഉണ്ടാക്കി, Git സെറ്റ് ചെയ്തു, ബ്രാഞ്ച് തന്ത്രം
- JSON നൽകുന്ന ഹലോ എൻഡ്പോയിന്റ്
- ഡാറ്റാബേസ് പ്രൊവിഷൻ ചെയ്തു, മൈഗ്രേഷൻ റൺ ചെയ്തു, ORM കണക്ട് ചെയ്തു
- Auth സ്ഥാപിച്ചു, എൻവയോൺമെൻ്റ് മാനേജറിൽ രഹസ്യങ്ങൾ
- സ്റ്റേജിംഗ് ഡിപ്ലോയ് ചെയ്തു, ലോഗുകൾ ക്ലീൻ ആണ്, പ്രൊട്ടക്റ്റഡ് റൂട്ടുകൾ പ്രവർത്തിക്കുന്നു
- മോണിറ്ററിംഗ്, അലേർട്ടുകൾ, അടിസ്ഥാന ഡാഷ്ബോർഡുകൾ
- ടെസ്റ്റുകൾ CI-യിലേക്ക് വയർ ചെയ്തു, റെഡ് PR-കളില്ല
- റേറ്റ് ലിമിറ്റിംഗും റോൾബാക്ക് പ്ലാനുമുള്ള പ്രൊഡക്ഷൻ റോൾഔട്ട്
ഇത് നിങ്ങളുടെ മോണിറ്ററിൽ ഒട്ടിക്കുക. അല്ലെങ്കിൽ ടാറ്റൂ ചെയ്യുക. (ദയവായി ടാറ്റൂ ചെയ്യരുത്.)
ചുരുക്കം: ഇത് മടുപ്പിക്കുന്നതാക്കുക (നല്ല രീതിയിൽ)
ഒരു ഇഷ്ടപ്പെടുന്ന ബാക്കെൻഡ് നിങ്ങൾ ഉറങ്ങുമ്പോൾ നിശബ്ദമായി അതിന്റെ ജോലി ചെയ്യുന്ന ഒന്നാണ്. HTTP എൻഡ്പോയിന്റുകൾ, ക്ലീൻ auth, ഉറപ്പുള്ള ഡാറ്റാബേസ്, സെൻസിബിൾ ഡിപ്ലോയ്മെൻ്റ് എന്നിവ ഉപയോഗിച്ച് ഉണ്ടാക്കുക. Lovable Cloud, കാര്യമായ ഭാഗങ്ങളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ നിങ്ങളെ സഹായിക്കുന്നു—നിങ്ങളുടെ ഉൽപ്പന്നം, നിങ്ങളുടെ ഉപയോക്താക്കൾ, ഒരുപക്ഷേ നിങ്ങൾ ഒഴിവാക്കിയ ആ കാപ്പി പോലും.
/hello ഷിപ്പ് ചെയ്യുക. /users ചേർക്കുക. സ്ക്രൂകൾ മുറുക്കുക. എന്നിട്ട് നിങ്ങളുടെ ബാക്കെൻഡ് പ്രവർത്തിക്കുമ്പോൾ അക്ഷരാർത്ഥത്തിൽ മറ്റെന്തെങ്കിലും ചെയ്യൂ. അത് ഇഷ്ടപ്പെടുന്നതിലൂടെ ജീവിക്കുകയാണ്.
ചെറിയ ചോദ്യോത്തരങ്ങൾ: യഥാർത്ഥ ലോക സാഹചര്യങ്ങൾ
എനിക്ക് ഒരേ പ്രോജക്റ്റിൽ പബ്ലിക്, പ്രൈവറ്റ് API-കൾ മിക്സ് ചെയ്യാൻ കഴിയുമോ?
അതെ. പ്രൈവറ്റ് റൂട്ടുകൾ നിയന്ത്രിക്കാൻ മിഡിൽവെയർ ഉപയോഗിക്കുക, മെഷീൻ-ടു-മെഷീൻ ട്രാഫിക്കിനായി ടോക്കണുകൾ/കീകൾ വേർതിരിക്കുക. സ്കോപ്പുകൾ കർശനമായി സൂക്ഷിക്കുക.
എനിക്ക് ബാക്ക്ഗ്രൗണ്ട് ജോലികൾ ആവശ്യമുണ്ടെങ്കിൽ എന്തുചെയ്യും?
ദീർഘകാല ജോലികൾക്കായി (ഇമെയിലുകൾ, റിപ്പോർട്ടുകൾ, സിങ്കുകൾ) ഷെഡ്യൂൾ ചെയ്ത അല്ലെങ്കിൽ ക്യൂ-ഡ്രിവൺ ഫംഗ്ഷനുകൾ ഉണ്ടാക്കുക. ന്യൂസ്ലെറ്ററുകൾ അയയ്ക്കാൻ ഉപയോക്താക്കളുടെ അഭ്യർത്ഥനകൾ തടസ്സപ്പെടുത്തരുത്.
സ്റ്റേജിംഗും പ്രൊഡും കൗമാരക്കാരെപ്പോലെ രഹസ്യങ്ങൾ കൈമാറ്റം ചെയ്യാതിരിക്കാൻ ഞാൻ എങ്ങനെ സൂക്ഷിക്കും?
എൻവയോൺമെൻ്റുകൾ വേർതിരിക്കുക. രഹസ്യങ്ങൾ വേർതിരിക്കുക. CI-യിൽ ഗാർഡ്റെയിലുകൾ വെക്കുക, അതിനാൽ സ്റ്റേജിംഗ് ക്രെഡൻഷ്യലുകൾ ഒരിക്കലും പ്രൊഡക്ഷൻ ബിൽഡുകളിലേക്ക് കടന്നുപോകാതിരിക്കാൻ ശ്രദ്ധിക്കുക.
എനിക്ക് ലളിതമായി ആരംഭിച്ച് പിന്നീട് മൈക്രോസർവീസുകളിലേക്ക് പോകാൻ കഴിയുമോ?
തീർച്ചയായും. വേഗതയ്ക്കായി മോണോലിത്തിഷ് ആയി തുടങ്ങുക. നിങ്ങളുടെ മെട്രിക്കുകൾ “ഇപ്പോൾ” എന്ന് പറയുമ്പോൾ ഹോട്ട് സ്പോട്ടുകൾ എക്സ്ട്രാക്റ്റ് ചെയ്യുക, ഒരു പോഡ്കാസ്റ്റ് “മൈക്രോസർവീസുകൾ നല്ലതാണ്” എന്ന് പറയുമ്പോൾ ചെയ്യരുത്.
അടുത്ത ഘട്ടങ്ങൾ: നിങ്ങളുടെ 30 മിനിറ്റ് പ്ലാൻ
- 5 മിനിറ്റ്: പ്രോജക്റ്റ് ഉണ്ടാക്കുക, ടെംപ്ലേറ്റ് തിരഞ്ഞെടുക്കുക
- 10 മിനിറ്റ്:
/api/hello ഉണ്ടാക്കുക, ഡാറ്റാബേസ് വയർ ചെയ്യുക, മൈഗ്രേഷൻ റൺ ചെയ്യുക
- 10 മിനിറ്റ്: JWT auth ചേർക്കുക,
POST /api/users സംരക്ഷിക്കുക
- 5 മിനിറ്റ്: സ്റ്റേജിംഗിലേക്ക് ഡിപ്ലോയ് ചെയ്യുക, സ്മോക്ക് ടെസ്റ്റ് റൺ ചെയ്യുക
അത്രയേയുള്ളൂ. നിങ്ങൾ ഇപ്പോൾ Lovable Cloud ഉപയോഗിച്ച് ഒരു ബാക്കെൻഡ് ഉണ്ടാക്കി. ഇത് പ്രവർത്തിക്കുന്നു. ഇത് സ്കെയിൽ ചെയ്യുന്നു. നിങ്ങളുടെ കാപ്പി വീണ്ടും ചൂടാക്കാൻ നിങ്ങൾക്ക് സമയമുണ്ട്.
FAQ
Q1:ഒരു ബാക്കെൻഡ് ഉണ്ടാക്കുന്ന തുടക്കക്കാർക്ക് Lovable Cloud നല്ലതാണോ?
അതെ—ഇതിന്റെ ടെംപ്ലേറ്റുകൾ, സെർവർലെസ് ഫംഗ്ഷനുകൾ, എൻവയോൺമെന്റ് മാനേജർ എന്നിവ ആദ്യത്തെ ബാക്കെൻഡിനെ ഭയമില്ലാത്തതാക്കുന്നു. ലളിതമായ REST API-ൽ ആരംഭിച്ച്, ഒരു ഡാറ്റാബേസ് ചേർത്ത്, auth ലെയർ ചെയ്യുക. ഒരു ഡാറ്റാ സെന്ററുമായി മല്ലിടാതെ തന്നെ നിങ്ങൾ യഥാർത്ഥ പാറ്റേണുകൾ പഠിക്കും.
Q2:പ്രൊഡക്ഷനായി എന്റെ Lovable Cloud ബാക്കെൻഡ് എങ്ങനെ സുരക്ഷിതമാക്കാം?
JWT അല്ലെങ്കിൽ OAuth ഉപയോഗിക്കുക, CORS ലോക്ക് ഡൗൺ ചെയ്യുക, എൻവയോൺമെന്റ് മാനേജറിൽ രഹസ്യങ്ങൾ സൂക്ഷിക്കുക. റേറ്റ് ലിമിറ്റുകൾ ചേർക്കുക, ഓരോ റൂട്ടിലും ഇൻപുട്ട് വാലിഡേറ്റ് ചെയ്യുക, കൂടാതെ ഉപയോക്താക്കൾക്ക് പ്രശ്നമുണ്ടാകുന്നതിന് മുമ്പ് കണ്ടെത്താനായി p95 ലേറ്റൻസി നിരീക്ഷിക്കുക.
Q3:REST API-കൾക്കായി Lovable Cloud-മായി ഏത് ഡാറ്റാബേസാണ് ഏറ്റവും നന്നായി പ്രവർത്തിക്കുന്നത്?
Prisma അല്ലെങ്കിൽ Drizzle പോലുള്ള ഒരു ORM ഉപയോഗിച്ച് മിക്ക ആപ്പുകൾക്കും PostgreSQL വിശ്വസനീയമായ തിരഞ്ഞെടുപ്പാണ്. ഇത് റിലേഷണൽ ഡാറ്റ, ട്രാൻസാക്ഷനുകൾ, ഇൻഡെക്സിംഗ് എന്നിവ പ്രശ്നങ്ങളില്ലാതെ കൈകാര്യം ചെയ്യുകയും ട്രാഫിക് വർദ്ധിക്കുന്നതിനനുസരിച്ച് സ്കെയിൽ ചെയ്യുകയും ചെയ്യുന്നു.
Q4:സെർവർലെസ് ബാക്കെൻഡുകളിൽ കോൾഡ് സ്റ്റാർട്ടുകളും പ്രകടനവും ഞാൻ എങ്ങനെ കൈകാര്യം ചെയ്യും?
ഡിപൻഡൻസികൾ കൃത്യമായി ബണ്ടിൽ ചെയ്യുക, നിർണായക പാതകൾക്ക് ഊഷ്മളത നൽകുക, ഒരു സേവനം മതിയാകുമ്പോൾ നൂറുകണക്കിന് ചെറിയ ഫംഗ്ഷനുകൾ ഒഴിവാക്കുക. കാഷിംഗും പേജിനേഷനും ചേർക്കുക, കൂടാതെ ശരിക്കും പ്രധാനപ്പെട്ട കാര്യങ്ങൾ ട്യൂൺ ചെയ്യാൻ p95 ലേറ്റൻസി നിരീക്ഷിക്കുക.
Q5:വ്യത്യസ്ത രഹസ്യങ്ങളും URL-കളുമുള്ള സ്റ്റേജിംഗും പ്രൊഡക്ഷനും എനിക്ക് ഡിപ്ലോയ് ചെയ്യാൻ കഴിയുമോ?
തീർച്ചയായും. വ്യത്യസ്ത എൻവയോൺമെന്റുകൾ ഉണ്ടാക്കുക, വ്യത്യസ്ത DATABASE_URL, JWT_SECRET, ഡൊമെയ്നുകൾ എന്നിവ സജ്ജമാക്കുക, ബിൽഡുകൾ മുന്നോട്ട് പ്രൊമോട്ട് ചെയ്യുക. ഇത് സുരക്ഷിതമായി ടെസ്റ്റ് ചെയ്യാനും റോൾബാക്കുകൾ വേദനയില്ലാത്തതാക്കാനും സഹായിക്കുന്നു.
