या GitHub `master` शाखा से```console
❯ pip install git+https://github.com/abhinavsingh/proxy.py.git@master

## Docker का उपयोग करना

मल्टी-प्लेटफॉर्म कंटेनर निम्नलिखित के माध्यम से उपलब्ध हैं:

- Docker Hub
  - `latest` टैग अंतिम `stable` रिलीज़ को इंगित करता है
  - `docker pull abhinavsingh/proxy.py:latest`
- GitHub container registry (GHCR)
  - `latest` टैग अंतिम `develop` रिलीज़ को इंगित करता है
  - `docker pull ghcr.io/abhinavsingh/proxy.py:latest`

स्थिर संस्करण कंटेनर रिलीज़ निम्नलिखित प्लेटफॉर्मों के लिए उपलब्ध हैं:

- `linux/386`
- `linux/amd64`
- `linux/arm/v6`
- `linux/arm/v7`
- `linux/arm64/v8`
- `linux/ppc64le`
- `linux/s390x`

### Docker Hub से स्थिर संस्करण

`proxy.py` नवीनतम कंटेनर चलाएँ:```console
❯ docker run -it -p 8899:8899 --rm abhinavsingh/proxy.py:latest

### GHCR से विकास संस्करण

`proxy.py` कंटेनर को डेवलप ब्रांच में अत्याधुनिक कोड से चलाएँ:```console
❯ docker run -it -p 8899:8899 --rm ghcr.io/abhinavsingh/proxy.py:latest

[![WARNING](https://img.shields.io/static/v1?label=MacOS&message=warning&color=red)](https://github.com/moby/vpnkit/issues/469)
`docker` इमेज `macOS` पर [vpnkit](https://github.com/moby/vpnkit/issues/469) के साथ असंगति के कारण वर्तमान में टूटा हुआ है।

## HomeBrew का उपयोग करना

`HomeBrew` के लिए अपडेटेड फॉर्मूले `helper/homebrew` निर्देशिका के अंतर्गत `develop` ब्रांच में बनाए रखे जाते हैं।

- `stable` फॉर्मूले `master` ब्रांच से पैकेज इंस्टॉल करते हैं।
- `develop` फॉर्मूले `develop` ब्रांच से पैकेज इंस्टॉल करते हैं।

### HomeBrew के साथ स्थिर संस्करण```console
❯ brew install https://raw.githubusercontent.com/abhinavsingh/proxy.py/develop/helper/homebrew/stable/proxy.rb

# Start proxy.py

## PIP का उपयोग करके स्थापित होने पर कमांड लाइन से

जब `proxy.py` को `pip` का उपयोग करके स्थापित किया जाता है,
तो एक निष्पादन योग्य फ़ाइल `proxy` आपके `$PATH` में रख दी जाती है।

### इसे चलाएँ

डिफ़ॉल्ट कॉन्फ़िगरेशन के साथ शुरू करने के लिए बस कमांड लाइन पर `proxy` टाइप करें।```console
❯ proxy
...[redacted]... - Loaded plugin proxy.http.proxy.HttpProxyPlugin
...[redacted]... - Started 8 threadless workers
...[redacted]... - Started 8 acceptors
...[redacted]... - Listening on 127.0.0.1:8899

आप लॉग स्तर को अनुकूलित करने के लिए एक अक्षर का उपयोग कर सकते हैं। उदाहरण:
- `d = DEBUG`
- `i = INFO`
- `w = WARNING`
- `e = ERROR`
- `c = CRITICAL`

जैसा कि हम उपरोक्त लॉग से देख सकते हैं, शुरू करने से पहले:

- `proxy.py` ने सिस्टम पर ओपन फ़ाइल सीमा `ulimit` सेट करने का प्रयास किया
- `--open-file-limit` के लिए डिफ़ॉल्ट मान `1024` उपयोग किया गया
- `--open-file-limit` फ़्लैग `Windows` ऑपरेटिंग सिस्टम पर कोई प्रभाव नहीं डालता

उपलब्ध कॉन्फ़िगरेशन विकल्पों की पूरी सूची के लिए [फ़्लैग](#flags) देखें।

## रिपो स्रोत से कमांड लाइन का उपयोग करके

यदि आप `proxy.py` को स्रोत कोड से चलाने का प्रयास कर रहे हैं,
तो स्रोत कोड में `proxy` नामक कोई बाइनरी फ़ाइल नहीं है।

स्रोत कोड से `proxy.py` शुरू करने के लिए इन निर्देशों का पालन करें:

- रिपो क्लोन करें  ```console
  ❯ git clone https://github.com/abhinavsingh/proxy.py.git
  ❯ cd proxy.py

--hostname 0.0.0.0 --port 8899

❯ docker run -it \
    -p 8899:8899 \
    --rm abhinavsingh/proxy.py:latest \
    -v

अब आप अपने दैनिक ब्राउज़िंग अनुभव को तेज़ कर सकते हैं अपनी पसंदीदा वेबसाइट पर एकल वर्ण डोमेन नामों का उपयोग करके विज़िट करके :). यह सभी ब्राउज़रों में काम करता है।

निम्नलिखित लघु लिंक डिफ़ॉल्ट रूप से सक्षम हैं:

| Short Link |  Destination URL   |
| :--------: |  :--------------:  |
|     a/     |    `amazon.com`    |
|     i/     |  `instagram.com`   |
|     l/     |   `linkedin.com`   |
|     f/     |   `facebook.com`   |
|     g/     |    `google.com`    |
|     t/     |   `twitter.com`    |
|     w/     | `web.whatsapp.com` |
|     y/     |   `youtube.com`    |
|   proxy/   |  `localhost:8899`  |

### ModifyPostDataPlugin

अपस्ट्रीम सर्वर पर अनुरोध भेजने से पहले POST अनुरोध बॉडी को संशोधित करता है।

`proxy.py` को इस प्रकार प्रारंभ करें:```console
❯ proxy \
    --plugins proxy.plugin.ModifyPostDataPlugin

ऊपर दिए गए प्रतिक्रिया से निम्नलिखित नोट:

1. POST डेटा को संशोधित किया गया `"data": "{\"key\": \"modified\"}"`.
   मूल `curl` कमांड डेटा था `{"key": "value"}`.
2. हमारे `curl` कमांड ने कोई `Content-Type` हेडर नहीं जोड़ा,
   लेकिन हमारे प्लगइन ने एक `"Content-Type": "application/json"` जोड़ा।
   इसे उपरोक्त आउटपुट में `json` फील्ड देखकर भी सत्यापित किया जा सकता है:   ```
   "json": {
    "key": "modified"
   },

मॉक API प्रतिक्रिया सत्यापित करने के लिए `curl -x localhost:8899 http://api.example.com/v1/users/` का उपयोग करें```console
{"count": 2, "next": null, "previous": null, "results": [{"email": "[email protected]", "groups": [], "url": "api.example.com/v1/users/1/", "username": "admin"}, {"email": "[email protected]", "groups": [], "url": "api.example.com/v1/users/2/", "username": "admin"}]}

Access log shows `None:None` as server `ip:port`. `None` simply means that
the server connection was never made, since response was returned by our plugin.

Now modify `ProposedRestApiPlugin` to returns REST API mock
responses as expected by your clients.

### RedirectToCustomServerPlugin

Redirects all incoming `http` requests to custom web server.
By default, it redirects client requests to inbuilt web server,
also running on `8899` port.

Start `proxy.py` and enable inbuilt web server:```console
❯ proxy \
    --enable-web-server \
    --plugins proxy.plugin.RedirectToCustomServerPlugin

उपरोक्त `404` प्रतिक्रिया `proxy.py` वेब सर्वर से वापस की गई थी।

`proxy.py` के लॉग की जाँच करके इसकी पुष्टि करें।
प्रॉक्सी अनुरोध लॉग के साथ, आपको एक http वेब सर्वर अनुरोध लॉग भी देखना होगा।```
... [redacted] ... - access_log:1241 - ::1:49525 - GET /
... [redacted] ... - access_log:1157 - ::1:49524 - GET localhost:8899/ - 404 NOT FOUND - 70 bytes

इसका प्रयोग करके सत्यापित करें `curl -v -x localhost:8899 http://facebook.com`:```console
... [redacted] ...
< HTTP/1.1 418 I'm a tea pot
< Proxy-agent: proxy.py v1.0.0
* no chunk, no close, no size. Assume close to signal end
<
* Closing connection 0

### CacheResponsesPlugin

अपस्ट्रीम सर्वर प्रतिक्रियाओं को कैश करता है।

प्रारंभ करें `proxy.py` इस प्रकार:```console
❯ proxy \
    --plugins proxy.plugin.CacheResponsesPlugin

`proxy.py` लॉग से कैश फ़ाइल का पथ प्राप्त करें:```console
... [redacted] ... - GET httpbin.org:80/get - 200 OK - 556 bytes
... [redacted] ... - Cached response at /var/folders/k9/x93q0_xn1ls9zy76m2mf2k_00000gn/T/httpbin.org-1569378301.407512.txt

### CacheByResponseType

`CacheResponsesPlugin` प्लगइन `content-type` द्वारा प्रतिक्रियाओं को स्वचालित रूप से कैश भी कर सकता है। इसे आज़माने के लिए, आपको [TLS Interception](#tls-interception) मोड के तहत चलना होगा और फिर `--cache-by-content-type` फ़्लैग पास करना होगा।  उदाहरण:```console
❯ proxy \
    --plugins proxy.plugin.CacheResponsesPlugin \
    --cache-by-content-type \
    --ca-key-file ca-key.pem \
    --ca-cert-file ca-cert.pem \
    --ca-signing-key ca-signing-key.pem

`curl -v -x localhost:8899 http://google.com` का उपयोग करके सत्यापित करें:```console
... [redacted] ...
< HTTP/1.1 200 OK
< Content-Length: 28
<
* Connection #0 to host localhost left intact
Hello from man in the middle

Please provide the Markdown content to translate.```console
❯ proxy --port 9001

`8899` प्रॉक्सी के माध्यम से curl अनुरोध करें:

`curl -v -x localhost:8899 http://httpbin.org/get`

सत्यापित करें कि `8899` प्रॉक्सी अनुरोधों को अपस्ट्रीम प्रॉक्सियों तक अग्रेषित करता है, संबंधित लॉग की जाँच करके।

यदि किसी अपस्ट्रीम प्रॉक्सी को क्रेडेंशियल्स की आवश्यकता है, तो उन्हें तर्क के रूप में पास करें। उदाहरण:

`--proxy-pool user:[email protected]:port`

### FilterByClientIpPlugin

विशिष्ट IP पतों से ट्रैफ़िक को अस्वीकार करें। डिफ़ॉल्ट रूप से यह प्लगइन `127.0.0.1` और `::1` से ट्रैफ़िक को ब्लॉक करता है।

`proxy.py` को इस प्रकार प्रारंभ करें:```console
❯ proxy \
    --plugins proxy.plugin.FilterByClientIpPlugin

अपने स्वाद के अनुसार प्लगइन को संशोधित करें, उदाहरण के लिए केवल विशिष्ट IP पतों की अनुमति दें।

### ModifyChunkResponsePlugin

यह प्लगइन दर्शाता है कि चंक एन्कोडेड प्रतिक्रियाओं को कैसे संशोधित किया जाए। ऐसा करने में सक्षम होने के लिए, यह प्लगइन चंक एन्कोडेड प्रतिक्रिया को पार्स करने के लिए `proxy.py` कोर का उपयोग करता है। फिर हम कस्टम हार्ड-कोडेड चंक का उपयोग करके प्रतिक्रिया का पुनर्निर्माण करते हैं, अपस्ट्रीम सर्वर से प्राप्त मूल चंक को अनदेखा करते हुए।

`proxy.py` को इस प्रकार प्रारंभ करें:```console
❯ proxy \
    --plugins proxy.plugin.ModifyChunkResponsePlugin

Modify `ModifyChunkResponsePlugin` को अपनी पसंद के अनुसार संशोधित करें। उदाहरण, हार्ड-कोडेड चंक्स भेजने के बजाय, अपस्ट्रीम सर्वर से प्राप्त मूल `JSON` चंक्स को पार्स और संशोधित करें।

### ModifyRequestHeaderPlugin

यह प्लगइन दर्शाता है कि TLS इंटरसेप्शन मोड के तहत आउटगोइंग HTTPS अनुरोध हेडर को कैसे संशोधित किया जाए।

`proxy.py` को इस प्रकार प्रारंभ करें:```console
❯ proxy \
    --plugins proxy.plugin.ModifyRequestHeaderPlugin \
    ... [TLS interception flags] ...

### CloudflareDnsResolverPlugin

यह प्लगइन `Cloudflare` द्वारा होस्ट किए गए `DNS-over-HTTPS` [API](https://developers.cloudflare.com/1.1.1.1/encrypted-dns/dns-over-https/make-api-requests/dns-json) (json) का उपयोग करता है।

`DoH` एक HTTP2-अनुरूप क्लाइंट की आवश्यकता है। दुर्भाग्य से `proxy.py` अभी तक वह प्रदान नहीं करता है, इसलिए हम एक निर्भरता का उपयोग करते हैं। इसे स्थापित करें:```console
❯ pip install "httpx[http2]"

डिफ़ॉल्ट रूप से, `CloudflareDnsResolverPlugin` `security` मोड में चलता है और मैलवेयर सुरक्षा प्रदान करता है।
`--cloudflare-dns-mode family` का उपयोग करके वयस्क सामग्री सुरक्षा भी सक्षम करें।

### CustomDnsResolverPlugin

यह प्लगइन `proxy.py` के साथ कस्टम DNS रिज़ॉल्यूशन कार्यान्वयन का उपयोग करने का प्रदर्शन करता है।
यह उदाहरण प्लगइन वर्तमान में पायथन के अंतर्निहित रिज़ॉल्यूशन तंत्र का उपयोग करता है। अपनी पसंद के अनुसार कोड को अनुकूलित करें।
उदाहरण के लिए, अपने कस्टम DNS सर्वर से क्वेरी करें, `DoH` या अन्य तंत्र लागू करें।

`proxy.py` को इस प्रकार शुरू करें:```console
❯ proxy \
    --plugins proxy.plugin.CustomDnsResolverPlugin

`curl` का उपयोग करके एक अनुरोध करें:```console
❯ curl -v -x localhost:8899 https://httpbin.org/get

ध्यान दें `curl` का उपयोग `::1` या `127.0.0.1` के स्थान पर क्लाइंट IP के रूप में करें।

[![WARNING](https://img.shields.io/static/v1?label=Compatibility&message=warning&color=red)](#programnameplugin) यदि `ProgramNamePlugin` आपके ऑपरेटिंग सिस्टम पर विश्वसनीय रूप से काम नहीं करता है, तो कृपया पुल अनुरोध भेजकर और/या एक मुद्दा खोलकर योगदान करें। धन्यवाद!!!

## HTTP वेब सर्वर प्लगइन्स

### वेब सर्वर रूट

प्लगइन का उपयोग करके अंतर्निहित वेब सर्वर रूटिंग को प्रदर्शित करता है।

`proxy.py` को इस प्रकार प्रारंभ करें:```console
❯ proxy --enable-web-server \
    --plugins proxy.plugin.WebServerPlugin

## रिवर्स प्रॉक्सी प्लगइन्स

रिवर्स प्रॉक्सी क्षमताओं को जोड़ने के लिए अंतर्निहित वेब सर्वर का विस्तार करता है।

### रिवर्स प्रॉक्सी

`proxy.py` को इस प्रकार प्रारंभ करें:```console
❯ proxy --enable-reverse-proxy \
    --plugins proxy.plugin.ReverseProxyPlugin

सत्यापित करें `curl -v localhost:8899/get`:```console
{
  "args": {},
  "headers": {
    "Accept": "*/*",
    "Host": "localhost",
    "User-Agent": "curl/7.64.1"
  },
  "origin": "1.2.3.4, 5.6.7.8",
  "url": "https://localhost/get"
}

यह इसलिए हो रहा है क्योंकि हमारा डिफ़ॉल्ट रिवर्स प्रॉक्सी प्लगइन `ReverseProxyPlugin` एक `http` और एक `https` अपस्ट्रीम सर्वर के साथ कॉन्फ़िगर किया गया है। और, डिफ़ॉल्ट रूप से `ReverseProxyPlugin` मूल होस्ट हेडर को संरक्षित करता है। जबकि यह `https` अपस्ट्रीम के साथ काम करता है, यह `http` अपस्ट्रीम के साथ विश्वसनीय रूप से काम नहीं करता है। इस समस्या को हल करने के लिए `--rewrite-host-header` फ्लैग का उपयोग करें।

उदाहरण:```console
❯ proxy --enable-reverse-proxy \
    --plugins proxy.plugin.ReverseProxyPlugin \
    --rewrite-host-header

`proxy.py` को इस प्रकार प्रारंभ करें:```console
❯ proxy \
    --cert-file https-cert.pem \
    --key-file https-key.pem

यदि आप `--proxy-cacert` फ़्लैग पास करने से बचना चाहते हैं, तो जनरेट किए गए SSL प्रमाणपत्रों पर हस्ताक्षर करने पर भी विचार करें। उदाहरण:

पहले, CA प्रमाणपत्र जनरेट करें:```console
make ca-certificates

अब सर्वर को `--cert-file https-signed-cert.pem` फ़्लैग के साथ पुनः प्रारंभ करें। ध्यान दें कि आपको अपने सिस्टम कीचेन में जनरेट किए गए `ca-cert.pem` पर भरोसा करना होगा।

# TLS अवरोधन

डिफ़ॉल्ट रूप से, `proxy.py` क्लाइंट और सर्वर के बीच `https` ट्रैफ़िक को डिक्रिप्ट नहीं करेगा।
TLS अवरोधन सक्षम करने के लिए पहले रूट CA प्रमाणपत्र जनरेट करें:```console
❯ make ca-certificates

[![NOTE](https://img.shields.io/static/v1?label=MacOS&message=note&color=yellow)](https://github.com/abhinavsingh/proxy.py#user-content-flags) पीयर प्रमाणपत्रों के सत्यापन के लिए आवश्यक स्पष्ट CA बंडल पथ भी प्रदान करें। `--ca-file` फ़्लैग देखें।

`curl` का उपयोग करके TLS इंटरसेप्शन सत्यापित करें।```console
❯ curl -v -x localhost:8899 --cacert ca-cert.pem https://httpbin.org/get

`issuer` पंक्ति पुष्टि करती है कि प्रतिक्रिया को इंटरसेप्ट किया गया था।

कैश्ड प्रतिक्रिया फ़ाइल की सामग्री भी सत्यापित करें। `proxy.py` लॉग से कैश
फ़ाइल का पथ प्राप्त करें।

`❯ cat /path/to/your/tmp/directory/httpbin.org-1569452863.924174.txt````console
HTTP/1.1 200 OK
Access-Control-Allow-Credentials: true
Access-Control-Allow-Origin: *
Content-Type: application/json
Date: Wed, 25 Sep 2019 23:07:05 GMT
Referrer-Policy: no-referrer-when-downgrade
Server: nginx
X-Content-Type-Options: nosniff
X-Frame-Options: DENY
X-XSS-Protection: 1; mode=block
Content-Length: 202
Connection: keep-alive

{
  "args": {},
  "headers": {
    "Accept": "*/*",
    "Host": "httpbin.org",
    "User-Agent": "curl/7.54.0"
  },
  "origin": "1.2.3.4, 5.6.7.8",
  "url": "https://httpbin.org/get"
}

## ग्राउट प्रमाणीकरण

ग्राउट आपकी फ़ाइलों, फ़ोल्डरों और सेवाओं को अनधिकृत पहुँच से बचाने के लिए प्रमाणीकरण का समर्थन करता है।  प्रमाणीकरण लागू करने के लिए `--basic-auth` फ़्लैग का उपयोग करें।  उदाहरण:```console
grout /path/to/folder --basic-auth user:pass
grout https://localhost:8080 --basic-auth u:p

## ग्राउट वाइल्डकार्ड डोमेन

डिफ़ॉल्ट रूप से, ग्राउट क्लाइंट एक समर्पित उपडोमेन पर आने वाले ट्रैफ़िक को सेवा प्रदान करता है। हालांकि, कुछ सेवाएं (जैसे कुबेरनेट्स) एडहॉक उपडोमेन पर ट्रैफ़िक प्रदान करना चाह सकती हैं। प्रत्येक एडहॉक उपडोमेन के लिए एक समर्पित ग्राउट क्लाइंट शुरू करना एक व्यावहारिक समाधान नहीं हो सकता है।

ऐसे परिदृश्यों के लिए, ग्राउट वाइल्डकार्ड डोमेन का समर्थन करता है। यहां बताया गया है कि ग्राउट क्लाइंट के साथ उपयोग के लिए अपना स्वयं का वाइल्डकार्ड डोमेन कैसे कॉन्फ़िगर करें।

1. एक डोमेन चुनें जैसे `custom.example.com`
2. आपकी सेवा `custom.example.com` और `*.custom.example.com` के लिए ट्रैफ़िक प्रदान करना चाहती है
3. यदि आप `https://` का उपयोग करने की योजना बना रहे हैं, तो आपको एक लोड बैलेंसर सेटअप करना होगा:
   - एक HTTPS लोड बैलेंसर (LB) सेटअप करें
   - LB को `custom.example.com` और `*.custom.example.com` के लिए जनरेट किए गए प्रमाणपत्र से कॉन्फ़िगर करें
   - ग्राउट सेवा के सार्वजनिक IP पतों पर ट्रैफ़िक पॉइंट करें
4. `custom.example.com` को व्हाइटलिस्ट करने के लिए [email protected] पर ग्राउट टीम से संपर्क करें। ग्राउट टीम यह सुनिश्चित करेगी कि आप वास्तव में डोमेन के मालिक हैं और आपने ऊपर बताए अनुसार एक मान्य SSL प्रमाणपत्र कॉन्फ़िगर किया है।

ग्राउट को `--wildcard` फ़्लैग के साथ प्रारंभ करें।  उदाहरण:

grout https://localhost:8080 custom.example.com --wildcard
2024-08-05 18:24:59,294 - grout - Logged in as [email protected]
2024-08-05 18:25:03,159 - setup - Grouting https://*.custom.domain.com
```
## Host हेडर पर आधारित ग्राउट वाइल्डकार्ड डोमेन रूटिंग

  > केवल `--wildcard` के साथ उपलब्ध

डिफ़ॉल्ट रूट के साथ आप अतिरिक्त रूट भी प्रदान कर सकते हैं जो होस्ट फ़ील्ड मेल खाने पर प्राथमिकता लेते हैं। उदाहरण:```console
grout https://localhost:8080 custom.example.com \
  --wildcard \
  --tunnel-route-url stream.example.com=http://localhost:7001
```
आप इस फ्लैग को दोहराकर कई कस्टम रूट प्रदान कर सकते हैं।

## Grout क्लाइंट प्लगइन

`GroutClientBasePlugin` आपको विभिन्न अपस्ट्रीम्स के लिए डायनामिक रूप से ट्रैफ़िक रूट करने की अनुमति देता है।  नीचे इसका उपयोग करने के तरीके के बारे में कुछ विवरण के साथ एक सरल कार्यान्वयन है।```python
class GroutClientPlugin(GroutClientBasePlugin):

    def resolve_route(
        self,
        route: str,
        request: HttpParser,
        origin: HostPort,
        server: HostPort,
    ) -> Tuple[Optional[str], HttpParser]:
        print(request, origin, server, '->', route)
        print(request.header(b'host'), request.path)
        #
        # Here, we send traffic to localhost:7001 irrespective
        # of the original "route" value provided to the grout
        # client OR any custom host:upstream mapping provided
        # through the --tunnel-route-url flags (when using
        # --wildcard).
        #
        # Optionally, you can also strip path before
        # sending traffic to upstrem, like:
        # request.path = b"/"
        #
        # To drop the request, simply return None for route
        # return None, request
        #
        return 'http://localhost:7001', request
```
See [grout_client.py](https://github.com/abhinavsingh/proxy.py/blob/develop/proxy/plugin/grout_client.py) अधिक जानकारी के लिए।  इसका परीक्षण करने के लिए, grout क्लाइंट शुरू करते समय `--plugin proxy.plugin.grout_client.GroutClientPlugin` पास करके शुरू करें।

## Docker का उपयोग करके Grout```console
❯ docker run --rm -it \
  --entrypoint grout \
  -v ~/.proxy:/root/.proxy \
  abhinavsingh/proxy.py:latest \
  http://host.docker.internal:29876
```
ऊपर:

- हमने `--entrypoint` को `grout` में बदल दिया
- हमने `localhost` को `host.docker.internal` से बदल दिया, ताकि `grout` होस्ट मशीन पर चल रहे पोर्ट `29876` पर ट्रैफिक रूट कर सके
- *(वैकल्पिक)* होस्ट मशीन के `~/.proxy` फ़ोल्डर को माउंट करें, ताकि `grout` क्रेडेंशियल्स कंटेनर रीस्टार्ट के दौरान बने रहें

## Grout कैसे काम करता है

- `grout` इंफ्रास्ट्रक्चर में 2 घटक हैं: क्लाइंट और सर्वर
- `grout` क्लाइंट में 2 घटक हैं: एक थिन और एक थिक क्लाइंट
- `grout` थिन क्लाइंट ओपन सोर्स `proxy.py` (BSD 3-Clause License) का हिस्सा है
- `grout` थिक क्लाइंट और सर्वर [jaxl.io](https://jaxl.io) पर होस्ट किए जाते हैं
  और [Jaxl Innovations Private Limited](https://jaxl.com) का कॉपीराइट है
- `grout` सर्वर में 3 घटक हैं: एक रजिस्ट्री सर्वर, एक रिवर्स प्रॉक्सी सर्वर और एक टनल सर्वर

## स्व-होस्टेड `grout`

- `grout` थिक क्लाइंट और सर्वर को आपके GCP, AWS, क्लाउड इंफ्रास्ट्रक्चर पर भी होस्ट किया जा सकता है
- स्व-होस्टेड संस्करण के साथ, आपका ट्रैफिक उस नेटवर्क के माध्यम से बहता है जिसे आप नियंत्रित और भरोसा करते हैं
- [jaxl.io](https://jaxl.io) पर `grout` डेवलपर्स स्व-होस्टेड समाधानों के लिए GCP, AWS, Docker इमेज प्रदान करते हैं
- शुरू करने के लिए कृपया [[email protected]](mailto:[email protected]) पर एक ईमेल भेजें।

# SSH टनल के ऊपर प्रॉक्सी

**यह एक कार्य प्रगति पर है और दस्तावेज़ के अनुसार काम नहीं कर सकता**

`paramiko` की आवश्यकता है। निर्भरताएँ स्थापित करने के लिए `pip install "proxy.py[tunnel]"` का उपयोग करें

## प्रॉक्सी रिमोट अनुरोध स्थानीय रूप से

                            |
    +------------+          |            +----------+
    |   LOCAL    |          |            |  REMOTE  |
    |   HOST     | <== SSH ==== :8900 == |  PROXY   |
    +------------+          |            +----------+
    :8899 proxy.py          |
                            |
                         FIREWALL
                      (allow tcp/22)

### क्या

एक `remote` प्रॉक्सी सर्वर पर किए गए HTTP(s) अनुरोधों को `localhost` पर चल रहे `proxy.py` सर्वर के माध्यम से प्रॉक्सी करें।

### कैसे

- अनुरोधित `remote` पोर्ट SSH कनेक्शन पर फॉरवर्ड किया जाता है।
- `localhost` पर चलने वाला `proxy.py` `remote` प्रॉक्सी अनुरोधों को
  संभालता और उत्तर देता है।

### आवश्यकताएँ

1. `localhost` के पास `remote` सर्वर तक SSH पहुंच होनी चाहिए
2. `remote` सर्वर को फॉरवर्ड किए गए पोर्ट नंबर के माध्यम से HTTP(s) अनुरोधों को प्रॉक्सी करने के लिए कॉन्फ़िगर किया जाना चाहिए, जैसे `:8900`।
   - `remote` और `localhost` पोर्ट समान हो सकते हैं, जैसे `:8899`।
   - `:8900` को आस्की आर्ट में भिन्नता के उद्देश्य के लिए चुना गया है।

### इसे आज़माएं

`proxy.py` को इस प्रकार प्रारंभ करें:```console
❯ # On localhost
❯ proxy --enable-ssh-tunnel \
    --tunnel-username username \
    --tunnel-hostname ip.address.or.domain.name \
    --tunnel-port 22 \
    --tunnel-remote-port 8899 \
    --tunnel-ssh-key /path/to/ssh/private.key \
    --tunnel-ssh-key-passphrase XXXXX
...[redacted]... [I] listener.setup:97 - Listening on 127.0.0.1:8899
...[redacted]... [I] pool.setup:106 - Started 16 acceptors in threadless (local) mode
...[redacted]... [I] transport._log:1873 - Connected (version 2.0, client OpenSSH_7.6p1)
...[redacted]... [I] transport._log:1873 - Authentication (publickey) successful!
...[redacted]... [I] listener.setup:116 - SSH connection established to ip.address.or.domain.name:22...
...[redacted]... [I] listener.start_port_forward:91 - :8899 forwarding successful...
```
`remote` सर्वर पर एक HTTP प्रॉक्सी अनुरोध करें और सत्यापित करें कि प्रतिक्रिया में `localhost` का सार्वजनिक IP पता मूल के रूप में शामिल है:```console
❯ # On remote
❯ curl -x 127.0.0.1:8899 http://httpbin.org/get
{
  "args": {},
  "headers": {
    "Accept": "*/*",
    "Host": "httpbin.org",
    "User-Agent": "curl/7.54.0"
  },
  "origin": "x.x.x.x, y.y.y.y",
  "url": "https://httpbin.org/get"
}
```
यह भी सुनिश्चित करें कि `proxy.py` के लॉग्स `localhost` पर `remote` IP को क्लाइंट IP के रूप में दिखाते हैं।```console
access_log:328 - remote:52067 - GET httpbin.org:80
```
## स्थानीय अनुरोधों को दूरस्थ रूप से प्रॉक्सी करें

                            |
    +------------+          |     +----------+
    |   LOCAL    |          |     |  REMOTE  |
    |   HOST     | === SSH =====> |  SERVER  |
    +------------+          |     +----------+
                            |     :8899 proxy.py
                            |
                        FIREWALL
                     (allow tcp/22)

योजना नहीं है।

यदि आपके पास कोई वैध उपयोग मामला है, तो कृपया एक इश्यू खोलें। आप इस कार्यक्षमता को जोड़ने के लिए पुल-रिक्वेस्ट के माध्यम से योगदान भेजने के लिए हमेशा स्वागत हैं :)

> स्थानीय अनुरोधों को दूरस्थ रूप से प्रॉक्सी करने के लिए, [प्रॉक्सी पूल प्लगइन](#proxypoolplugin) का उपयोग करें।

# proxy.py को एम्बेड करें

## ब्लॉकिंग मोड

डिफ़ॉल्ट कॉन्फ़िगरेशन के साथ `proxy.py` को एम्बेडेड मोड में प्रारंभ करने के लिए `proxy.main` विधि का उपयोग करें। उदाहरण:```python
import proxy

if __name__ == '__main__':
  proxy.main()
```
kwargs के रूप में पास करके स्टार्टअप फ्लैग्स को अनुकूलित करें:```python
import ipaddress
import proxy

if __name__ == '__main__':
  proxy.main(
    hostname=ipaddress.IPv6Address('::1'),
    port=8899
  )
```
ध्यान दें:

1. `main` कमांड लाइन से `proxy.py` शुरू करने के समतुल्य है।
2. `main` कोई `args` स्वीकार नहीं करता (केवल `kwargs`)।
3. `main` स्वचालित रूप से किसी भी उपलब्ध `sys.argv` को `args` के रूप में उपभोग करेगा।
3. `main` तब तक ब्लॉक रहेगा जब तक `proxy.py` बंद न हो जाए।

## नॉन-ब्लॉकिंग मोड

डिफ़ॉल्ट कॉन्फ़िगरेशन के साथ `Proxy` कॉन्टेक्स्ट मैनेजर का उपयोग करके `proxy.py` को नॉन-ब्लॉकिंग एम्बेडेड मोड में शुरू करें: उदाहरण:```python
import proxy

if __name__ == '__main__':
  with proxy.Proxy() as p:
    # Uncomment the line below and
    # implement your app your logic here
    proxy.sleep_loop()
```
ध्यान दें:

1. `Proxy` `main` के समान है, सिवाय इसके कि `Proxy` ब्लॉक नहीं करेगा।
2. आंतरिक रूप से, `Proxy` एक कॉन्टेक्स्ट मैनेजर है जो कॉल करने पर `proxy.py` शुरू करेगा और स्कोप समाप्त होने पर इसे बंद कर देगा।
3. `main` के विपरीत, `Proxy` के साथ स्टार्टअप फ्लैग को `args` और `kwargs` का उपयोग करके भी अनुकूलित किया जा सकता है। उदा., `Proxy(['--port', '8899'])` या फ्लैग को kwargs के रूप में पास करके, जैसे `Proxy(port=8899)`।
4. `main` के विपरीत, `Proxy` `sys.argv` का निरीक्षण नहीं करेगा।

## अस्थायी पोर्ट

`--port=0` का उपयोग करें ताकि `proxy.py` कर्नेल द्वारा आवंटित एक यादृच्छिक पोर्ट पर बाइंड हो।

एम्बेडेड मोड में, आप इस पोर्ट तक पहुँच सकते हैं।  उदाहरण:```python
import proxy

if __name__ == '__main__':
  with proxy.Proxy(port=0) as p:
    print(p.flags.port)
    proxy.sleep_loop()
```
`flags.port` आपको कर्नेल द्वारा आवंटित रैंडम पोर्ट तक पहुंच प्रदान करेगा।

## प्लगइन लोड करना

उपयोगकर्ता एकाधिक प्लगइन लोड करने के लिए `--plugins` फ्लैग का कई बार उपयोग कर सकते हैं।
यदि आप समस्याओं का सामना कर रहे हैं तो [प्लगइन लोड करने में असमर्थ](#unable-to-load-plugins) देखें।

एम्बेडेड मोड में उपयोग करते समय, आपके पास कुछ और विकल्प होते हैं।  उदाहरण:

1. प्लगइन क्लास का पूरी तरह से योग्य नाम `bytes` के रूप में `proxy.main` विधि या `proxy.Proxy` कॉन्टेक्स्ट मैनेजर को प्रदान करें।
2. प्लगइन क्लास का `type` इंस्टेंस प्रदान करें। यह विशेष रूप से उपयोगी है यदि आप रनटाइम पर प्लगइन परिभाषित करने की योजना बनाते हैं।

उदाहरण, `--plugins` फ्लैग का उपयोग करके एकल प्लगइन लोड करें:```python
import proxy

if __name__ == '__main__':
  proxy.main(plugins=['proxy.plugin.CacheResponsesPlugin'])
```
सरलता के लिए, आप प्लगइन्स की सूची को `proxy.main` या `Proxy` कंस्ट्रक्टर को एक कीवर्ड आर्गुमेंट के रूप में भी पास कर सकते हैं।

उदाहरण:```python
import proxy
from proxy.plugin import FilterByUpstreamHostPlugin

if __name__ == '__main__':
  proxy.main(plugins=[
    b'proxy.plugin.CacheResponsesPlugin',
    FilterByUpstreamHostPlugin,
  ])
```
# proxy.py के साथ यूनिट परीक्षण

## `proxy.TestCase`

अपने Python `unittest` क्लासेस के लिए `proxy.py` को सेटअप और टियर डाउन करने के लिए, बस `unittest.TestCase` के बजाय `proxy.TestCase` का उपयोग करें।
उदाहरण:```python
import proxy

class TestProxyPyEmbedded(proxy.TestCase):

    def test_my_application_with_proxy(self) -> None:
        self.assertTrue(True)
```
ध्यान दें:

1. `proxy.TestCase` `unittest.TestCase.run()` विधि को ओवरराइड करता है ताकि `proxy.py` को सेटअप और टियर डाउन किया जा सके।
2. `proxy.py` सर्वर सिस्टम पर एक यादृच्छिक उपलब्ध पोर्ट पर सुनेगा।
   यह यादृच्छिक पोर्ट आपके परीक्षण मामलों में `self.PROXY.flags.port` के रूप में उपलब्ध है।
3. डिफ़ॉल्ट रूप से केवल एक एक्सेप्टर और एक वर्कर शुरू किया जाता है (`--num-workers 1 --num-acceptors 1`) तेजी से सेटअप और टियर डाउन के लिए।
4. सबसे महत्वपूर्ण बात, `proxy.TestCase` यह भी सुनिश्चित करता है कि `proxy.py` सर्वर
   परीक्षणों के निष्पादन के साथ आगे बढ़ने से पहले चालू हो और चल रहा हो। डिफ़ॉल्ट रूप से,
   `proxy.TestCase` `proxy.py` सर्वर शुरू होने के लिए `10 सेकंड` तक प्रतीक्षा करेगा,
   विफलता पर एक `TimeoutError` अपवाद उठाया जाएगा।

## स्टार्टअप फ्लैग को ओवरराइड करें

डिफ़ॉल्ट स्टार्टअप फ्लैग को ओवरराइड करने के लिए, अपने परीक्षण वर्ग में एक `PROXY_PY_STARTUP_FLAGS` चर परिभाषित करें।
उदाहरण:```python
class TestProxyPyEmbedded(TestCase):

    PROXY_PY_STARTUP_FLAGS = [
        '--num-workers', '2',
        '--num-acceptors', '1',
        '--enable-web-server',
    ]

    def test_my_application_with_proxy(self) -> None:
        self.assertTrue(True)
```
पूर्ण कार्यशील उदाहरण के लिए [test_embed.py] देखें।

[test_embed.py]:
https://raw.githubusercontent.com/abhinavsingh/proxy.py/develop/tests/testing/test_embed.py

## `unittest.TestCase` के साथ

यदि किसी कारण से आप सीधे `proxy.TestCase` का उपयोग करने में असमर्थ हैं, तो स्वयं `unittest.TestCase.run` को ओवरराइड करके `proxy.py` को सेटअप और टियर डाउन करें। उदाहरण:```python
import unittest
import proxy


class TestProxyPyEmbedded(unittest.TestCase):

    def test_my_application_with_proxy(self) -> None:
        self.assertTrue(True)

    def run(self, result: Optional[unittest.TestResult] = None) -> Any:
        with proxy.start([
                '--num-workers', '1',
                '--num-acceptors', '1',
                '--port', '... random port ...']):
            super().run(result)
```
या बस `proxy.py` को `setUpClass` और `teardownClass` क्लास मेथड्स के भीतर सेटअप/टियर डाउन करें।

# उपयोगिताएँ

## TCP सॉकेट्स

### new_socket_connection

IPv4 कनेक्शन बनाने का प्रयास करता है, फिर IPv6 और अंत में प्रदान किए गए पते के लिए एक डुअल स्टैक कनेक्शन बनाता है।```python
>>> conn = new_socket_connection(('httpbin.org', 80))
>>> ...[ use connection ]...
>>> conn.close()
```
### socket_connection

`socket_connection` एक सुविधाजनक डेकोरेटर + संदर्भ प्रबंधक है
`new_socket_connection` के चारों ओर जो यह सुनिश्चित करता है कि `conn.close` अंतर्निहित है।

एक संदर्भ प्रबंधक के रूप में:```python
>>> with socket_connection(('httpbin.org', 80)) as conn:
>>>   ... [ use connection ] ...
```
एक डेकोरेटर के रूप में:```python
>>> @socket_connection(('httpbin.org', 80))
>>> def my_api_call(conn, *args, **kwargs):
>>>   ... [ use connection ] ...
```
## HTTP Client

### build_http_request

- HTTP GET अनुरोध उत्पन्न करें  ```python
  >>> build_http_request(b'GET', b'/')
  b'GET / HTTP/1.1\r\n\r\n'
  ```
- शीर्षलेखों के साथ HTTP GET अनुरोध उत्पन्न करें  ```python
  >>> build_http_request(b'GET', b'/', conn_close=True)
  b'GET / HTTP/1.1\r\nConnection: close\r\n\r\n'
  ```
- हेडर और बॉडी के साथ HTTP POST अनुरोध उत्पन्न करें  ```python
  >>> import json
  >>> build_http_request(b'POST', b'/form',
          headers={b'Content-type': b'application/json'},
          body=proxy.bytes_(json.dumps({'email': '[email protected]'})))
      b'POST /form HTTP/1.1\r\nContent-type: application/json\r\n\r\n{"email": "[email protected]"}'
  ```
### build_http_response```python
build_http_response(
    status_code: int,
    protocol_version: bytes = HTTP_1_1,
    reason: Optional[bytes] = None,
    headers: Optional[Dict[bytes, bytes]] = None,
    body: Optional[bytes] = None) -> bytes
```
## PKI

### API उपयोग

- `gen_private_key`  ```python
  gen_private_key(
      key_path: str,
      password: str,
      bits: int = 2048,
      timeout: int = 10) -> bool
  ```
- `gen_public_key`  ```python
  gen_public_key(
      public_key_path: str,
      private_key_path: str,
      private_key_password: str,
      subject: str,
      alt_subj_names: Optional[List[str]] = None,
      extended_key_usage: Optional[str] = None,
      validity_in_days: int = 365,
      timeout: int = 10) -> bool
  ```
- `remove_passphrase`  ```python
  remove_passphrase(
      key_in_path: str,
      password: str,
      key_out_path: str,
      timeout: int = 10) -> bool
  ```
- `gen_csr`  ```python
  gen_csr(
      csr_path: str,
      key_path: str,
      password: str,
      crt_path: str,
      timeout: int = 10) -> bool
  ```
- `sign_csr`  ```python
  sign_csr(
      csr_path: str,
      crt_path: str,
      ca_key_path: str,
      ca_key_password: str,
      ca_crt_path: str,
      serial: str,
      alt_subj_names: Optional[List[str]] = None,
      extended_key_usage: Optional[str] = None,
      validity_in_days: int = 365,
      timeout: int = 10) -> bool
  ```
उपयोग उदाहरणों के लिए [pki.py](https://github.com/abhinavsingh/proxy.py/blob/develop/proxy/common/pki.py) और [test_pki.py](https://github.com/abhinavsingh/proxy.py/blob/develop/tests/common/test_pki.py) देखें।

### CLI उपयोग

`proxy.common.pki` मॉड्यूल का उपयोग करें:

1. सार्वजनिक और निजी कुंजियों का निर्माण
2. CSR अनुरोध उत्पन्न करना
3. कस्टम CA का उपयोग करके CSR अनुरोधों पर हस्ताक्षर करना।```console
❯ python -m proxy.common.pki -h
usage: pki.py [-h] [--password PASSWORD] [--private-key-path PRIVATE_KEY_PATH] [--public-key-path PUBLIC_KEY_PATH]
              [--subject SUBJECT] [--csr-path CSR_PATH] [--crt-path CRT_PATH] [--hostname HOSTNAME] [--openssl OPENSSL]
              action

proxy.py v2.4.4rc2.dev12+gdc06ea4 : PKI Utility

positional arguments:
  action                Valid actions: remove_passphrase, gen_private_key, gen_public_key, gen_csr, sign_csr

options:
  -h, --help            show this help message and exit
  --password PASSWORD   Password to use for encryption. Default: proxy.py
  --private-key-path PRIVATE_KEY_PATH
                        Private key path
  --public-key-path PUBLIC_KEY_PATH
                        Public key path
  --subject SUBJECT     Subject to use for public key generation. Default: /CN=localhost
  --csr-path CSR_PATH   CSR file path. Use with gen_csr and sign_csr action.
  --crt-path CRT_PATH   Signed certificate path. Use with sign_csr action.
  --hostname HOSTNAME   Alternative subject names to use during CSR signing.
  --openssl OPENSSL     Path to openssl binary. By default, we assume openssl is in your PATH
```
## आंतरिक दस्तावेज़ीकरण

### दस्तावेज़ पढ़ें

- [proxypy.readthedocs.io](https://proxypy.readthedocs.io/) पर जाएँ
- स्थानीय रूप से बिल्ड करने के लिए:

`make lib-doc`

### pydoc

कोड अच्छी तरह से दस्तावेज़ित है। स्रोत कोड प्राप्त करें और चलाएँ:

`pydoc3 proxy`

### pyreverse

गहन विश्लेषण के लिए क्लास स्तर के पदानुक्रम UML आरेख बनाएँ:

`make lib-pyreverse`

# डैशबोर्ड चलाएँ

डैशबोर्ड वर्तमान में विकास के अंतर्गत है और अभी तक `pip` पैकेजों के साथ बंडल नहीं किया गया है।
डैशबोर्ड चलाने के लिए, आपको स्रोत चेकआउट करना होगा।

डैशबोर्ड Typescript और SCSS में लिखा गया है, तो पहले इसे इसका उपयोग करके बिल्ड करें:```console
❯ make dashboard
```
एम्बेडेड `Chrome DevTools` भी बनाएँ यदि आप इसका उपयोग करने की योजना बना रहे हैं:```console
❯ make devtools
```
अब `proxy.py` को डैशबोर्ड प्लगइन के साथ और स्टैटिक सर्वर के लिए रूट डायरेक्टरी को ओवरराइड करके शुरू करें:```console
❯ proxy --enable-dashboard --static-server-dir dashboard/public
...[redacted]... - Loaded plugin proxy.http.server.HttpWebServerPlugin
...[redacted]... - Loaded plugin proxy.dashboard.dashboard.ProxyDashboard
...[redacted]... - Loaded plugin proxy.dashboard.inspect_traffic.InspectTrafficPlugin
...[redacted]... - Loaded plugin proxy.http.inspector.DevtoolsProtocolPlugin
...[redacted]... - Loaded plugin proxy.http.proxy.HttpProxyPlugin
...[redacted]... - Listening on ::1:8899
...[redacted]... - Core Event enabled
```
वर्तमान में, डैशबोर्ड को सक्षम करने से सभी डैशबोर्ड प्लगइन्स भी सक्षम हो जाएंगे।

डैशबोर्ड पर जाएँ:```console
❯ open http://localhost:8899/dashboard/
```
## Inspect Traffic

***यह एक WIP है और दस्तावेज़ के अनुसार काम नहीं कर सकता***

एम्बेडेड `Chrome Dev Console` लोड होने की प्रतीक्षा करें।  वर्तमान में, `proxy.py` के माध्यम से बहने वाले सभी ट्रैफ़िक का विवरण `Inspect Traffic` टैब पर पुश किया जाता है।  हालांकि, प्राप्त पेलोड अभी तक एम्बेडेड डेवलपर कंसोल के साथ एकीकृत नहीं किए गए हैं।

वर्तमान कार्यक्षमता को डैशबोर्ड के `Dev Console` को खोलकर और `proxy.py` सर्वर के साथ डैशबोर्ड द्वारा स्थापित वेबसॉकेट कनेक्शन का निरीक्षण करके सत्यापित किया जा सकता है।

[![Proxy.Py Dashboard Inspect Traffic](https://assets.kitploit.com/production/public/readmes/157/1e6258665ca9259fc526ebb90892d4b322094bb1e8139d329ab2379fc76ab66d.png)](https://github.com/abhinavsingh/proxy.py)

# Chrome DevTools प्रोटोकॉल

उन परिदृश्यों के लिए जहां आप `Chrome DevTools` प्रोटोकॉल वेबसॉकेट एंडपॉइंट तक सीधी पहुंच चाहते हैं,
`proxy.py` को इस प्रकार प्रारंभ करें:```console
❯ proxy --enable-devtools --enable-events
```
अब अपने CDT इंस्टेंस को `ws://localhost:8899/devtools` पर इंगित करें।

## Prometheus मेट्रिक्स

1) `proxy.py` को `--enable-metrics` फ़्लैग के साथ प्रारंभ करें ताकि एक prometheus एंडपॉइंट के माध्यम से आंतरिक मेट्रिक्स प्राप्त हो सकें
2) अपने `prometheus.yaml` को `/metrics` एंडपॉइंट से स्क्रैप करने के लिए कॉन्फ़िगर करें, उदा. [http://localhost:8899/metrics](http://localhost:8899/metrics)
3) `--metrics-path` फ़्लैग का उपयोग करके मेट्रिक्स पथ को अनुकूलित करें
4) ध्यान दें कि `--enable-metrics` आंतरिक रूप से `--enable-events` और वेब सर्वर प्लगइन को भी सक्षम करता है

# अक्सर पूछे जाने वाले प्रश्न

## उत्पादन में proxy.py तैनात करना

नीचे आपकी निजी/उत्पादन/कॉर्पोरेट परियोजनाओं में `proxy.py` का उपयोग करने के लिए कुछ रणनीतियाँ सूचीबद्ध हैं।

### क्या नहीं करना चाहिए?

> आपको अपने प्लगइन कोड को `proxy/plugin` निर्देशिका में रखने के लिए रिपॉजिटरी को *"बस"* फोर्क करने से `बचना चाहिए`। फोर्किंग परियोजना योगदानकर्ताओं के लिए अनुशंसित वर्कफ़्लो है, परियोजना उपयोगकर्ताओं के लिए नहीं।

- इसके बजाय, नीचे दिए गए सुझाए गए तरीकों में से एक का उपयोग करें।
- फिर अपने प्लगइन्स को `--plugin`, `--plugins` फ़्लैग या `plugin` kwargs का उपयोग करके लोड करें।
- उदाहरण के लिए [skeleton](https://github.com/abhinavsingh/proxy.py/tree/develop/skeleton) ऐप देखें जो `proxy.py` का उपयोग करके एक स्टैंडअलोन प्रोजेक्ट है।

### आवश्यकताओं के माध्यम से

यह *अत्यधिक* अनुशंसित है कि आप `proxy.py` का उपयोग `requirements.txt` या समान निर्भरता प्रबंधन सेटअप के माध्यम से करें। यह आपको `proxy.py` पारिस्थितिकी तंत्र में नियमित प्रदर्शन अद्यतन, बग फिक्स, सुरक्षा पैच और अन्य सुधारों का लाभ उठाने की अनुमति देगा। उदाहरण:

1. अंतिम `प्री-रिलीज़` पर निर्भर रहने के लिए `--pre` विकल्प का उपयोग करें

    ```console
    ❯ pip install proxy.py --pre
    ```

    प्री-रिलीज़ `develop` शाखा कोड पर निर्भर रहने के समान हैं, बस इतना है कि प्री-रिलीज़ `HEAD` की ओर इंगित नहीं हो सकते हैं। ऐसा इसलिए हो सकता है क्योंकि प्रत्येक PR मर्ज के बाद `PyPi` पर प्री-रिलीज़ उपलब्ध नहीं कराए जाते हैं।

2. `develop` शाखा कोड पर निर्भर रहने के लिए `--pre` विकल्प के साथ `TestPyPi` का उपयोग करें

    ```console
    ❯ pip install -i https://test.pypi.org/simple/ proxy.py --pre
    ```

    प्रत्येक PR मर्ज के बाद `TestPyPi` पर एक प्री-रिलीज़ उपलब्ध कराया जाता है।

3. अंतिम `स्थिर` रिलीज़ कोड का उपयोग करें

    हमेशा की तरह, बस उपयोग करें:

    ```console
    ❯ pip install proxy.py
    ```

### डॉकर कंटेनर के माध्यम से

यदि आप कंटेनर तैनात कर रहे हैं, तो बस अपनी छवि को आधार `proxy.py` कंटेनर छवियों से बनाएँ।

1. `develop` शाखा कोड से निर्माण करने के लिए `GHCR` का उपयोग करें:

    ```console
    FROM ghcr.io/abhinavsingh/proxy.py:latest as base
    ```

    *PS: मैं कई उत्पादन स्तर की परियोजनाओं के लिए GHCR नवीनतम का उपयोग करता हूँ*

2. अंतिम `स्थिर` रिलीज़ कोड से निर्माण करने के लिए `DockerHub` का उपयोग करें:

    ```console
    FROM abhinavsingh/proxy.py:latest as base
    ```

PS: मेरी राय में, कंटेनर-आधारित रणनीति *सबसे अच्छा तरीका* है और एकमात्र रणनीति है जिसका *मैं स्वयं उपयोग करता हूँ*।

### अपने CI/CD को proxy.py के साथ एकीकृत करें

*अरे, लेकिन आप develop शाखा में ब्रेकिंग चेंजेस करते रहते हैं।*

मैं समझता हूँ। और इसलिए, आपके उत्पादन-ग्रेड अनुप्रयोगों के लिए, आपको *अवश्य* ही अपने एप्लिकेशन CI/CD को `proxy.py` के साथ एकीकृत करना चाहिए। आपको यह सुनिश्चित करना होगा कि आपका एप्लिकेशन `proxy.py` अपस्ट्रीम रिपॉजिटरी में प्रत्येक PR मर्ज के लिए अपने परीक्षणों का निर्माण और पास करे।

यदि आपका एप्लिकेशन रिपॉजिटरी सार्वजनिक है, तो कुछ परिदृश्यों में, PR लेखक पिछड़ी संगतता और हरी CI/CD बनाए रखने के लिए सभी आश्रितों के लिए पैच PR भेज सकते हैं।

CI/CD एकीकरण सुनिश्चित करता है कि आपका ऐप नवीनतम `proxy.py` कोड के साथ बनता रहे। आप अपने कोड को कहाँ होस्ट करते हैं, इसके आधार पर, नीचे सूचीबद्ध रणनीति का उपयोग करें:

- GitHub

    शीघ्र ही

- Google Cloud Build

    शीघ्र ही

- AWS

    शीघ्र ही

- Azure

    शीघ्र ही

- अन्य

    शीघ्र ही

> किसी स्तर पर, हम `master` शाखा पृथक्करण को हटा देंगे और केवल एक `develop` शाखा बनाए रखेंगे। क्योंकि आश्रित CI/CD एकीकरण के माध्यम से स्थिरता बनाए रख सकते हैं। वर्तमान में, किसी उत्पादन-ग्रेड प्रोजेक्ट के लिए आँख मूंदकर `develop` शाखा पर निर्भर रहना कठिन है।

## स्थिर बनाम विकास

- `master` शाखा में नवीनतम `स्थिर` कोड होता है और यह `PyPi` रिपॉजिटरी और `docker.io` और `ghcr.io` रजिस्ट्रियों के माध्यम से `Docker` कंटेनरों में उपलब्ध है।

  `स्थिर` रिलीज़ के लिए रिपोर्ट की गई समस्याओं को सर्वोच्च प्राथमिकता दी जाती है। हालाँकि, वर्तमान में हम पुराने रिलीज़ में फिक्स बैकपोर्ट नहीं करते हैं। उदाहरण के लिए, यदि आपने `v2.3.1` में कोई समस्या रिपोर्ट की, लेकिन वर्तमान `master` शाखा में अब `v2.4.0rc1` है। तो, फिक्स `v2.4.0rc2` में आएगा।

- `develop` शाखा में अत्याधुनिक परिवर्तन होते हैं

  विकास शाखा को (अधिकांश समय) स्थिर रखा जाता है। **लेकिन**, यदि आप *100% विश्वसनीयता* चाहते हैं और *उत्पादन वातावरण* में उपयोगकर्ताओं की सेवा कर रहे हैं, तो हमेशा स्थिर संस्करण का उपयोग करें।

### रिलीज़ अनुसूची

एक `vX.Y.ZrcN` पुल अनुरोध महीने में एक बार बनाया जाता है जो `develop` → `master` को मर्ज करता है। नीचे देखें कि कोड एक पुल अनुरोध से अगले स्थिर रिलीज़ तक कैसे प्रवाहित होता है।

1. प्रत्येक पुल अनुरोध मर्ज के बाद `develop` → `test.pypi.org` से डेवलपमेंट रिलीज़ तैनात की जाती है

2. अल्फा रिलीज़ `develop` → `pypi.org` से `develop` → `master` शाखा में `vX.Y.Z.rcN` पुल अनुरोध को मर्ज करने **से पहले** तैनात की जाती है। `rc` पुल अनुरोध को मर्ज करने से पहले कई अल्फा रिलीज़ किए जा सकते हैं

3. बीटा रिलीज़ `master` → `pypi.org` से तैनात की जाती है। बीटा रिलीज़ `rc` रिलीज़ की तैयारी में की जाती है और यदि आवश्यक न हो तो इसे छोड़ा जा सकता है

4. रिलीज़ कैंडिडेट `master` → `pypi.org` से तैनात किया जाता है। रिलीज़ कैंडिडेट हमेशा अंतिम स्थिर रिलीज़ से पहले उपलब्ध कराए जाते हैं

5. स्थिर रिलीज़ `master` → `pypi.org` से तैनात की जाती है

## थ्रेड्स बनाम थ्रेडलेस

### `v1.x`

`proxy.py` क्लाइंट अनुरोधों को संभालने के लिए नए थ्रेड्स बनाता था।

### `v2.0+`

`proxy.py` ने `asyncio` का उपयोग करके क्लाइंट अनुरोधों के थ्रेडलेस निष्पादन के लिए समर्थन जोड़ा।

### `v2.4.0+`

`mac` और `linux` वातावरणों पर `Python 3.8+` के लिए थ्रेडलेस निष्पादन को डिफ़ॉल्ट रूप से चालू किया गया था।

हमारे उपयोगकर्ताओं द्वारा इन वातावरणों पर `proxy.py` थ्रेडलेस निष्पादन को सुरक्षित बताया गया है। यदि आप समस्या में भाग रहे हैं, तो `--threaded` फ़्लैग का उपयोग करके थ्रेडेड मोड पर वापस आएँ।

`windows` और `Python < 3.8` के लिए, आप अभी भी `proxy.py` को `--threadless` फ़्लैग के साथ प्रारंभ करके थ्रेडलेस मोड आज़मा सकते हैं।

यदि थ्रेडलेस आपके लिए काम करता है, तो `proxy/common/constants.py` फ़ाइल में `_env_threadless_compliant` विधि को संपादित करके PR भेजने पर विचार करें।

## थ्रेडलेस रिमोट बनाम स्थानीय निष्पादन मोड

मूल थ्रेडलेस कार्यान्वयन में `रिमोट` निष्पादन मोड का उपयोग किया गया था। इसे [उच्च स्तरीय आर्किटेक्चर](#high-level-architecture) के अंतर्गत ASCII कला के रूप में भी दर्शाया गया है।

`रिमोट` निष्पादन मोड में, स्वीकर्ता आने वाले क्लाइंट कनेक्शन प्रसंस्करण को एक रिमोट वर्कर प्रक्रिया को सौंपते हैं। डिफ़ॉल्ट रूप से, स्वीकर्ता कनेक्शन को राउंड-रॉबिन फैशन में सौंपते हैं। अनुरोध को संसाधित करने वाला वर्कर उसी CPU कोर पर चल रहा हो सकता है या नहीं भी हो सकता है जिस पर स्वीकर्ता चल रहा है। यह आर्किटेक्चर उच्च थ्रूपुट के लिए अच्छी तरह से स्केल करता है, लेकिन इसके परिणामस्वरूप प्रति CPU कोर दो प्रक्रियाएँ उत्पन्न होती हैं।

उदाहरण के लिए, यदि मशीन पर N-CPU हैं, तो डिफ़ॉल्ट रूप से, N स्वीकर्ता और N वर्कर प्रक्रियाएँ शुरू की जाती हैं। आप `--num-acceptors` और `--num-workers` फ़्लैग का उपयोग करके प्रक्रियाओं की संख्या को ट्यून कर सकते हैं। आप अपने उपयोग के मामले के आधार पर स्वीकर्ता से अधिक वर्कर या इसके विपरीत चाह सकते हैं।

v2.4.x में, `स्थानीय` निष्पादन मोड जोड़ा गया था, मुख्य रूप से डिफ़ॉल्ट रूप से उत्पन्न प्रक्रियाओं की संख्या को कम करने के लिए। यह मॉडल दिन-प्रतिदिन के एकल उपयोगकर्ता उपयोग के मामलों और डेवलपर परीक्षण परिदृश्यों के लिए अच्छा काम करता है। `स्थानीय` निष्पादन मोड में, स्वीकर्ता क्लाइंट कनेक्शन को एक रिमोट प्रक्रिया के बजाय एक साथी थ्रेड को सौंपते हैं। `स्थानीय` निष्पादन मोड CPU आत्मीयता सुनिश्चित करता है, `रिमोट` मोड के विपरीत जहाँ स्वीकर्ता और वर्कर विभिन्न CPU कोर पर चल रहे हो सकते हैं।

`--local-executor 1` को v2.4.x श्रृंखला में डिफ़ॉल्ट बनाया गया था। `स्थानीय` निष्पादन मोड में, `--num-workers` फ़्लैग का कोई प्रभाव नहीं होता, क्योंकि कोई रिमोट वर्कर शुरू नहीं किए जाते हैं।

`रिमोट` निष्पादन मोड का उपयोग करने के लिए, `--local-executor 0` फ़्लैग का उपयोग करें। फिर वर्कर प्रक्रियाओं की संख्या को ट्यून करने के लिए `--num-workers` का उपयोग करें।

## SyntaxError: अमान्य सिंटैक्स

`proxy.py` सख्ती से टाइप किया गया है और Python `typing` एनोटेशन का उपयोग करता है। उदाहरण:```python
>>> my_strings : List[str] = []
>>> #############^^^^^^^^^#####
```
इसलिए, एक Python संस्करण जो typing annotations को समझता है, आवश्यक है।
सुनिश्चित करें कि आप `Python 3.6+` का उपयोग कर रहे हैं।

`proxy.py` चलाने से पहले संस्करण की जाँच करें:

`❯ python --version`

सभी `typing` annotations को `comment-only` annotations से बदला जा सकता है। उदाहरण:```python
>>> my_strings = [] # List[str]
>>> ################^^^^^^^^^^^
```
यह `proxy.py` को Python `pre-3.6`, यहाँ तक कि `2.7` पर चलाने में सक्षम बनाएगा।
हालाँकि, Python के सभी भविष्य के संस्करण `typing` एनोटेशन का समर्थन करेंगे,
इस पर विचार नहीं किया गया है।

## प्लगइन लोड करने में असमर्थ

सुनिश्चित करें कि प्लगइन मॉड्यूल `PYTHONPATH` में जोड़कर खोजे जा सकें। उदाहरण:

`PYTHONPATH=/path/to/my/app proxy --plugins my_app.proxyPlugin````console
...[redacted]... - Loaded plugin proxy.HttpProxyPlugin