mirror of https://github.com/diegosouzapw/OmniRoute.git synced 2026-09-21 06:12:17 +03:00

Files

Diego Rodrigues de Sa e Souza 8feea123bb feat(docs): mirror every docs/ page in all 65 locales (#14106 )

* feat(docs): mirror every docs/ page in all 65 locales

Extends the documentation mirrors from the 22-page core set (#13940) to
every Markdown page under docs/: 152 sources x 65 locales = 9,880 mirrors
(6,208 new), language bars rewritten for the full locale list, state
adopted so the blocking drift gate now covers all 152 pages.

run-translation.mjs: an oversized block made only of table rows or list
items (PROVIDER_REFERENCE.md 244-row table, FREE_TIERS.md 71-item list) is
cut at item boundaries and rejoined without a blank line — the single
16-40 KB request outlived the backend socket for verbose scripts. 48
older mirrors whose tables had lost rows were retranslated with --force.

* docs(i18n): refresh mirrors for the sources the base changed since the branch cut

Section-level retranslation of the 29 docs (and README.md) whose source
or mirrors moved on release/v3.8.51 during the run, then state adoption;
the drift gate is green again on the merged tree.

2026-09-18 13:16:46 -03:00

73 KiB

Raw Blame History

🌐 OmniRoute Proxy Guide (മലയാളം)

🌐 Languages: 🇺🇸 English · 🇪🇹 am · 🇸🇦 ar · 🇦🇿 az · 🇧🇬 bg · 🇧🇩 bn · 🇨🇿 cs · 🇩🇰 da · 🇩🇪 de · 🇬🇷 el · 🇪🇸 es · 🇪🇪 et · 🇮🇷 fa · 🇫🇮 fi · 🇫🇷 fr · 🇮🇪 ga · 🇮🇳 gu · 🇳🇬 ha · 🇮🇱 he · 🇮🇳 hi · 🇭🇷 hr · 🇭🇺 hu · 🇦🇲 hy · 🇮🇩 id · 🇳🇬 ig · 🇮🇹 it · 🇯🇵 ja · 🇬🇪 ka · 🇰🇭 km · 🇮🇳 kn · 🇰🇷 ko · 🇱🇹 lt · 🇱🇻 lv · 🇮🇳 mr · 🇲🇾 ms · 🇲🇹 mt · 🇲🇲 my · 🇳🇵 ne · 🇳🇱 nl · 🇳🇴 no · 🇮🇳 or · 🇮🇳 pa · 🇵🇭 phi · 🇵🇱 pl · 🇵🇹 pt · 🇧🇷 pt-BR · 🇷🇴 ro · 🇷🇺 ru · 🇱🇰 si · 🇸🇰 sk · 🇸🇮 sl · 🇷🇸 sr · 🇸🇪 sv · 🇰🇪 sw · 🇮🇳 ta · 🇮🇳 te · 🇹🇭 th · 🇹🇷 tr · 🇺🇦 uk-UA · 🇵🇰 ur · 🇺🇿 uz · 🇻🇳 vi · 🇳🇬 yo · 🇨🇳 zh-CN · 🇹🇼 zh-TW

ഭൗഗോളിക തടസ്സങ്ങൾ മറികടക്കുക, നിങ്ങളുടെ വ്യക്തിത്വം സംരക്ഷിക്കുക, ഏത് പ്രോക്സിയിലൂടെയും AI ട്രാഫിക് റൂട്ട് ചെയ്യുക — കോൺഫിഗറേഷൻ സങ്കീർണ്ണത ഒട്ടുമില്ലാതെ.

HTTP, HTTPS, അല്ലെങ്കിൽ SOCKS5 പ്രോക്സികളിലൂടെ അപ്സ്ട്രീം AI പ്രൊവൈഡർ ട്രാഫിക് റൂട്ട് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന, സമ്പൂർണ്ണ സവിശേഷതകളുള്ള ഒരു പ്രോക്സി മാനേജ്മെന്റ് സിസ്റ്റം OmniRoute-ൽ ഉൾപ്പെടുന്നു. നിങ്ങൾ തടയപ്പെട്ട ഒരു മേഖലയിലാണെങ്കിലും, IP റൊട്ടേഷൻ ആവശ്യമാണെങ്കിലും, അല്ലെങ്കിൽ രഹസ്യസ്വഭാവമുള്ള ഫിംഗർപ്രിന്റിംഗ് ആഗ്രഹിക്കുന്നുവെങ്കിലും — ഈ ഗൈഡ് എല്ലാം വിശദീകരിക്കുന്നു.

എന്തുകൊണ്ട് പ്രോക്സികൾ ഉപയോഗിക്കണം?

പല AI പ്രൊവൈഡർമാരും ഭൗഗോളിക മേഖലയുടെ അടിസ്ഥാനത്തിൽ ആക്സസ് നിയന്ത്രിക്കുന്നു. റഷ്യ, ചൈന, ഇറാൻ, ക്യൂബ, തുർക്കി എന്നിവിടങ്ങളിലെയും മറ്റ് രാജ്യങ്ങളിലെയും ഡെവലപ്പർമാർക്ക് ഇനിപ്പറയുന്നതുപോലുള്ള പിശകുകൾ നേരിടേണ്ടിവരുന്നു:

unsupported_country_region_territory

തടയപ്പെട്ട മേഖലകൾക്ക് പുറത്തുപോലും പ്രോക്സികൾ ഇനിപ്പറയുന്ന ആവശ്യങ്ങൾക്ക് പ്രയോജനകരമാണ്:

ഉപയോഗ സാഹചര്യം	വിവരണം
ഭൗഗോളിക തടസ്സം മറികടക്കൽ	തടയപ്പെട്ട രാജ്യങ്ങളിൽനിന്ന് OpenAI, Anthropic, Codex, Copilot എന്നിവ ആക്സസ് ചെയ്യുക
IP റൊട്ടേഷൻ	റേറ്റ് ലിമിറ്റിംഗ് ഒഴിവാക്കാൻ ഒന്നിലധികം IP-കളിലായി അഭ്യർത്ഥനകൾ വിതരണം ചെയ്യുക
സ്വകാര്യത	അപ്സ്ട്രീം പ്രൊവൈഡർമാരിൽനിന്ന് നിങ്ങളുടെ യഥാർഥ IP മറയ്ക്കുക
അനുസൃതത	നിർദ്ദിഷ്ട അധികാരപരിധികളിലൂടെ ട്രാഫിക് റൂട്ട് ചെയ്യുക
പരിശോധന	വ്യത്യസ്ത മേഖലകളിൽനിന്നുള്ള അഭ്യർത്ഥനകൾ അനുകരിക്കുക

ആർക്കിടെക്ചർ അവലോകനം

┌───────────────────────────────────────────────────────────────┐
│                       OmniRoute സെർവർ                        │
│                                                               │
│  ┌─────────────┐    ┌──────────────┐    ┌──────────────────┐  │
│  │ പ്രോക്സി     │    │ പ്രോക്സി      │    │ പ്രോക്സി         │  │
│  │ രജിസ്ട്രി    │───▶│ ഡിസ്പാച്ചർ    │───▶│ Fetch (undici)   │  │
│  │ (SQLite)    │    │ (കാഷ് ചെയ്തത്)│    │                  │  │
│  └─────────────┘    └──────────────┘    └────────┬─────────┘  │
│         ▲                                        │            │
│         │                                        ▼            │
│  ┌──────┴──────┐                        ┌──────────────────┐  │
│  │ 1proxy Sync │                        │ അപ്സ്ട്രീം       │  │
│  │ (സൗജന്യ പൂൾ)│                        │ പ്രൊവൈഡർ API      │  │
│  └─────────────┘                        └──────────────────┘  │
└───────────────────────────────────────────────────────────────┘

പ്രധാന ഘടകങ്ങൾ

ഘടകം	ഫയൽ	പങ്ക്
പ്രോക്സി രജിസ്ട്രി	`src/lib/db/proxies.ts`	പ്രോക്സി എൻട്രികൾക്കും സ്കോപ്പ് അസൈൻമെന്റുകൾക്കുമുള്ള CRUD
പ്രോക്സി ഡിസ്പാച്ചർ	`open-sse/utils/proxyDispatcher.ts`	കാഷിംഗോടുകൂടിയ `undici` ProxyAgent/SOCKS ഡിസ്പാച്ചറുകൾ സൃഷ്ടിക്കുന്നു
പ്രോക്സി Fetch	`open-sse/utils/proxyFetch.ts`	പ്രോക്സി ഡിസ്പാച്ചർ ഇൻജക്ഷനോടെ `fetch()` പൊതിയുന്നു
ക്രമീകരണ റൂട്ട്	`src/app/api/settings/proxy/route.ts`	പഴയ പ്രോക്സി കോൺഫിഗറേഷൻ API (GET/PUT/DELETE)
മാനേജ്മെന്റ് റൂട്ട്	`src/app/api/v1/management/proxies/route.ts`	രജിസ്ട്രി CRUD API (GET/POST/PATCH/DELETE)
1proxy DB	`src/lib/db/oneproxy.ts`	സൗജന്യ പ്രോക്സി മാർക്കറ്റ്പ്ലേസ് പെർസിസ്റ്റൻസ്

4-തല പ്രോക്സി സിസ്റ്റം

OmniRoute നാല് സ്വതന്ത്ര പരിധികളിൽ പ്രോക്സി കോൺഫിഗറേഷൻ പിന്തുണയ്ക്കുന്നു; മുൻഗണനാക്രമത്തിലാണ് ഇവ പരിഹരിക്കപ്പെടുന്നത്:

മുൻഗണനാ പരിഹാരക്രമം (ഏറ്റവും ഉയർന്നത് → ഏറ്റവും താഴ്ന്നത്):

  1. 🔵 അക്കൗണ്ട്/കണക്ഷൻ പ്രോക്സി  →  ഓരോ API കീയ്ക്കും / OAuth കണക്ഷനും
  2. 🟡 പ്രൊവൈഡർ പ്രോക്സി          →  ഓരോ പ്രൊവൈഡർക്കും (ഉദാ., എല്ലാ OpenAI ട്രാഫിക്കും)
  3. 🟠 കോംബോ പ്രോക്സി             →  ഓരോ കോംബോ/റൂട്ടിംഗ് കോൺഫിഗറേഷനും
  4. 🟢 ഗ്ലോബൽ പ്രോക്സി            →  എല്ലാ ട്രാഫിക്കും, എല്ലാ പ്രൊവൈഡർമാർക്കും

പരിഹാരം എങ്ങനെ പ്രവർത്തിക്കുന്നു

OmniRoute ഒരു അപ്സ്ട്രീം പ്രൊവൈഡറിലേക്ക് അഭ്യർത്ഥന അയയ്ക്കുമ്പോൾ, അത് resolveProxyForConnectionFromRegistry() വിളിക്കുകയും ഓരോ തലവും ക്രമത്തിൽ പരിശോധിക്കുകയും ചെയ്യുന്നു:

അക്കൗണ്ട്-തലം — ഈ നിർദ്ദിഷ്ട കണക്ഷൻ ID-യ്ക്ക് ഒരു പ്രോക്സി നൽകിയിട്ടുണ്ടോ?
പ്രൊവൈഡർ-തലം — ഈ പ്രൊവൈഡറിന് (ഉദാ., openai) ഒരു പ്രോക്സി നൽകിയിട്ടുണ്ടോ?
ഗ്ലോബൽ-തലം — ഒരു ഗ്ലോബൽ പ്രോക്സി കോൺഫിഗർ ചെയ്തിട്ടുണ്ടോ?
പ്രോക്സി ഇല്ല — പ്രൊവൈഡറിലേക്കുള്ള നേരിട്ടുള്ള കണക്ഷൻ.

ആദ്യം പൊരുത്തപ്പെടുന്നതാണ് തിരഞ്ഞെടുക്കപ്പെടുന്നത്. അതായത്, നിങ്ങൾക്ക് ഒരു ഗ്ലോബൽ പ്രോക്സിയെ ഫാൾബാക്കായി സജ്ജീകരിക്കാം; എന്നാൽ നിർദ്ദിഷ്ട പ്രൊവൈഡർമാർക്കോ കണക്ഷനുകൾക്കോ വേണ്ടി അതിനെ മറികടക്കാനും കഴിയും.

പ്രോക്സിയിലൂടെ കടന്നുപോകുന്നവ

ട്രാഫിക് തരം	പ്രോക്സി ചെയ്യുമോ?	കുറിപ്പുകൾ
ചാറ്റ് പൂർത്തീകരണങ്ങൾ	✅	എല്ലാ `/v1/chat/completions` അഭ്യർത്ഥനകളും
എംബെഡ്ഡിങ്ങുകൾ	✅	`/v1/embeddings`
ഇമേജ് ജനറേഷൻ	✅	`/v1/images/generations`
ഓഡിയോ (TTS/STT)	✅	`/v1/audio/*`
OAuth ടോക്കൺ എക്സ്ചേഞ്ച്	✅	`unsupported_country_region_territory` പരിഹരിക്കുന്നു
കണക്ഷൻ പരിശോധനകൾ	✅	"കണക്ഷൻ പരിശോധിക്കുക" ബട്ടൺ പ്രോക്സി ഉപയോഗിക്കുന്നു
ടോക്കൺ പുതുക്കൽ	✅	പശ്ചാത്തല OAuth പുതുക്കൽ
മോഡൽ സമന്വയം	✅	മോഡൽ ലിസ്റ്റിംഗും കണ്ടെത്തലും

പ്രോക്സി രജിസ്ട്രി (CRUD)

നിങ്ങളുടെ എല്ലാ പ്രോക്സികളും സംഭരിക്കുന്ന ഒരു SQLite പട്ടികയാണ് (proxy_registry) പ്രോക്സി രജിസ്ട്രി. ഓരോ പ്രോക്സിയിലും ഇനിപ്പറയുന്നവയുണ്ട്:

ഫീൽഡ്	തരം	വിവരണം
`id`	UUID	തനതായ ഐഡന്റിഫയർ
`name`	String	മനുഷ്യർക്ക് വായിച്ചറിയാവുന്ന ലേബൽ
`type`	String	പ്രോട്ടോക്കോൾ: `http`, `https`, `socks5`
`host`	String	പ്രോക്സി ഹോസ്റ്റ്നെയിം അല്ലെങ്കിൽ IP
`port`	Integer	പോർട്ട് നമ്പർ
`username`	String	ഓത്ത് ഉപയോക്തൃനാമം (സംഭരണത്തിൽ എൻക്രിപ്റ്റ് ചെയ്തത്)
`password`	String	ഓത്ത് പാസ്വേഡ് (സംഭരണത്തിൽ എൻക്രിപ്റ്റ് ചെയ്തത്)
`region`	String	ഭൂമിശാസ്ത്രപരമായ മേഖലാ ലേബൽ
`notes`	String	സ്വതന്ത്ര-ടെക്സ്റ്റ് കുറിപ്പുകൾ
`status`	String	`active` അല്ലെങ്കിൽ `inactive`
`source`	String	`manual` അല്ലെങ്കിൽ `oneproxy`

ഒരു പ്രോക്സി സൃഷ്ടിക്കൽ

ഡാഷ്ബോർഡ് വഴി:

Settings → Proxy എന്നതിലേക്ക് പോകുക
Add Proxy ക്ലിക്ക് ചെയ്യുക
തരം, ഹോസ്റ്റ്, പോർട്ട്, ഐച്ഛിക ഓത്ത് ക്രെഡൻഷ്യലുകൾ എന്നിവ പൂരിപ്പിക്കുക
സംരക്ഷിക്കുക

API വഴി:

curl -X POST http://localhost:20128/api/v1/management/proxies \
  -H "Content-Type: application/json" \
  -d '{
    "name": "US Proxy",
    "type": "http",
    "host": "proxy.example.com",
    "port": 8080,
    "username": "user",
    "password": "pass",
    "region": "US"
  }'

ഒരു പ്രോക്സി അപ്ഡേറ്റ് ചെയ്യൽ

curl -X PATCH http://localhost:20128/api/v1/management/proxies \
  -H "Content-Type: application/json" \
  -d '{
    "id": "proxy-uuid-here",
    "host": "new-proxy.example.com",
    "port": 9090
  }'

കുറിപ്പ്: ശൂന്യമല്ലാത്ത പകരക്കാരെ നിങ്ങൾ വ്യക്തമായി അയയ്ക്കുന്നില്ലെങ്കിൽ ക്രെഡൻഷ്യലുകൾ നിലനിർത്തപ്പെടും. username/password എന്നിവയ്ക്ക് ശൂന്യമായ സ്ട്രിങ്ങുകൾ അയയ്ക്കുന്നത് സംഭരിച്ച മൂല്യങ്ങൾ നിലനിർത്തും.

ഒരു പ്രോക്സി ഇല്ലാതാക്കൽ

# ഏതെങ്കിലും പരിധിയിലേക്ക് പ്രോക്സി നൽകിയിട്ടുണ്ടെങ്കിൽ പരാജയപ്പെടും
curl -X DELETE "http://localhost:20128/api/v1/management/proxies?id=proxy-uuid"

# നിർബന്ധിതമായി ഇല്ലാതാക്കുക (അസൈൻമെന്റുകളും നീക്കംചെയ്യുന്നു)
curl -X DELETE "http://localhost:20128/api/v1/management/proxies?id=proxy-uuid&force=1"

പ്രോക്സികളുടെ പട്ടിക ലഭ്യമാക്കൽ

curl "http://localhost:20128/api/v1/management/proxies?limit=50&offset=0"

പരിധികളിലേക്ക് പ്രോക്സികൾ നൽകൽ

# ഗ്ലോബൽ പരിധിയിലേക്ക് നൽകുക
curl -X PUT http://localhost:20128/api/settings/proxy \
  -H "Content-Type: application/json" \
  -d '{"level": "global", "proxy": {"type":"http","host":"proxy.example.com","port":8080}}'

# ഒരു നിർദ്ദിഷ്ട പ്രൊവൈഡറിന് നൽകുക
curl -X PUT http://localhost:20128/api/settings/proxy \
  -H "Content-Type: application/json" \
  -d '{"level": "provider", "id": "openai", "proxy": {"type":"socks5","host":"socks.example.com","port":1080}}'

# ഒരു നിർദ്ദിഷ്ട കണക്ഷൻ/കീയ്ക്ക് നൽകുക
curl -X PUT http://localhost:20128/api/settings/proxy \
  -H "Content-Type: application/json" \
  -d '{"level": "key", "id": "connection-uuid", "proxy": {"type":"http","host":"key-proxy.com","port":3128}}'

പ്രാബല്യത്തിലുള്ള പ്രോക്സി പരിഹരിക്കൽ

നൽകിയിരിക്കുന്ന ഒരു കണക്ഷനുവേണ്ടി ഏത് പ്രോക്സി ഉപയോഗിക്കുമെന്ന് പരിശോധിക്കുക:

curl "http://localhost:20128/api/settings/proxy?resolve=connection-uuid"

പരിഹരിച്ച പ്രോക്സിയെ അതിന്റെ തലവും (account, provider, അല്ലെങ്കിൽ global) ഉറവിടവും സഹിതം നൽകുന്നു.

ബൾക്ക് അസൈൻമെന്റ്

ഒരേ സമയം ഒന്നിലധികം പ്രൊവൈഡർമാർക്കോ കണക്ഷനുകൾക്കോ ഒരു പ്രോക്സി നൽകുക:

curl -X POST http://localhost:20128/api/v1/management/proxies/bulk-assign \
  -H "Content-Type: application/json" \
  -d '{
    "scope": "provider",
    "scopeIds": ["openai", "anthropic", "codex"],
    "proxyId": "proxy-uuid"
  }'

ഇമ്പോർട്ട്/എക്സ്പോർട്ട്

Backup/Restore സിസ്റ്റത്തിൽ പ്രോക്സികൾ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. നിങ്ങളുടെ OmniRoute കോൺഫിഗറേഷൻ എക്സ്പോർട്ട് ചെയ്യുമ്പോൾ:

Dashboard → Settings → Backup എന്നതിലേക്ക് പോകുക
Export ക്ലിക്ക് ചെയ്യുക — പ്രോക്സി രജിസ്ട്രിയും അസൈൻമെന്റുകളും ഉൾപ്പെടുത്തിയിരിക്കും
പുനഃസ്ഥാപിക്കാൻ, Import ക്ലിക്ക് ചെയ്ത് ബാക്കപ്പ് ഫയൽ അപ്ലോഡ് ചെയ്യുക

പ്രോക്സി രജിസ്ട്രി host+port അടിസ്ഥാനമാക്കിയുള്ള upsert-ഉം പിന്തുണയ്ക്കുന്നു — ഇതിനകം നിലവിലുള്ള ഒരു പ്രോക്സി (ഒരേ ഹോസ്റ്റും പോർട്ടും ഉള്ളത്) നിങ്ങൾ ഇമ്പോർട്ട് ചെയ്താൽ, പകർപ്പ് സൃഷ്ടിക്കുന്നതിന് പകരം അത് അപ്ഡേറ്റ് ചെയ്യും.

ലെഗസി മൈഗ്രേഷൻ

നിങ്ങൾ പഴയ പതിപ്പിൽ (registry-ക്ക് മുമ്പുള്ളത്) പ്രോക്സികൾ കോൺഫിഗർ ചെയ്തിട്ടുണ്ടെങ്കിൽ, OmniRoute അവയെ സ്വയമേവ മൈഗ്രേറ്റ് ചെയ്യും:

ലെഗസി key_value സ്റ്റോർ → proxy_registry + proxy_assignments

അപ്ഗ്രേഡ് ചെയ്ത ശേഷമുള്ള ആദ്യ സ്റ്റാർട്ടപ്പിൽ ഇത് ഒരിക്കൽ സംഭവിക്കും. വീണ്ടും പ്രവർത്തിപ്പിക്കാൻ migrateLegacyProxyConfigToRegistry({ force: true }) ഉപയോഗിക്കുക.

1proxy സൗജന്യ പ്രോക്സി മാർക്കറ്റ്പ്ലേസ്

🆕 @oyi77 സംഭാവന ചെയ്തത് — PR #1847 (Issue #1788)

ലോകമെമ്പാടുമുള്ള നൂറുകണക്കിന് സൗജന്യവും സാധൂകരിച്ചതുമായ പ്രോക്സികൾ ലഭ്യമാക്കുന്നതിനായി OmniRoute, 1proxy കമ്മ്യൂണിറ്റി പ്ലാറ്റ്ഫോമുമായി സംയോജിക്കുന്നു. സ്വന്തമായി പ്രോക്സി ഇൻഫ്രാസ്ട്രക്ചർ ഇല്ലാത്ത ഉപയോക്താക്കൾക്ക് ഇത് അനുയോജ്യമാണ്.

ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു

┌─────────────┐  സമന്വയിപ്പിക്കുക  ┌─────────────────┐  റൊട്ടേറ്റ് ചെയ്യുക  ┌──────────┐
│  1proxy API │ ────────────▶ │  proxy_registry  │ ────────────▶ │ ദാതാവ്   │
│  (ബാഹ്യം)   │   500 വരെ     │  source=oneproxy │ നിലവാരമനുസരിച്ച് │   API    │
└─────────────┘  പ്രോക്സികൾ    └─────────────────┘               └──────────┘

സമന്വയം — OmniRoute, 1proxy API-യിൽ നിന്ന് സാധൂകരിച്ച പ്രോക്സികൾ ലഭ്യമാക്കുന്നു
സംഭരണം — പ്രോക്സികൾ അതേ proxy_registry പട്ടികയിൽ source = 'oneproxy' ഉപയോഗിച്ച് സംരക്ഷിക്കുന്നു
ഫിൽട്ടർ — പ്രോട്ടോക്കോൾ, രാജ്യം, ഗുണനിലവാര സ്കോർ എന്നിവ അനുസരിച്ച് ഫിൽട്ടർ ചെയ്യുക
റൊട്ടേഷൻ — ഗുണനിലവാരം, റാൻഡം, അല്ലെങ്കിൽ ക്രമാനുഗത തന്ത്രങ്ങൾ ഉപയോഗിച്ച് മികച്ച പ്രോക്സി തിരഞ്ഞെടുക്കുക
സ്വയമേവ നിലവാരം കുറയ്ക്കൽ — പരാജയപ്പെട്ട പ്രോക്സികളുടെ ഗുണനിലവാര സ്കോർ കുറയ്ക്കുന്നു; പരിധിക്ക് താഴെയായാൽ → നിഷ്ക്രിയമായി അടയാളപ്പെടുത്തുന്നു

പ്രോക്സികൾ സമന്വയിപ്പിക്കൽ

ഡാഷ്ബോർഡ് വഴി:

Settings → 1proxy ടാബിലേക്ക് പോകുക
"Sync Now" ക്ലിക്ക് ചെയ്യുക
സ്ഥിതിവിവരക്കണക്കുകൾ കാണുക: ആകെ പ്രോക്സികൾ, സജീവമായവയുടെ എണ്ണം, ശരാശരി ഗുണനിലവാരം, രാജ്യം തിരിച്ചുള്ള വിശദാംശങ്ങൾ

API വഴി:

# സമന്വയം ആരംഭിക്കുക
curl -X POST http://localhost:20128/api/settings/oneproxy \
  -H "Content-Type: application/json" \
  -d '{}'

# പ്രതികരണം:
# { "success": true, "added": 127, "updated": 45, "failed": 2, "total": 172 }

പ്രോക്സികൾ ഫിൽട്ടർ ചെയ്യൽ

# പ്രോട്ടോക്കോൾ അനുസരിച്ച് ഫിൽട്ടർ ചെയ്യുക
curl "http://localhost:20128/api/settings/oneproxy?protocol=socks5"

# രാജ്യം അനുസരിച്ച് ഫിൽട്ടർ ചെയ്യുക
curl "http://localhost:20128/api/settings/oneproxy?countryCode=US"

# ഏറ്റവും കുറഞ്ഞ ഗുണനിലവാര സ്കോർ അനുസരിച്ച് ഫിൽട്ടർ ചെയ്യുക
curl "http://localhost:20128/api/settings/oneproxy?minQuality=80"

# ഫിൽട്ടറുകൾ സംയോജിപ്പിക്കുക
curl "http://localhost:20128/api/settings/oneproxy?protocol=http&countryCode=DE&minQuality=70"

പ്രോക്സി ഗുണനിലവാര സ്കോറുകൾ

ഓരോ 1proxy പ്രോക്സിയിലും മെറ്റാഡാറ്റ ഉൾപ്പെടുന്നു:

ഫീൽഡ്	വിവരണം
`qualityScore`	1proxy സാധൂകരണത്തിൽ നിന്നുള്ള 0-100 റേറ്റിംഗ്
`latencyMs`	അളന്ന നെറ്റ്വർക്ക് ലേറ്റൻസി
`anonymity`	`transparent`, `anonymous`, അല്ലെങ്കിൽ `elite`
`googleAccess`	പ്രോക്സിക്ക് Google സേവനങ്ങൾ ആക്സസ് ചെയ്യാനാകുമോ എന്നത്
`countryCode`	രണ്ട് അക്ഷരങ്ങളുള്ള ISO രാജ്യ കോഡ്
`lastValidated`	അവസാന സാധൂകരണത്തിന്റെ ടൈംസ്റ്റാമ്പ്

ഗുണനിലവാര സ്കോറുകൾ ചലനാത്മകമായി ക്രമീകരിക്കപ്പെടുന്നു:

പരാജയപ്പെട്ട അഭ്യർത്ഥനകൾ സ്കോർ 10 പോയിന്റ് കുറയ്ക്കുന്നു
സ്കോർ ≤10 ആയി കുറയുമ്പോൾ → പ്രോക്സി inactive ആയി അടയാളപ്പെടുത്തുന്നു
നിഷ്ക്രിയ പ്രോക്സികളെ റൊട്ടേഷനിൽ നിന്ന് ഒഴിവാക്കുന്നു

റൊട്ടേഷൻ തന്ത്രങ്ങൾ

# ഗുണനിലവാരമനുസരിച്ച് റൊട്ടേറ്റ് ചെയ്യുക (മികച്ച പ്രോക്സി ആദ്യം) — ഡിഫോൾട്ട്
curl -X POST http://localhost:20128/api/settings/oneproxy/rotate \
  -H "Content-Type: application/json" \
  -d '{"strategy": "quality"}'

# റാൻഡം റൊട്ടേഷൻ
curl -X POST http://localhost:20128/api/settings/oneproxy/rotate \
  -d '{"strategy": "random"}'

# ക്രമാനുഗതം (ഏറ്റവും മുമ്പ് സാധൂകരിച്ചതിനെ ആദ്യം)
curl -X POST http://localhost:20128/api/settings/oneproxy/rotate \
  -d '{"strategy": "sequential"}'

സർക്യൂട്ട് ബ്രേക്കർ

1proxy സമന്വയത്തിൽ ഒരു ബിൽറ്റ്-ഇൻ സർക്യൂട്ട് ബ്രേക്കർ ഉൾപ്പെടുന്നു:

തുടർച്ചയായി 5 സമന്വയ പരാജയങ്ങൾക്ക് ശേഷം, തുടർന്നുള്ള സമന്വയ ശ്രമങ്ങൾ തടയപ്പെടും
ഇങ്ങനെ റീസെറ്റ് ചെയ്യുക: resetOneproxyCircuitBreaker() അല്ലെങ്കിൽ സെർവർ പുനരാരംഭിക്കുക
സമന്വയ നില GET /api/settings/oneproxy?action=status എന്നതിൽ ലഭ്യമാണ്

1proxy പ്രോക്സികൾ മായ്ക്കൽ

# ഒരു 1proxy പ്രോക്സി ഇല്ലാതാക്കുക
curl -X DELETE "http://localhost:20128/api/settings/oneproxy?id=proxy-uuid"

# എല്ലാ 1proxy പ്രോക്സികളും മായ്ക്കുക (മാനുവൽ പ്രോക്സികൾക്ക് മാറ്റമുണ്ടാകില്ല)
curl -X DELETE "http://localhost:20128/api/settings/oneproxy?clearAll=1"

കണ്ടെത്തൽ ഒഴിവാക്കലും സ്റ്റെൽത്തും

OmniRoute ഒരു പ്രോക്സിയിലൂടെ ട്രാഫിക് റൂട്ട് ചെയ്യുക മാത്രമല്ല ചെയ്യുന്നത് — ട്രാഫിക് യഥാർഥമാണെന്ന് തോന്നിപ്പിക്കുകയും ചെയ്യുന്നു:

TLS ഫിംഗർപ്രിന്റ് സ്പൂഫിംഗ്

ബ്രൗസർ അല്ലാത്ത TLS ഹാൻഡ്ഷേക്കുകൾ അടയാളപ്പെടുത്തുന്ന ബോട്ട് കണ്ടെത്തൽ സംവിധാനങ്ങളെ മറികടന്ന്, ബ്രൗസറിന് സമാനമായ TLS ഫിംഗർപ്രിന്റുകൾ സൃഷ്ടിക്കാൻ wreq-js ഉപയോഗിക്കുന്നു.

CLI ഫിംഗർപ്രിന്റ് പൊരുത്തപ്പെടുത്തൽ

CLI ഫിംഗർപ്രിന്റ് ടോഗിൾ (Settings → Security) നേറ്റീവ് CLI ബൈനറികളുടെ (Claude Code, Codex മുതലായവ) കൃത്യമായ സിഗ്നേച്ചറുമായി പൊരുത്തപ്പെടുന്നതിന് HTTP ഹെഡറുകളുടെയും JSON ബോഡി ഫീൽഡുകളുടെയും ക്രമം പുനഃക്രമീകരിക്കുന്നു. ഇത് പ്രോക്സിക്ക് പുറമേ പ്രവർത്തിക്കുന്നു:

നിങ്ങളുടെ IP (തടഞ്ഞത്) → പ്രോക്സി IP (US) → പ്രൊവൈഡർ API
                         + TLS സ്പൂഫ്
                         + CLI ഫിംഗർപ്രിന്റ്

നിങ്ങൾക്ക് ഒരേസമയം IP മറയ്ക്കലും അഭ്യർത്ഥനയുടെ ആധികാരികതയും ലഭിക്കുന്നു.

പ്രോക്സി IP സംരക്ഷണം

ഡാഷ്ബോർഡിലെ വർണ്ണ-കോഡുചെയ്ത ബാഡ്ജുകൾ ഏത് പ്രോക്സി ലെവലാണ് സജീവമെന്ന് കാണിക്കുന്നു:

ബാഡ്ജ്	ലെവൽ	അർത്ഥം
🟢	ഗ്ലോബൽ	എല്ലാ ട്രാഫിക്കും ഈ പ്രോക്സിയിലൂടെ കടന്നുപോകുന്നു
🟡	പ്രൊവൈഡർ	ഈ പ്രൊവൈഡറിന്റെ ട്രാഫിക് മാത്രം പ്രോക്സി ചെയ്യുന്നു
🔵	കണക്ഷൻ	ഈ നിർദ്ദിഷ്ട കീ/അക്കൗണ്ട് ഈ പ്രോക്സി ഉപയോഗിക്കുന്നു

പരിശോധനയ്ക്കായി പരിഹരിച്ച പ്രോക്സി IP-യും ബാഡ്ജ് കാണിക്കുന്നു.

അപ്സ്ട്രീം പ്രോക്സി മോഡുകൾ

CLIProxyAPI പാറ്റേൺ ഉപയോഗിക്കുന്ന പ്രൊവൈഡറുകൾക്കായി, OmniRoute മൂന്ന് അപ്സ്ട്രീം പ്രോക്സി മോഡുകൾ പിന്തുണയ്ക്കുന്നു:

മോഡ്	വിവരണം
`native`	OmniRoute പ്രോക്സി റൂട്ടിംഗ് നേരിട്ട് കൈകാര്യം ചെയ്യുന്നു (ഡിഫോൾട്ട്)
`cliproxyapi`	ഒരു ബാഹ്യ CLIProxyAPI ഇൻസ്റ്റൻസിന് ചുമതല കൈമാറുന്നു
`fallback`	ആദ്യം നേറ്റീവ് രീതി പരീക്ഷിക്കുന്നു; പരാജയപ്പെട്ടാൽ CLIProxyAPI ഉപയോഗിക്കുന്നു

ഓരോ പ്രൊവൈഡറിനും പ്രത്യേകം കോൺഫിഗർ ചെയ്യുക:

curl -X PUT "http://localhost:20128/api/upstream-proxy/openai" \
  -H "Content-Type: application/json" \
  -d '{"mode": "native", "enabled": true}'

ഡാഷ്ബോർഡ് UI

Settings → Proxy ടാബ്

ഗ്ലോബൽ പ്രോക്സി കോൺഫിഗറേഷൻ (എല്ലാ ട്രാഫിക്കിനുമായി ഒരിക്കൽ സജ്ജീകരിക്കുക)
ഓരോ പ്രൊവൈഡറിനുമുള്ള പ്രോക്സി ഓവർറൈഡുകൾ
ഓരോ കണക്ഷനുമുള്ള പ്രോക്സി അസൈൻമെന്റുകൾ
കോൺഫിഗർ ചെയ്ത പ്രോക്സിയിലൂടെയുള്ള കണക്ഷൻ പരിശോധന
സജീവമായ പ്രോക്സി ലെവൽ കാണിക്കുന്ന വർണ്ണ-കോഡുചെയ്ത ബാഡ്ജുകൾ

Settings → 1proxy ടാബ്

സൗജന്യ പ്രോക്സികൾ ലഭ്യമാക്കുന്നതിനുള്ള ഇപ്പോൾ സമന്വയിപ്പിക്കുക ബട്ടൺ
സ്ഥിതിവിവരക്കണക്ക് കാർഡുകൾ: ആകെ, സജീവം, ശരാശരി ഗുണനിലവാരം, അവസാന സമന്വയം
ഫിൽട്ടറുകൾ: പ്രോട്ടോക്കോൾ, രാജ്യ കോഡ്, കുറഞ്ഞ ഗുണനിലവാരം
ഹോസ്റ്റ്, പ്രോട്ടോക്കോൾ, രാജ്യം, ഗുണനിലവാര സ്കോർ, ലേറ്റൻസി, അജ്ഞാതത്വം, Google ആക്സസ് എന്നിവയുള്ള പ്രോക്സി പട്ടിക
വിജയ/പരാജയ ട്രാക്കിംഗും തുടർച്ചയായ പരാജയങ്ങളുടെ എണ്ണവും ഉൾപ്പെടുന്ന സമന്വയ നില പാനൽ
എല്ലാ 1proxy എൻട്രികളും നീക്കം ചെയ്യുന്നതിനുള്ള എല്ലാം മായ്ക്കുക

API റഫറൻസ്

പ്രോക്സി ക്രമീകരണ API

മെത്തേഡ്	എൻഡ്പോയിന്റ്	വിവരണം
`GET`	`/api/settings/proxy`	പൂർണ്ണ പ്രോക്സി കോൺഫിഗറേഷൻ നേടുക
`GET`	`/api/settings/proxy?level=global`	ഗ്ലോബൽ പ്രോക്സി നേടുക
`GET`	`/api/settings/proxy?level=provider&id=openai`	പ്രൊവൈഡർ പ്രോക്സി നേടുക
`GET`	`/api/settings/proxy?resolve=connectionId`	പ്രാബല്യത്തിലുള്ള പ്രോക്സി പരിഹരിക്കുക
`PUT`	`/api/settings/proxy`	പ്രോക്സി കോൺഫിഗറേഷൻ അപ്ഡേറ്റ് ചെയ്യുക
`DELETE`	`/api/settings/proxy?level=provider&id=openai`	ലെവലിലുള്ള പ്രോക്സി നീക്കം ചെയ്യുക

പ്രോക്സി രജിസ്ട്രി API

മെത്തേഡ്	എൻഡ്പോയിന്റ്	വിവരണം
`GET`	`/api/v1/management/proxies`	എല്ലാ പ്രോക്സികളും പട്ടികപ്പെടുത്തുക
`GET`	`/api/v1/management/proxies?id=uuid`	ID ഉപയോഗിച്ച് പ്രോക്സി നേടുക
`GET`	`/api/v1/management/proxies?id=uuid&where_used=1`	പ്രോക്സി അസൈൻമെന്റുകൾ നേടുക
`POST`	`/api/v1/management/proxies`	പ്രോക്സി സൃഷ്ടിക്കുക
`PATCH`	`/api/v1/management/proxies`	പ്രോക്സി അപ്ഡേറ്റ് ചെയ്യുക
`DELETE`	`/api/v1/management/proxies?id=uuid`	പ്രോക്സി ഇല്ലാതാക്കുക
`DELETE`	`/api/v1/management/proxies?id=uuid&force=1`	നിർബന്ധിതമായി ഇല്ലാതാക്കുക
`POST`	`/api/v1/management/proxies/bulk-assign`	കൂട്ടമായി അസൈൻ ചെയ്യുക
`GET`	`/api/v1/management/proxies/assignments`	അസൈൻമെന്റുകൾ പട്ടികപ്പെടുത്തുക
`GET`	`/api/v1/management/proxies/health`	പ്രോക്സി ആരോഗ്യനിലയുടെ സ്ഥിതിവിവരക്കണക്കുകൾ

ടണലുകൾ API

ഒരു പ്രോക്സിയിലൂടെ ഔട്ട്ബൗണ്ട് ട്രാഫിക് റൂട്ട് ചെയ്യുന്നതിന് പകരം നിങ്ങളുടെ OmniRoute ഇൻസ്റ്റൻസിനെ പൊതു ഇന്റർനെറ്റിലേക്ക് (Cloudflare/ngrok/Tailscale) തുറന്നുകാട്ടുന്നതിനായി, TUNNELS_GUIDE.md കാണുക. ടണൽ REST API /api/tunnels/{cloudflared,ngrok,tailscale}/* എന്നതിന് കീഴിലാണ്; മുകളിൽ രേഖപ്പെടുത്തിയിരിക്കുന്ന ഔട്ട്ബൗണ്ട് പ്രോക്സി ശൃംഖലയിൽനിന്ന് ഇത് സ്വതന്ത്രമാണ്.

1proxy API

മെത്തേഡ്	എൻഡ്പോയിന്റ്	വിവരണം
`GET`	`/api/settings/oneproxy`	1proxy പ്രോക്സികൾ പട്ടികപ്പെടുത്തുക
`GET`	`/api/settings/oneproxy?action=stats`	സ്ഥിതിവിവരക്കണക്കുകളും സമന്വയ നിലയും നേടുക
`GET`	`/api/settings/oneproxy?action=status`	സമന്വയ നില മാത്രം നേടുക
`POST`	`/api/settings/oneproxy`	സമന്വയം ആരംഭിക്കുക
`POST`	`/api/settings/oneproxy/rotate`	അടുത്ത പ്രോക്സിയിലേക്ക് റൊട്ടേറ്റ് ചെയ്യുക
`DELETE`	`/api/settings/oneproxy?id=uuid`	ഒരെണ്ണം ഇല്ലാതാക്കുക
`DELETE`	`/api/settings/oneproxy?clearAll=1`	എല്ലാം മായ്ക്കുക

അപ്സ്ട്രീം പ്രോക്സി API

മെത്തേഡ്	എൻഡ്പോയിന്റ്	വിവരണം
`GET`	`/api/upstream-proxy/:providerId`	അപ്സ്ട്രീം പ്രോക്സി കോൺഫിഗറേഷൻ നേടുക
`PUT`	`/api/upstream-proxy/:providerId`	അപ്സ്ട്രീം പ്രോക്സി മോഡ് സജ്ജീകരിക്കുക
`DELETE`	`/api/upstream-proxy/:providerId`	അപ്സ്ട്രീം പ്രോക്സി കോൺഫിഗറേഷൻ നീക്കം ചെയ്യുക

പരിസ്ഥിതി വേരിയബിളുകൾ

വേരിയബിൾ	ഡിഫോൾട്ട്	വിവരണം
`ENABLE_SOCKS5_PROXY`	`true`	SOCKS5 പ്രോക്സി പിന്തുണ പ്രവർത്തനക്ഷമമാക്കുക (`.env.example`-ൽ ഡിഫോൾട്ട് `true`)

പ്രശ്നപരിഹാരം

"SOCKS5 പ്രോക്സി പ്രവർത്തനരഹിതമാണ്"

നിങ്ങളുടെ .env ഫയലിൽ ENABLE_SOCKS5_PROXY=true സജ്ജമാക്കി പുനരാരംഭിക്കുക.

പ്രോക്സി വഴിയുള്ള "socket hang up" പിശകുകൾ

നിഷ്ക്രിയ കണക്ഷനുകൾ വിച്ഛേദിക്കുന്ന വിലകുറഞ്ഞ പ്രോക്സികളിൽ ഇത് സാധാരണമാണ്. OmniRoute ഇതിനകം തന്നെ ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ കൈകാര്യം ചെയ്യുന്നു:

പ്രോക്സി കണക്ഷനുകളിൽ keep-alive പ്രവർത്തനരഹിതമാക്കുന്നു (keepAliveTimeout: 1)
pipelining പ്രവർത്തനരഹിതമാക്കുന്നു (pipelining: 0)
ആവർത്തിച്ചുള്ള handshakes ഒഴിവാക്കാൻ dispatchers കാഷ് ചെയ്യുന്നു

ഇത് തുടരുകയാണെങ്കിൽ, മറ്റൊരു പ്രോക്സി പരീക്ഷിക്കുക അല്ലെങ്കിൽ 1proxy rotation സവിശേഷത ഉപയോഗിക്കുക.

OAuth സമയത്ത് "unsupported_country_region_territory"

OAuth ഫ്ലോ ആരംഭിക്കുന്നതിന് മുമ്പ് പ്രോക്സി കോൺഫിഗർ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. കോൺഫിഗർ ചെയ്ത പ്രോക്സിയിലൂടെയാണ് OmniRoute OAuth token exchange റൂട്ട് ചെയ്യുന്നത്. ആദ്യം ഒരു global അല്ലെങ്കിൽ provider-level പ്രോക്സി സജ്ജമാക്കുക, തുടർന്ന് കണക്റ്റ് ചെയ്യുക.

പ്രോക്സി ഉപയോഗിക്കപ്പെടുന്നില്ല

റെസല്യൂഷൻ ക്രമം പരിശോധിക്കുക:

GET /api/settings/proxy?resolve=your-connection-id ഉപയോഗിച്ച് പരിശോധിച്ചുറപ്പിക്കുക
പ്രോക്സിയുടെ status, inactive അല്ലാതെ active ആണോയെന്ന് പരിശോധിക്കുക
പ്രോക്സി assignment scope നിങ്ങളുടെ കണക്ഷനുമായി പൊരുത്തപ്പെടുന്നുവെന്ന് ഉറപ്പാക്കുക

1proxy sync പരാജയപ്പെടുന്നു

sync status പരിശോധിക്കുക:

curl "http://localhost:20128/api/settings/oneproxy?action=status"

consecutiveFailures >= 5 ആണെങ്കിൽ, circuit breaker പ്രവർത്തിച്ചിട്ടുണ്ട്. റീസെറ്റ് ചെയ്യാൻ സെർവർ പുനരാരംഭിക്കുക, അല്ലെങ്കിൽ മാനുവൽ റീസെറ്റിനായി കാത്തിരിക്കുക.

ഡാറ്റാബേസ് സ്കീമ

`proxy_registry` പട്ടിക

CREATE TABLE proxy_registry (
  id TEXT PRIMARY KEY,
  name TEXT NOT NULL,
  type TEXT NOT NULL DEFAULT 'http',
  host TEXT NOT NULL,
  port INTEGER NOT NULL,
  username TEXT DEFAULT '',
  password TEXT DEFAULT '',
  region TEXT,
  notes TEXT,
  status TEXT DEFAULT 'active',
  source TEXT NOT NULL DEFAULT 'manual',    -- 'manual' or 'oneproxy'
  quality_score INTEGER,                     -- 0-100 (1proxy only)
  latency_ms INTEGER,                        -- milliseconds (1proxy only)
  anonymity TEXT,                            -- transparent/anonymous/elite
  google_access INTEGER DEFAULT 0,           -- can access Google? (1proxy)
  last_validated TEXT,                       -- ISO timestamp (1proxy)
  country_code TEXT,                         -- ISO 2-letter code (1proxy)
  created_at TEXT NOT NULL,
  updated_at TEXT NOT NULL
);

`proxy_assignments` പട്ടിക

CREATE TABLE proxy_assignments (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  proxy_id TEXT NOT NULL REFERENCES proxy_registry(id),
  scope TEXT NOT NULL,        -- 'global', 'provider', 'account', 'combo'
  scope_id TEXT,              -- provider ID, connection ID, or combo ID
  created_at TEXT NOT NULL,
  updated_at TEXT NOT NULL,
  UNIQUE(scope, scope_id)
);

പ്രോക്സി ആരോഗ്യ പരിശോധന (v3.8.16+)

OmniRoute-ന്റെ proxy fast-fail സംവിധാനം (src/lib/proxyHealth.ts) ഒരു ദ്രുത TCP കണക്ഷൻ പരിശോധനയിലൂടെ പ്രവർത്തനരഹിതമായ പ്രോക്സികളെ <2s-നുള്ളിൽ കണ്ടെത്തുകയും, തുടർന്ന് ഓരോ അഭ്യർത്ഥനയിലും അധിക ചെലവ് ഒഴിവാക്കാൻ ഫലം കാഷ് ചെയ്യുകയും ചെയ്യുന്നു.

ഇത് പ്രവർത്തിക്കുന്ന വിധം

അഭ്യർത്ഥന ──▶ ProxyHealthCache.get(url)
             │
             ├─ കാഷിൽ ലഭ്യവും പുതുമയുള്ളതുമാണോ?  ──▶ കാഷ് ചെയ്ത status മടക്കുക
             │
             └─ കാഷിൽ ഇല്ലേ / കാലഹരണപ്പെട്ടോ?  ──▶ host:port-ലേക്ക് TCP കണക്റ്റ് ചെയ്യുക
                                          (timeout: FAST_FAIL_TIMEOUT_MS)
                                          ──▶ HEALTH_CACHE_TTL_MS സമയത്തേക്ക് കാഷ് ചെയ്യുക
                                          ──▶ ഫലം മടക്കുക

ഇത് ഇല്ലെങ്കിൽ, പ്രവർത്തനരഹിതമായ ഒരു പ്രോക്സി പരാജയപ്പെടുന്നതിന് മുമ്പ് പൂർണ്ണമായ PROXY_TIMEOUT_MS സമയത്തേക്ക് (ഡിഫോൾട്ട് 30s) എല്ലാ അഭ്യർത്ഥനകളെയും തടയും.

ക്രമീകരിക്കാവുന്ന പരിസ്ഥിതി വേരിയബിളുകൾ

വേരിയബിൾ	ഡിഫോൾട്ട്	ഉദ്ദേശ്യം
`PROXY_FAST_FAIL_TIMEOUT_MS`	`2000`	ഓരോ ആരോഗ്യ പരിശോധനയ്ക്കുമുള്ള TCP കണക്ഷൻ timeout
`PROXY_HEALTH_CACHE_TTL_MS`	`30000`	ആരോഗ്യ പരിശോധനാ ഫലം എത്ര സമയം കാഷ് ചെയ്യണം

ശുപാർശ ചെയ്യുന്ന മൂല്യങ്ങൾ:

സാഹചര്യം	Fast-fail timeout	Cache TTL	കാരണം
ഉയർന്ന-throughput API gateway	1500ms	60000ms	വേഗത്തിൽ പരാജയം കണ്ടെത്തുന്നു; പരിശോധനകൾ കുറയ്ക്കാൻ കൂടുതൽ ദൈർഘ്യമുള്ള കാഷ്
ഭൂമിശാസ്ത്രപരമായി വിതരണം ചെയ്ത nodes	3000ms	15000ms	വേഗം കുറഞ്ഞ നെറ്റ്വർക്കുകൾക്ക് കൂടുതൽ സമയം ആവശ്യമാണ്; വേഗത്തിലുള്ള failover-നായി കുറഞ്ഞ കാഷ് കാലാവധി
Dev / testing	1000ms	10000ms	ലോക്കൽ പ്രോക്സികളിൽ വേഗത്തിലുള്ള iteration
Stealth / anti-detection	2500ms	45000ms	rate limits സജീവമാക്കാൻ സാധ്യതയുള്ള ദ്രുത probing ഒഴിവാക്കുന്നു

പ്രോക്സിയുടെ ആരോഗ്യം പരിശോധിക്കൽ

import { getAllProxyHealthStatuses, invalidateProxyHealth } from "omniroute/proxyHealth";

const statuses = getAllProxyHealthStatuses();
for (const s of statuses) {
  console.log(`${s.proxyUrl} → healthy=${s.healthy}, stale=${s.stale}`);
}

// ഒരു നിർദ്ദിഷ്ട പ്രോക്സിയുടെ പുനഃപരിശോധന നിർബന്ധിതമാക്കുക
invalidateProxyHealth("http://user:pass@203.0.113.7:8080");

കാഷ് എൻട്രി HEALTH_CACHE_TTL_MS കവിഞ്ഞിരിക്കുമ്പോൾ stale ഫ്ലാഗ് true ആയിരിക്കും; അടുത്ത അഭ്യർത്ഥന ഒരു പുതിയ പരിശോധന സജീവമാക്കും.

ഓരോ പ്രോക്സി തരത്തിനുമുള്ള ഡിഫോൾട്ടുകൾ

URL scheme അടിസ്ഥാനമാക്കി ആരോഗ്യ പരിശോധന യുക്തിസഹമായ ഡിഫോൾട്ടുകൾ ഉപയോഗിക്കുന്നു:

Scheme	ഡിഫോൾട്ട് port
`http://`	8080
`https://`	443
`socks5://` / `socks5h://`	1080

URL-ലെ custom ports (http://host:9999) എല്ലായ്പ്പോഴും scheme ഡിഫോൾട്ടിനേക്കാൾ മുൻഗണന നേടുന്നു.

പ്രോക്സി അനലിറ്റിക്സും നിരീക്ഷണക്ഷമതയും

റൂട്ടിംഗ് പാറ്റേണുകൾ, ലേറ്റൻസി വർധനകൾ, ആവർത്തിച്ചുള്ള പരാജയങ്ങൾ എന്നിവ കണ്ടെത്താൻ ഓപ്പറേറ്റർമാരെ സഹായിക്കുന്നതിനായി OmniRoute ഓരോ പ്രോക്സിയുടെയും ഉപയോഗം ട്രാക്ക് ചെയ്യുന്നു.

ട്രാക്ക് ചെയ്യുന്നവ

കോൺഫിഗർ ചെയ്ത പ്രോക്സിയിലൂടെയുള്ള ഓരോ അഭ്യർത്ഥനയ്ക്കും OmniRoute ഇനിപ്പറയുന്നവ രേഖപ്പെടുത്തുന്നു:

മെട്രിക്	വിവരണം
`proxy_url`	പൂർണ്ണ പ്രോക്സി URL (ഓതന്റിക്കേഷൻ ക്രെഡൻഷ്യലുകൾ മറച്ചത്)
`provider`	അപ്സ്ട്രീം പ്രൊവൈഡർ ID (openai, anthropic മുതലായവ)
`latency_ms`	പ്രോക്സി ഹാൻഡ്ഷേക്ക് ഉൾപ്പെടെയുള്ള ആകെ റൗണ്ട്-ട്രിപ്പ് സമയം
`connect_ms`	TCP കണക്ഷൻ സമയം മാത്രം
`status`	അപ്സ്ട്രീമിൽ നിന്നുള്ള HTTP സ്റ്റാറ്റസ് കോഡ്
`error`	അഭ്യർത്ഥന പരാജയപ്പെട്ടെങ്കിൽ പിശകിന്റെ ക്ലാസ്
`timestamp`	ISO 8601 UTC

ഡാറ്റ ആക്സസ് ചെയ്യുന്നത്

# സമീപകാല പ്രോക്സി ഇവന്റുകൾ
curl -H "Authorization: Bearer $OMNIROUTE_KEY" \
  "http://localhost:20128/api/usage/proxy-logs?limit=100"

യഥാർത്ഥ എൻഡ്പോയിന്റ് /api/usage/proxy-logs ആണ് (src/app/api/usage/proxy-logs/route.ts കാണുക). ഈ എൻഡ്പോയിന്റ് ഇനിപ്പറയുന്നവ പിന്തുണയ്ക്കുന്നു:

GET /api/usage/proxy-logs — പ്രോക്സി ലോഗുകൾ ലഭ്യമാക്കുക
DELETE /api/usage/proxy-logs — എല്ലാ പ്രോക്സി ലോഗുകളും മായ്ക്കുക

ആവശ്യമെങ്കിൽ, അഗ്രഗേറ്റ് സ്ഥിതിവിവരക്കണക്കുകൾ SQL ഉപയോഗിച്ച് proxy_logs പട്ടികയിൽ നിന്ന് നേരിട്ട് ക്വറി ചെയ്യാം. ഡാഷ്ബോർഡ് UI അഗ്രഗേറ്റ് കാഴ്ചകൾ നൽകിയേക്കാം.

സാധാരണ പാറ്റേണുകൾ

അസ്ഥിരമായ ഒരു പ്രോക്സി കണ്ടെത്തുക (വിജയത്തിനും പരാജയത്തിനും ഇടയിൽ മാറിമാറി വരുന്നത്):

SELECT proxy_url,
       COUNT(*) AS total,
       SUM(CASE WHEN status >= 500 THEN 1 ELSE 0 END) AS errors,
       ROUND(100.0 * SUM(CASE WHEN status >= 500 THEN 1 ELSE 0 END) / COUNT(*), 1) AS error_pct
FROM proxy_logs
WHERE timestamp > datetime('now', '-1 hour')
GROUP BY proxy_url
HAVING error_pct > 5
ORDER BY error_pct DESC;

വേഗത കുറഞ്ഞ പ്രോക്സികൾ കണ്ടെത്തുക (p95 ലേറ്റൻസി > 2s):

WITH ranked AS (
  SELECT proxy_url, latency_ms,
         PERCENT_RANK() OVER (PARTITION BY proxy_url ORDER BY latency_ms) AS pct
  FROM proxy_logs
  WHERE timestamp > datetime('now', '-24 hour')
)
SELECT proxy_url, latency_ms
FROM ranked
WHERE pct >= 0.95
ORDER BY latency_ms DESC;

റൊട്ടേഷൻ തന്ത്രത്തിനുള്ള തീരുമാനവൃക്ഷം

ഒന്നിലധികം പ്രോക്സികൾ ഒരു സ്കോപ്പിന് നൽകിയിരിക്കുമ്പോൾ, ഓരോ അഭ്യർത്ഥനയ്ക്കും ഏത് പ്രോക്സി ഉപയോഗിക്കണമെന്ന് തിരഞ്ഞെടുക്കാൻ OmniRoute ഒരു റൊട്ടേഷൻ തന്ത്രം ഉപയോഗിക്കുന്നു. തന്ത്രം സ്കോപ്പ് തലത്തിലാണ് കോൺഫിഗർ ചെയ്യുന്നത് (ആഗോളം, ഓരോ പ്രൊവൈഡറിനും, ഓരോ അക്കൗണ്ടിനും, ഓരോ കോമ്പോയ്ക്കും).

ലഭ്യമായ തന്ത്രങ്ങൾ

തന്ത്രം	എപ്പോൾ ഉപയോഗിക്കണം	വിട്ടുവീഴ്ച
`quality` (ഡിഫോൾട്ട്)	വ്യത്യസ്ത ഗുണനിലവാരമുള്ള പ്രോക്സികളോടെയുള്ള പ്രൊഡക്ഷൻ	ഉയർന്ന റേറ്റിംഗുള്ള പ്രോക്സികൾക്ക് മുൻഗണന നൽകുന്നു; കുറഞ്ഞ റേറ്റിംഗുള്ളവയ്ക്ക് അവസരം ലഭിക്കാതിരിക്കാം
`random`	ലോഡ് വിതരണം, സ്വകാര്യത	തുല്യമായ വിതരണം; ഗുണനിലവാര സൂചനകൾ അവഗണിക്കുന്നു
`sequential`	ഡീബഗ്ഗിംഗ്, നിർണായകമായ പരിശോധന	പ്രോക്സികളിലൂടെ ക്രമത്തിൽ ആവർത്തിക്കുന്നു; മനസ്സിലാക്കാൻ എളുപ്പമാണ്

തീരുമാനവൃക്ഷം

                    നിങ്ങളുടെ പ്രോക്സികൾക്ക് ഗുണനിലവാര സ്കോറുകൾ ഉണ്ടോ?
                    │
        ┌───────────┴───────────┐
        │                       │
       ഉണ്ട്                    ഇല്ല
        │                       │
   എല്ലാ പ്രോക്സികളും            │
   ഗുണനിലവാരത്തിൽ               │
   ഏകദേശം തുല്യമാണോ?            │
        │                       │
   ┌────┴────┐                  │
   │         │                  │
  അതെ       അല്ല              ഉപയോഗിക്കുക
   │         │              `random`
   │         │              (തുല്യമായ വിതരണം
   │         │              കാലക്രമേണ ഗുണനിലവാര
   │         │              ഡാറ്റ സൃഷ്ടിക്കുന്നു)
   │         │
   │    ഉപയോഗിക്കുക `quality`
   │    (വ്യത്യസ്ത ഗുണനിലവാരത്തിന്
   │    ഏറ്റവും അനുയോജ്യം)
   │
ഉപയോഗിക്കുക `random`
(ലോഡ് തുല്യമായി
വിതരണം ചെയ്യുക)

നിങ്ങളുടെ സ്വന്തം പ്രോക്സികൾക്കായുള്ള സ്വയമേവയുള്ള പരാജയ ഒഴിവാക്കൽ

1proxy മാർക്കറ്റ്പ്ലേസ് പൂൾ പരാജയപ്പെട്ട പ്രോക്സികളുടെ നിലവാരം ഇതിനകം തന്നെ സ്വയമേവ താഴ്ത്തുന്നു (പ്രോക്സി ഗുണനിലവാര സ്കോറുകൾ കാണുക). രജിസ്ട്രിയിൽ നിങ്ങൾ ചേർത്ത പ്രോക്സികൾക്കായി, പശ്ചാത്തല ഹെൽത്ത് ഷെഡ്യൂളർ (src/lib/proxyHealth/scheduler.ts) ഒന്നും ഇല്ലാതാക്കാതെ തന്നെ, "പ്രവർത്തനരഹിതമായ ഒരു അംഗത്തെ ചെയിനിൽനിന്ന് സ്വയമേവ ഒഴിവാക്കുക" എന്ന അതേ പ്രവർത്തനം നൽകുന്നു:

# .env — തുടർച്ചയായ 3 പരാജയപ്പെട്ട പരിശോധനകൾക്ക് ശേഷം ഒരു പ്രോക്സിയെ താൽക്കാലികമായി പ്രവർത്തനരഹിതമാക്കുകയും,
# പരിശോധനകളോട് വീണ്ടും പ്രതികരിക്കാൻ തുടങ്ങുമ്പോൾ അതിനെ സ്വയമേവ വീണ്ടും പ്രവർത്തനക്ഷമമാക്കുകയും ചെയ്യുക.
PROXY_AUTO_DISABLE=true
PROXY_AUTO_REMOVE_AFTER=3

ഒരു മൾട്ടി-പ്രോക്സി ചെയിനിൽ ഇത് പ്രവർത്തിക്കുന്ന വിധം:

ഷെഡ്യൂളർ രജിസ്റ്റർ ചെയ്ത ഓരോ പ്രോക്സിയെയും ഓരോ PROXY_HEALTH_INTERVAL_MS ഇടവേളയിലും പരിശോധിക്കുന്നു (സ്ഥിരസ്ഥിതി 10 മിനിറ്റ്; കുറഞ്ഞത് 1 മിനിറ്റ്).
തുടർച്ചയായ PROXY_AUTO_REMOVE_AFTER നിർണായകമായ പരാജയങ്ങൾക്ക് ശേഷം (യഥാർഥ കണക്ഷൻ പരാജയം — ടൈംഔട്ടോ പരിശോധനാ ലക്ഷ്യത്തിന്റെ സ്വന്തം 5xx-ഓ ഒരിക്കലും കണക്കാക്കില്ല; പ്രോക്സി ഹെൽത്ത് പരിശോധന കാണുക), പ്രോക്സിയുടെ status dead ആയി സജ്ജീകരിക്കുന്നു.
പൂൾ/റൊട്ടേഷൻ നിർണയത്തിൽ ഉപയോഗിക്കുന്ന സജീവ-സ്റ്റാറ്റസ് ഫിൽട്ടർ ഒഴിവാക്കുന്ന സ്റ്റാറ്റസുകളിൽ ഒന്നാണ് dead; അതിനാൽ ഒരു സ്കോപ്പിന്റെ റൊട്ടേഷൻ (റൗണ്ട്-റോബിൻ / റാൻഡം / സ്റ്റിക്കി / ലേറ്റൻസി — റൊട്ടേഷൻ തന്ത്രത്തിനായുള്ള തീരുമാനവൃക്ഷം കാണുക) പുതിയ അഭ്യർത്ഥനകൾക്ക് ആ പ്രോക്സി നൽകുന്നത് ഉടൻ നിർത്തുന്നു. പൂളിലെ മറ്റ് പ്രോക്സികളെയൊന്നും ഇത് ബാധിക്കില്ല; കൂടാതെ മുഴുവൻ പൂളും ഒരിക്കലും നിശ്ശബ്ദമായി നേരിട്ടുള്ള കണക്ഷനിലേക്ക് മടങ്ങുകയുമില്ല — ഫെയിൽ-ക്ലോസ്ഡ് സംരക്ഷണത്തെക്കുറിച്ച് 4-തല പ്രോക്സി സിസ്റ്റം കാണുക.
അതേ ഇടവേളയിൽ തന്നെ ഷെഡ്യൂളർ dead പ്രോക്സികളെ തുടർന്നും പരിശോധിക്കുന്നു. അടുത്ത വിജയകരമായ പരിശോധന status വീണ്ടും active ആക്കി മാറ്റുകയും പ്രോക്സി വീണ്ടും റൊട്ടേഷനിൽ പ്രവേശിക്കുകയും ചെയ്യുന്നു — സ്വമേധയാ വീണ്ടും ചേർക്കേണ്ടതില്ല.

ഇത് മനഃപൂർവം ഓപ്റ്റ്-ഇൻ രീതിയിലുള്ളതും നശിപ്പിക്കാത്തതുമാണ്: സ്ഥിരസ്ഥിതിയായി ഷെഡ്യൂളർ പരാജയങ്ങൾ എണ്ണുകയും ലോഗ് ചെയ്യുകയും മാത്രമാണ് ചെയ്യുന്നത് (decision.ts-ലെ പോളിസി C കാണുക); കൂടാതെ PROXY_AUTO_DISABLE ഒരിക്കലും ഒരു റോ ഇല്ലാതാക്കുന്നില്ല — അതിനായാണ് വേറിട്ടതും കൂടുതൽ ആക്രമണാത്മകവുമായ PROXY_AUTO_REMOVE ഫ്ലാഗ്. രണ്ടും true ആയി സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, PROXY_AUTO_REMOVE-നാണ് മുൻഗണന (ഇല്ലാതാക്കാൻ പോകുന്ന ഒരു പ്രോക്സിയെ അതിനിടയിൽ താൽക്കാലികമായി പ്രവർത്തനരഹിതമാക്കുന്നതിന് പ്രയോജനമില്ല). വേരിയബിളുകളുടെ പൂർണ്ണ ലിസ്റ്റിനായി പരിസ്ഥിതി കോൺഫിഗറേഷൻ റഫറൻസ് കാണുക.

📖 ബന്ധപ്പെട്ട ഡോക്യുമെന്റേഷൻ:

ഉപയോക്തൃ ഗൈഡ് — പൊതുവായ സജ്ജീകരണവും കോൺഫിഗറേഷനും

API റഫറൻസ് — സമ്പൂർണ്ണ API ഡോക്യുമെന്റേഷൻ

പരിസ്ഥിതി കോൺഫിഗറേഷൻ — എല്ലാ പരിസ്ഥിതി വേരിയബിളുകളും

73 KiB Raw Blame History