proxy-chain: ಪ್ರತಿ listener ಗೆ ಪ್ರತ್ಯೇಕ ಖಾತೆಗಳು ಮತ್ತು upstream ಗಳು

proxy-chain ಪ್ರತಿ ಆಲಿಸುವ ಪೋರ್ಟ್‌ಗೆ ಒಂದು Server ಉದಾಹರಣೆಯನ್ನು ಚಲಾಯಿಸಬಹುದು. ಆ listener ನ ನೀತಿಯನ್ನು ಅದರ ದೃಢೀಕರಣ ಕಾಲ್‌ಬ್ಯಾಕ್‌ನಲ್ಲಿ ಸೆರೆಹಿಡಿಯಿರಿ:

import { Server } from 'proxy-chain';

const listeners = [
  { port: 8001, user: userA, password: passwordA, upstream: upstreamA },
  { port: 8002, user: userB, password: passwordB, upstream: upstreamB },
];
const servers = listeners.map(rule => new Server({
  host: '127.0.0.1',
  port: rule.port,
  prepareRequestFunction: ({ username, password }) => ({
    requestAuthentication:
      username !== rule.user || password !== rule.password,
    upstreamProxyUrl: rule.upstream,
  }),
}));
await Promise.all(servers.map(server => server.listen()));

ಅಪ್ಲಿಕೇಶನ್ ತನ್ನ ಸಾಮಾನ್ಯ ಸಂರಚನೆಯ ಮೂಲಕ ಖಾತೆ ಮೌಲ್ಯಗಳು ಮತ್ತು upstream URL ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಪ್ರತಿ ಕಾಲ್‌ಬ್ಯಾಕ್ ತನ್ನದೇ ನಿಯಮವನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ, ಆದ್ದರಿಂದ ಪೋರ್ಟ್ 8001 ನಲ್ಲಿ ಖಾತೆಯನ್ನು ಸ್ವೀಕರಿಸುವುದು ಪೋರ್ಟ್ 8002 ನಲ್ಲಿ ಆ ಖಾತೆಯನ್ನು ಸ್ವೀಕರಿಸುವುದಿಲ್ಲ.

requestAuthentication true ಒಂದು Basic ಪ್ರಾಕ್ಸಿ ಸವಾಲನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ದೃಢೀಕರಣ ಅಗತ್ಯವಿದ್ದಾಗ, ಆ ವಿನಂತಿಗೆ upstreamProxyUrl ನಿರ್ಲಕ್ಷಿಸಲಾಗುತ್ತದೆ. ಯಶಸ್ವಿ ಒಳಬರುವ ಖಾತೆ ಮತ್ತು upstream ಖಾತೆ ಬೇರೆ ಬೇರೆ ಗುರುತುಗಳು.

ಪ್ರತಿ upstream ಗೆ ಬೆಂಬಲಿತ URL ಬಳಸಿ, ಅಗತ್ಯವಿದ್ದಾಗ ಸರಿಯಾಗಿ ಎನ್‌ಕೋಡ್ ಮಾಡಿದ ರುಜುವಾತುಗಳು ಸೇರಿದಂತೆ. ದೃಢೀಕರಣವಿಲ್ಲದ ಸಾರ್ವಜನಿಕ HTTP upstream ಗೆ HTTP ಪ್ರಾಕ್ಸಿ ಪಟ್ಟಿಯಿಂದ ಅಭ್ಯರ್ಥಿಯನ್ನು ಆಯ್ಕೆಮಾಡಿ ಮತ್ತು ರುಜುವಾತುಗಳಿಲ್ಲದೆ ಅದರ URL ರಚಿಸಿ. ಬಿಟ್ಟುಬಿಟ್ಟ upstream ಇನ್ನೊಂದು ಸ್ವಯಂಚಾಲಿತ ಪ್ರಾಕ್ಸಿ ಬದಲು ನೇರ ಫಾರ್ವರ್ಡಿಂಗ್ ಆಯ್ಕೆಮಾಡುತ್ತದೆ.

ಉದಾಹರಣೆ ಸ್ಥಳೀಯ ಕ್ಲೈಂಟ್‌ಗಳಿಗೆ loopback ಬೈಂಡ್ ಮಾಡುತ್ತದೆ. ಇನ್ನೊಂದು ಯಂತ್ರ ಸಂಪರ್ಕಿಸಬೇಕಾದಾಗ ಸಂಬಂಧಿತ ಪ್ರವೇಶ ನೀತಿಯೊಂದಿಗೆ ಉದ್ದೇಶಿತ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಬೈಂಡ್ ಮಾಡಿ.

ಸರ್ವರ್‌ಗಳನ್ನು ಅವುಗಳ ಕ್ಲೈಂಟ್‌ಗಳ ಕೆಲಸದ ಹೊರೆಗಾಗಿ ಜೀವಂತವಾಗಿರಿಸಿ. ಅವುಗಳ ಮಾಲೀಕರು ಸ್ಥಗಿತದ ಸಮಯದಲ್ಲಿ ಪ್ರತಿ ಸರ್ವರ್ ಅನ್ನು ಅದರ ಬೆಂಬಲಿತ ಮುಚ್ಚುವ ವಿಧಾನದ ಮೂಲಕ ಮುಚ್ಚಬೇಕು; ಉದಾಹರಣೆ ಆ ಅಪ್ಲಿಕೇಶನ್‌ನ ಪೂರ್ಣ ಜೀವನಚಕ್ರವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದಿಲ್ಲ.