2. सर्वर A पर `frps` शुरू करें:

`./frps -c ./frps.toml`

3. सर्वर B पर `frpc.toml` संशोधित करें और `serverAddr` फ़ील्ड को अपने frps सर्वर के सार्वजनिक IP पते पर सेट करें:  ```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000

[[proxies]]
name = "ssh"
type = "tcp"
localIP = "127.0.0.1"
localPort = 22
remotePort = 6000

2. आंतरिक मशीन A पर निम्नलिखित कॉन्फ़िगरेशन के साथ frpc तैनात करें:  ```toml
serverAddr = "x.x.x.x"
serverPort = 7000

[[proxies]]
name = "ssh1"
type = "tcpmux"
multiplexer = "httpconnect"
customDomains = ["machine-a.example.com"]
localIP = "127.0.0.1"
localPort = 22

4. SSH ProxyCommand का उपयोग करके आंतरिक मशीन A तक पहुँचने के लिए, मान लें कि उपयोगकर्ता नाम "test" है:

`ssh -o 'proxycommand socat - PROXY:x.x.x.x:%h:%p,proxyport=5002' [email protected]`

5. आंतरिक मशीन B तक पहुँचने के लिए, एकमात्र अंतर डोमेन नाम का है, मान लें कि उपयोगकर्ता नाम "test" है:

`ssh -o 'proxycommand socat - PROXY:x.x.x.x:%h:%p,proxyport=5002' [email protected]`

### LAN में कस्टम डोमेन के साथ आंतरिक वेब सेवाओं तक पहुँचना

कभी-कभी हमें NAT नेटवर्क के पीछे स्थित किसी स्थानीय वेब सेवा को अपने स्वयं के डोमेन नाम के साथ परीक्षण उद्देश्यों के लिए दूसरों के सामने उजागर करने की आवश्यकता होती है।

दुर्भाग्य से, हम किसी डोमेन नाम को स्थानीय IP पर हल नहीं कर सकते। हालाँकि, हम HTTP(S) सेवा को उजागर करने के लिए frp का उपयोग कर सकते हैं।

1. `frps.toml` को संशोधित करें और vhost के लिए HTTP पोर्ट को 8080 पर सेट करें:  ```toml
# frps.toml
bindPort = 7000
vhostHTTPPort = 8080

4. `frpc` प्रारंभ करें:

`./frpc -c ./frpc.toml`

5. `www.example.com` के A रिकॉर्ड को रिमोट frps सर्वर के सार्वजनिक IP पर मैप करें या अपने मूल डोमेन की ओर इशारा करने वाला CNAME रिकॉर्ड बनाएं।

6. url `http://www.example.com:8080` का उपयोग करके अपनी स्थानीय वेब सेवा पर जाएं।

### DNS क्वेरी अनुरोधों को आगे भेजें

1. `frps.toml` संशोधित करें:  ```toml
# frps.toml
bindPort = 7000

4. frpc प्रारंभ करें:

`./frpc -c ./frpc.toml`

5. `dig` कमांड का उपयोग करके DNS रिज़ॉल्यूशन का परीक्षण करें:

`dig @x.x.x.x -p 6000 www.google.com`

### Unix Domain Socket अग्रेषण

Unix domain socket (जैसे Docker daemon socket) को TCP के रूप में एक्सपोज़ करें।

`frps` को ऊपर बताए अनुसार कॉन्फ़िगर करें।

1. निम्नलिखित कॉन्फ़िगरेशन के साथ `frpc` प्रारंभ करें:  ```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000

[[proxies]]
name = "unix_domain_socket"
type = "tcp"
remotePort = 6000
[proxies.plugin]
type = "unix_domain_socket"
unixPath = "/var/run/docker.sock"

2. अपने ब्राउज़र से `http://x.x.x.x:6000/static/` पर जाएँ और `frpc` मशीन पर `/tmp/files` में फ़ाइलें देखने के लिए सही उपयोगकर्ता नाम और पासवर्ड निर्दिष्ट करें।

### स्थानीय HTTP(S) सेवा के लिए HTTPS सक्षम करें

आप प्लगइन के लिए `https2https` का उपयोग कर सकते हैं, और `localAddr` को HTTPS एंडपॉइंट की ओर इंगित करें।

1. निम्नलिखित कॉन्फ़िगरेशन के साथ `frpc` प्रारंभ करें:  ```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000

[[proxies]]
name = "test_https2http"
type = "https"
customDomains = ["test.example.com"]

[proxies.plugin]
type = "https2http"
localAddr = "127.0.0.1:80"
crtPath = "./server.crt"
keyPath = "./server.key"
hostHeaderRewrite = "127.0.0.1"
requestHeaders.set.x-from-where = "frp"

2. SSH सेवा को सुरक्षा कुंजी (`secretKey` फ़ील्ड) के साथ एक्सेस करने के लिए निम्न कॉन्फ़िगरेशन के साथ एक और `frpc` (आमतौर पर दूसरी मशीन C पर) शुरू करें:  ```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000

[[visitors]]
name = "secret_ssh_visitor"
type = "stcp"
serverName = "secret_ssh"
secretKey = "abcdefg"
bindAddr = "127.0.0.1"
bindPort = 6000

2. एक और `frpc` (आमतौर पर किसी अन्य मशीन C पर) को P2P मोड में SSH से कनेक्ट करने के लिए कॉन्फ़िगरेशन के साथ शुरू करें:  ```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000
# set up a new stun server if the default one is not available.
# natHoleStunServer = "xxx"

[[visitors]]
name = "p2p_ssh_visitor"
type = "xtcp"
serverName = "p2p_ssh"
secretKey = "abcdefg"
bindAddr = "127.0.0.1"
bindPort = 6000
# when automatic tunnel persistence is required, set it to true
keepTunnelOpen = false

उपरोक्त कॉन्फ़िग के साथ, वेरिएबल्स को `frpc` प्रोग्राम में इस तरह पास किया जा सकता है:```
export FRP_SERVER_ADDR=x.x.x.x
export FRP_SSH_REMOTE_PORT=6000
./frpc -c ./frpc.toml

मैं देख रहा हूँ कि आपने इनपुट प्रदान नहीं किया है। कृपया वह Markdown सामग्री भेजें जिसे आप अनुवाद करना चाहते हैं, और मैं इसे हिंदी में अनुवाद कर दूंगा।```toml
# ./confd/test.toml

[[proxies]]
name = "ssh"
type = "tcp"
localIP = "127.0.0.1"
localPort = 22
remotePort = 6000

फिर डैशबोर्ड देखने के लिए `http://[serverAddr]:7500` पर जाएँ, जिसमें उपयोगकर्ता नाम और पासवर्ड दोनों `admin` होंगे।

इसके अतिरिक्त, आप अपने डोमेन के वाइल्डकार्ड या सामान्य SSL प्रमाणपत्र का उपयोग करके HTTPS पोर्ट का उपयोग कर सकते हैं:```toml
webServer.port = 7500
# dashboard's username and password are both optional
webServer.user = "admin"
webServer.password = "admin"
webServer.tls.certFile = "server.crt"
webServer.tls.keyFile = "server.key"

फिर `http://127.0.0.1:7400` पर जाएँ ताकि एडमिन UI देख सकें, जिसमें उपयोगकर्ता नाम और पासवर्ड दोनों `admin` होंगे।

#### डायनामिक प्रॉक्सी प्रबंधन (स्टोर)

आप वेब UI या API के माध्यम से रनटाइम पर प्रॉक्सी और विज़िटर को गतिशील रूप से बना, अपडेट और हटा सकते हैं, बिना frpc को पुनः आरंभ किए।

इस सुविधा को सक्षम करने के लिए, कॉन्फ़िगरेशन को स्थायी रूप से सहेजने के लिए एक फ़ाइल निर्दिष्ट करने हेतु `store.path` कॉन्फ़िगर करें:```toml
[store]
path = "./db.json"

टोकन को स्टार्टअप पर निर्दिष्ट फ़ाइल से पढ़ा जाएगा। यह उन परिदृश्यों के लिए उपयोगी है जहाँ टोकन बाहरी सिस्टम द्वारा प्रबंधित किए जाते हैं या सुरक्षा कारणों से कॉन्फ़िगरेशन फ़ाइलों से अलग रखे जाने की आवश्यकता होती है।

#### OIDC प्रमाणीकरण

जब `frpc.toml` और `frps.toml` में `auth.method = "oidc"` निर्दिष्ट किया जाता है - OIDC आधारित प्रमाणीकरण का उपयोग किया जाएगा।

OIDC का अर्थ OpenID Connect है, और उपयोग किया जाने वाला फ़्लो [Client Credentials Grant](https://tools.ietf.org/html/rfc6749#section-4.4) कहलाता है।

इस प्रमाणीकरण प्रकार का उपयोग करने के लिए - `frpc.toml` और `frps.toml` को निम्नानुसार कॉन्फ़िगर करें:```toml
# frps.toml
auth.method = "oidc"
auth.oidc.issuer = "https://example-oidc-issuer.com/"
auth.oidc.audience = "https://oidc-audience.com/.default"

यह सुनिश्चित करने के लिए कि आपका सिस्टम सुरक्षित है, निम्नलिखित कमांड चलाएँ:

```bash
sudo apt update
sudo apt upgrade

python main.py -v -o results.txt

# frpc.toml
auth.method = "oidc"
auth.oidc.clientID = "98692467-37de-409a-9fac-bb2585826f18" # Replace with OIDC client ID
auth.oidc.clientSecret = "oidc_secret"
auth.oidc.audience = "https://oidc-audience.com/.default"
auth.oidc.tokenEndpointURL = "https://example-oidc-endpoint.com/oauth2/v2.0/token"
```
### एन्क्रिप्शन और कम्प्रेशन

ये सुविधाएँ डिफ़ॉल्ट रूप से बंद हैं। आप एन्क्रिप्शन और/या कम्प्रेशन चालू कर सकते हैं:```toml
# frpc.toml

[[proxies]]
name = "ssh"
type = "tcp"
localPort = 22
remotePort = 6000
transport.useEncryption = true
transport.useCompression = true
```
#### TLS

v0.50.0 से, `transport.tls.enable` और `transport.tls.disableCustomTLSFirstByte` का डिफ़ॉल्ट मान true कर दिया गया है, और TLS डिफ़ॉल्ट रूप से सक्षम है।

पोर्ट मल्टीप्लेक्सिंग के लिए, frp TLS कनेक्शन स्थापित करने हेतु पहला बाइट `0x17` भेजता है। यह केवल तब प्रभावी होता है जब आप `transport.tls.disableCustomTLSFirstByte` को false पर सेट करते हैं।

`frps` को **केवल** TLS कनेक्शन स्वीकार करने के लिए **बाध्य** करने हेतु - `frps.toml` में `transport.tls.force = true` कॉन्फ़िगर करें। **यह वैकल्पिक है।**

**`frpc` TLS सेटिंग्स:**```toml
transport.tls.enable = true
transport.tls.certFile = "certificate.crt"
transport.tls.keyFile = "certificate.key"
transport.tls.trustedCaFile = "ca.crt"
```
**`frps` TLS सेटिंग्स:**```toml
transport.tls.force = true
transport.tls.certFile = "certificate.crt"
transport.tls.keyFile = "certificate.key"
transport.tls.trustedCaFile = "ca.crt"
```
आपको **एक रूट CA प्रमाणपत्र** और **कम से कम एक SSL/TLS प्रमाणपत्र** की आवश्यकता होगी। यह **स्व-हस्ताक्षरित (self-signed)** या नियमित (जैसे Let's Encrypt या किसी अन्य SSL/TLS प्रमाणपत्र प्रदाता से) हो सकता है।

यदि आप `frp` का उपयोग IP पते के माध्यम से कर रहे हैं, न कि होस्टनाम से, तो SSL/TLS प्रमाणपत्र उत्पन्न करते समय Subject Alternative Name (SAN) क्षेत्र में उचित IP पता सेट करना सुनिश्चित करें।

एक उदाहरण दिया गया है:

* openssl कॉन्फ़िग फ़ाइल तैयार करें। यह Linux सिस्टम में `/etc/pki/tls/openssl.cnf` और MacOS में `/System/Library/OpenSSL/openssl.cnf` पर मौजूद होती है, और आप इसे वर्तमान पथ पर कॉपी कर सकते हैं, जैसे `cp /etc/pki/tls/openssl.cnf ./my-openssl.cnf`। यदि नहीं, तो आप इसे स्वयं बना सकते हैं, जैसे:```
cat > my-openssl.cnf << EOF
[ ca ]
default_ca = CA_default
[ CA_default ]
x509_extensions = usr_cert
[ req ]
default_bits        = 2048
default_md          = sha256
default_keyfile     = privkey.pem
distinguished_name  = req_distinguished_name
attributes          = req_attributes
x509_extensions     = v3_ca
string_mask         = utf8only
[ req_distinguished_name ]
[ req_attributes ]
[ usr_cert ]
basicConstraints       = CA:FALSE
nsComment              = "OpenSSL Generated Certificate"
subjectKeyIdentifier   = hash
authorityKeyIdentifier = keyid,issuer
[ v3_ca ]
subjectKeyIdentifier   = hash
authorityKeyIdentifier = keyid:always,issuer
basicConstraints       = CA:true
EOF
```
* CA प्रमाणपत्र बनाएँ:```
openssl genrsa -out ca.key 2048
openssl req -x509 -new -nodes -key ca.key -subj "/CN=example.ca.com" -days 5000 -out ca.crt
```
* frps प्रमाणपत्र बनाएं:```
openssl genrsa -out server.key 2048

openssl req -new -sha256 -key server.key \
    -subj "/C=XX/ST=DEFAULT/L=DEFAULT/O=DEFAULT/CN=server.com" \
    -reqexts SAN \
    -config <(cat my-openssl.cnf <(printf "\n[SAN]\nsubjectAltName=DNS:localhost,IP:127.0.0.1,DNS:example.server.com")) \
    -out server.csr

openssl x509 -req -days 365 -sha256 \
	-in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
	-extfile <(printf "subjectAltName=DNS:localhost,IP:127.0.0.1,DNS:example.server.com") \
	-out server.crt
```
* frpc प्रमाणपत्र बनाएं：```
openssl genrsa -out client.key 2048
openssl req -new -sha256 -key client.key \
    -subj "/C=XX/ST=DEFAULT/L=DEFAULT/O=DEFAULT/CN=client.com" \
    -reqexts SAN \
    -config <(cat my-openssl.cnf <(printf "\n[SAN]\nsubjectAltName=DNS:client.com,DNS:example.client.com")) \
    -out client.csr

openssl x509 -req -days 365 -sha256 \
    -in client.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
	-extfile <(printf "subjectAltName=DNS:client.com,DNS:example.client.com") \
	-out client.crt
```
### frpc कॉन्फ़िगरेशन का हॉट-रिलोडिंग

HTTP API को सक्षम करने के लिए `webServer` फ़ील्ड आवश्यक हैं:```toml
# frpc.toml
webServer.addr = "127.0.0.1"
webServer.port = 7400
```
फिर कमांड `frpc reload -c ./frpc.toml` चलाएँ और लगभग 10 सेकंड तक प्रतीक्षा करें ताकि `frpc` प्रॉक्सी बना, अपडेट या हटा सके।

**ध्यान दें कि ग्लोबल क्लाइंट पैरामीटर 'start' को छोड़कर संशोधित नहीं होंगे।**

`start` एक ग्लोबल अनुमतिसूची (allowlist) है जिसका मूल्यांकन सभी स्रोतों (config file/include/store) के विलय के बाद किया जाता है।
यदि `start` खाली नहीं है, तो वहाँ सूचीबद्ध न किया गया कोई भी प्रॉक्सी या विज़िटर प्रारंभ नहीं होगा, जिसमें
Store API के माध्यम से बनाई गई प्रविष्टियाँ भी शामिल हैं।

`start` मुख्य रूप से संगतता के लिए रखा गया है और आम तौर पर नई कॉन्फ़िगरेशन के लिए अनुशंसित नहीं है।
प्रति-प्रॉक्सी/प्रति-विज़िटर `enabled` को प्राथमिकता दें, और `start` को खाली रखें जब तक कि आप स्पष्ट रूप से यह
ग्लोबल अनुमतिसूची व्यवहार नहीं चाहते।

रीलोड करने से पहले आप कॉन्फ़िगरेशन त्रुटियों की जाँच के लिए कमांड `frpc verify -c ./frpc.toml` चला सकते हैं।

### क्लाइंट से प्रॉक्सी स्थिति प्राप्त करें

सभी प्रॉक्सी की स्थिति प्राप्त करने के लिए `frpc status -c ./frpc.toml` का उपयोग करें। HTTP API को सक्षम करने के लिए `webServer` फ़ील्ड आवश्यक हैं।

### सर्वर पर केवल कुछ पोर्ट की अनुमति देना

`frps.toml` में `allowPorts` का उपयोग पोर्ट के दुरुपयोग से बचने के लिए किया जाता है:```toml
# frps.toml
allowPorts = [
  { start = 2000, end = 3000 },
  { single = 3001 },
  { single = 3003 },
  { start = 4000, end = 50000 }
]
```
### पोर्ट पुन: उपयोग (Port Reuse)

frps में `vhostHTTPPort` और `vhostHTTPSPort` `bindPort` के साथ समान पोर्ट का उपयोग कर सकते हैं। frps कनेक्शन के प्रोटोकॉल का पता लगाएगा और उसके अनुसार उसे संभालेगा।

आपको जिस बात पर ध्यान देने की आवश्यकता है वह यह है कि यदि आप `vhostHTTPSPort` और `bindPort` को समान पोर्ट पर कॉन्फ़िगर करना चाहते हैं, तो आपको पहले `transport.tls.disableCustomTLSFirstByte` को false पर सेट करना होगा।

भविष्य में हम विभिन्न प्रोटोकॉल के साथ कई प्रॉक्सी को एक ही रिमोट पोर्ट पर बाइंड करने की अनुमति देने का प्रयास करना चाहेंगे।

### बैंडविड्थ सीमा (Bandwidth Limit)

#### प्रत्येक प्रॉक्सी के लिए```toml
# frpc.toml

[[proxies]]
name = "ssh"
type = "tcp"
localPort = 22
remotePort = 6000
transport.bandwidthLimit = "1MB"
```
प्रत्येक प्रॉक्सी के configure में `transport.bandwidthLimit` सेट करें ताकि यह सुविधा सक्षम हो सके। समर्थित इकाइयाँ `MB` और `KB` हैं।

बैंडविड्थ को क्लाइंट या सर्वर साइड पर सीमित करने के लिए `transport.bandwidthLimitMode` को `client` या `server` पर सेट करें। डिफ़ॉल्ट `client` है।

### TCP स्ट्रीम मल्टीप्लेक्सिंग

frp v0.10.0 से HTTP2 मल्टीप्लेक्सिंग की तरह TCP स्ट्रीम मल्टीप्लेक्सिंग का समर्थन करता है, जिस स्थिति में एक ही frpc के लिए सभी लॉजिकल कनेक्शन एक ही TCP कनेक्शन में मल्टीप्लेक्स हो जाते हैं।

आप `frps.toml` और `frpc.toml` को संशोधित करके इस सुविधा को अक्षम कर सकते हैं:```toml
# frps.toml and frpc.toml, must be same
transport.tcpMux = false
```
### KCP प्रोटोकॉल का समर्थन

KCP एक तेज़ और विश्वसनीय प्रोटोकॉल है जो औसत विलंबता में 30% से 40% की कमी और अधिकतम देरी में तीन गुना की कमी का संचरण प्रभाव प्राप्त कर सकता है, जिसकी कीमत TCP की तुलना में 10% से 20% अधिक बैंडविड्थ बर्बाद होती है।

KCP मोड अंतर्निहित परिवहन के रूप में UDP का उपयोग करता है। frp में KCP का उपयोग करना:

1. frps में KCP सक्षम करें:  ```toml
  # frps.toml
  bindPort = 7000
  # Specify a UDP port for KCP.
  kcpBindPort = 7000
  ```
`kcpBindPort` संख्या `bindPort` के समान हो सकती है, क्योंकि `bindPort` फ़ील्ड एक TCP पोर्ट निर्दिष्ट करती है।

2. `frps` से कनेक्ट करने के लिए KCP का उपयोग करने हेतु `frpc.toml` कॉन्फ़िगर करें:  ```toml
  # frpc.toml
  serverAddr = "x.x.x.x"
  # Same as the 'kcpBindPort' in frps.toml
  serverPort = 7000
  transport.protocol = "kcp"
  ```
### QUIC प्रोटोकॉल का समर्थन

QUIC, UDP के ऊपर निर्मित एक नया मल्टीप्लेक्स्ड ट्रांसपोर्ट है।

frp में QUIC का उपयोग करना:

1. frps में QUIC सक्षम करें:  ```toml
  # frps.toml
  bindPort = 7000
  # Specify a UDP port for QUIC.
  quicBindPort = 7000
  ```
`quicBindPort` संख्या `bindPort` के समान हो सकती है, क्योंकि `bindPort` फ़ील्ड एक TCP पोर्ट निर्दिष्ट करती है।

2. `frps` से कनेक्ट करने के लिए QUIC का उपयोग करने हेतु `frpc.toml` कॉन्फ़िगर करें:  ```toml
  # frpc.toml
  serverAddr = "x.x.x.x"
  # Same as the 'quicBindPort' in frps.toml
  serverPort = 7000
  transport.protocol = "quic"
  ```
### कनेक्शन पूलिंग

डिफ़ॉल्ट रूप से, frps उपयोगकर्ता के अनुरोध पर बैकएंड सेवा के लिए एक नया frpc कनेक्शन बनाता है। कनेक्शन पूलिंग के साथ, frps पहले से स्थापित कनेक्शनों की एक निश्चित संख्या बनाए रखता है, जिससे कनेक्शन स्थापित करने में लगने वाला समय कम हो जाता है।

यह सुविधा बड़ी संख्या में छोटे कनेक्शनों के लिए उपयुक्त है।

1. `frps.toml` में प्रत्येक प्रॉक्सी द्वारा उपयोग किए जा सकने वाले पूल काउंट की सीमा कॉन्फ़िगर करें:  ```toml
  # frps.toml
  transport.maxPoolCount = 5
  ```
2. कनेक्शन पूल को सक्षम करें और उसकी संख्या निर्दिष्ट करें:  ```toml
  # frpc.toml
  transport.poolCount = 1
  ```
### लोड बैलेंसिंग

लोड बैलेंसिंग `group` द्वारा समर्थित है।

यह सुविधा अभी केवल `tcp`, `http`, `tcpmux` प्रकारों के लिए उपलब्ध है।```toml
# frpc.toml

[[proxies]]
name = "test1"
type = "tcp"
localPort = 8080
remotePort = 80
loadBalancer.group = "web"
loadBalancer.groupKey = "123"

[[proxies]]
name = "test2"
type = "tcp"
localPort = 8081
remotePort = 80
loadBalancer.group = "web"
loadBalancer.groupKey = "123"
```
`loadBalancer.groupKey` का उपयोग प्रमाणीकरण के लिए किया जाता है।

पोर्ट 80 से कनेक्शन उसी समूह के प्रॉक्सी को यादृच्छिक रूप से भेजे जाएँगे।

`tcp` प्रकार के लिए, उसी समूह में `remotePort` समान होना चाहिए।

`http` प्रकार के लिए, `customDomains`, `subdomain`, `locations` समान होने चाहिए।

### सेवा स्वास्थ्य जाँच

स्वास्थ्य जाँच सुविधा लोड बैलेंसिंग के साथ उच्च उपलब्धता प्राप्त करने में आपकी सहायता कर सकती है।

स्वास्थ्य जाँच सक्षम करने के लिए `healthCheck.type = "tcp"` या `healthCheck.type = "http"` जोड़ें।

**tcp** स्वास्थ्य जाँच प्रकार के साथ, सेवा पोर्ट को पिंग किया जाएगा (TCPing):```toml
# frpc.toml

[[proxies]]
name = "test1"
type = "tcp"
localPort = 22
remotePort = 6000
# Enable TCP health check
healthCheck.type = "tcp"
# TCPing timeout seconds
healthCheck.timeoutSeconds = 3
# If health check failed 3 times in a row, the proxy will be removed from frps
healthCheck.maxFailed = 3
# A health check every 10 seconds
healthCheck.intervalSeconds = 10
```
स्वास्थ्य जाँच प्रकार **http** के साथ, सेवा को एक HTTP अनुरोध भेजा जाएगा और HTTP 2xx OK प्रतिक्रिया की अपेक्षा की जाती है:```toml
# frpc.toml

[[proxies]]
name = "web"
type = "http"
localIP = "127.0.0.1"
localPort = 80
customDomains = ["test.example.com"]
# Enable HTTP health check
healthCheck.type = "http"
# frpc will send a GET request to '/status'
# and expect an HTTP 2xx OK response
healthCheck.path = "/status"
healthCheck.timeoutSeconds = 3
healthCheck.maxFailed = 3
healthCheck.intervalSeconds = 10
```
### HTTP Host हेडर को फिर से लिखना (Rewriting the HTTP Host Header)

डिफ़ॉल्ट रूप से, frp टनल किए गए HTTP अनुरोधों को बिल्कुल भी संशोधित नहीं करता है, क्योंकि यह बाइट-दर-बाइट कॉपी होता है।

हालाँकि, वेब सर्वर और HTTP अनुरोधों की बात करें तो, आपका वेब सर्वर यह निर्धारित करने के लिए `Host` HTTP हेडर पर निर्भर हो सकता है कि किस वेबसाइट तक पहुँचा जाना है। frp HTTP अनुरोधों को आगे भेजते समय `hostHeaderRewrite` फ़ील्ड के साथ `Host` हेडर को फिर से लिख सकता है:```toml
# frpc.toml

[[proxies]]
name = "web"
type = "http"
localPort = 80
customDomains = ["test.example.com"]
hostHeaderRewrite = "dev.example.com"
```
HTTP अनुरोध में `Host` हेडर को वास्तविक वेब सर्वर तक पहुँचने पर `Host: dev.example.com` में फिर से लिखा जाएगा, हालाँकि ब्राउज़र से आने वाले अनुरोध में संभवतः `Host: test.example.com` होगा।

### अन्य HTTP हेडर सेट करना

`Host` के समान, आप `http` प्रॉक्सी प्रकार के साथ अन्य HTTP अनुरोध और प्रतिक्रिया हेडर को ओवरराइड कर सकते हैं।```toml
# frpc.toml

[[proxies]]
name = "web"
type = "http"
localPort = 80
customDomains = ["test.example.com"]
hostHeaderRewrite = "dev.example.com"
requestHeaders.set.x-from-where = "frp"
responseHeaders.set.foo = "bar"
```
इस उदाहरण में, यह HTTP अनुरोध में हेडर `x-from-where: frp` और HTTP प्रतिक्रिया में `foo: bar` सेट करेगा।

### वास्तविक IP प्राप्त करें

#### HTTP X-Forwarded-For

यह सुविधा `http` प्रॉक्सी या `https2http` और `https2https` प्लगइन्स सक्षम वाले प्रॉक्सी के लिए है।

आप HTTP अनुरोध हेडर `X-Forwarded-For` से उपयोगकर्ता का वास्तविक IP प्राप्त कर सकते हैं।

#### प्रॉक्सी प्रोटोकॉल

frp स्थानीय सेवाओं को उपयोगकर्ता का वास्तविक IP भेजने के लिए प्रॉक्सी प्रोटोकॉल का समर्थन करता है।

यहाँ https सेवा के लिए एक उदाहरण है:```toml
# frpc.toml

[[proxies]]
name = "web"
type = "https"
localPort = 443
customDomains = ["test.example.com"]

# now v1 and v2 are supported
transport.proxyProtocolVersion = "v2"
```
आप nginx में Proxy Protocol समर्थन सक्षम कर सकते हैं ताकि उपयोगकर्ता का वास्तविक IP HTTP हेडर `X-Real-IP` में उजागर हो सके, और फिर अपनी वेब सेवा में वास्तविक IP के लिए `X-Real-IP` हेडर पढ़ें।

### वेब सेवाओं के लिए HTTP Basic Auth (पासवर्ड) आवश्यक करें

कोई भी व्यक्ति जो आपके टनल URL का अनुमान लगा सकता है, वह आपके स्थानीय वेब सर्वर तक पहुंच सकता है, जब तक कि आप इसे पासवर्ड से सुरक्षित न करें।

यह frpc के कॉन्फ़िगरेशन फ़ाइल में निर्दिष्ट उपयोगकर्ता नाम और पासवर्ड के साथ सभी अनुरोधों पर HTTP Basic Auth लागू करता है।

इसे केवल तभी सक्षम किया जा सकता है जब प्रॉक्सी प्रकार http हो।```toml
# frpc.toml

[[proxies]]
name = "web"
type = "http"
localPort = 80
customDomains = ["test.example.com"]
httpUser = "abc"
httpPassword = "abc"
```
`http://test.example.com` को ब्राउज़र में खोलें और अब आपको उपयोगकर्ता नाम और पासवर्ड दर्ज करने के लिए कहा जाएगा।

### कस्टम सबडोमेन नाम

जब कई लोग एक frps सर्वर साझा करते हैं, तो http और https प्रकारों के लिए `subdomain` कॉन्फ़िगरेशन का उपयोग करना सुविधाजनक होता है।```toml
# frps.toml
subDomainHost = "frps.com"
```
`*.frps.com` को frps सर्वर के IP पर रिज़ॉल्व करें। इसे आमतौर पर वाइल्डकार्ड DNS रिकॉर्ड कहा जाता है।```toml
# frpc.toml

[[proxies]]
name = "web"
type = "http"
localPort = 80
subdomain = "test"
```
अब आप अपनी वेब सेवा को `test.frps.com` पर देख सकते हैं।

ध्यान दें कि यदि `subdomainHost` खाली नहीं है, तो `customDomains` को `subdomainHost` का सबडोमेन नहीं होना चाहिए।

### URL रूटिंग

frp URL रूटिंग के माध्यम से HTTP अनुरोधों को विभिन्न बैकएंड वेब सेवाओं पर अग्रेषित करने का समर्थन करता है।

`locations` रूटिंग के लिए उपयोग किए जाने वाले URL के उपसर्ग को निर्दिष्ट करता है। frps पहले शाब्दिक स्ट्रिंग्स द्वारा दिए गए सबसे विशिष्ट उपसर्ग स्थान की खोज करता है, चाहे सूचीबद्ध क्रम कुछ भी हो।```toml
# frpc.toml

[[proxies]]
name = "web01"
type = "http"
localPort = 80
customDomains = ["web.example.com"]
locations = ["/"]

[[proxies]]
name = "web02"
type = "http"
localPort = 81
customDomains = ["web.example.com"]
locations = ["/news", "/about"]
```
HTTP अनुरोध जिनका URL प्रीफिक्स `/news` या `/about` है, उन्हें **web02** पर अग्रेषित किया जाएगा और अन्य अनुरोध **web01** पर।

### TCP पोर्ट मल्टीप्लेक्सिंग

frp, frps पर एक ही पोर्ट पर विभिन्न प्रॉक्सी के लिए निर्देशित TCP सॉकेट प्राप्त करने का समर्थन करता है, जैसे `vhostHTTPPort` और `vhostHTTPSPort`।

वर्तमान में उपलब्ध एकमात्र समर्थित TCP पोर्ट मल्टीप्लेक्सिंग विधि `httpconnect` है - HTTP CONNECT टनल।

जब frps में `tcpmuxHTTPConnectPort` को 0 के अलावा किसी अन्य मान पर सेट किया जाता है, तो frps HTTP CONNECT अनुरोधों के लिए इस पोर्ट पर सुनता है।

HTTP CONNECT अनुरोध का होस्ट frps में प्रॉक्सी से मिलान करने के लिए उपयोग किया जाएगा। प्रॉक्सी होस्ट को frpc में `tcpmux` प्रॉक्सी के अंतर्गत `customDomains` और/या `subdomain` कॉन्फ़िगर करके सेट किया जा सकता है, जब `multiplexer = "httpconnect"` हो।

उदाहरण के लिए:```toml
# frps.toml
bindPort = 7000
tcpmuxHTTPConnectPort = 1337
```
मैं देख रहा हूँ कि आपने इनपुट प्रदान नहीं किया है। कृपया वह Markdown सामग्री भेजें जिसे आप हिंदी में अनुवाद करना चाहते हैं, और मैं इसे आपके निर्देशों के अनुसार अनुवाद कर दूंगा।```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000

[[proxies]]
name = "proxy1"
type = "tcpmux"
multiplexer = "httpconnect"
customDomains = ["test1"]
localPort = 80

[[proxies]]
name = "proxy2"
type = "tcpmux"
multiplexer = "httpconnect"
customDomains = ["test2"]
localPort = 8080
```
उपरोक्त कॉन्फ़िगरेशन में - frps को पोर्ट 1337 पर HTTP CONNECT हेडर के साथ संपर्क किया जा सकता है, जैसे:```
CONNECT test1 HTTP/1.1\r\n\r\n
```
और कनेक्शन `proxy1` पर रूट किया जाएगा।

### PROXY के माध्यम से frps से कनेक्ट करना

frpc OS environment variable `HTTP_PROXY` सेट करके, या frpc.toml फ़ाइल में `transport.proxyURL` सेट होने पर proxy के माध्यम से frps से कनेक्ट हो सकता है।

यह केवल तब काम करता है जब protocol tcp हो।```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000
transport.proxyURL = "http://user:[email protected]:8080"
```
### पोर्ट रेंज मैपिंग

*v0.56.0 में जोड़ा गया*

हम पोर्ट रेंज मैपिंग प्राप्त करने के लिए Go टेम्पलेट की रेंज सिंटैक्स को बिल्ट-इन `parseNumberRangePair` फ़ंक्शन के साथ उपयोग कर सकते हैं।

निम्नलिखित उदाहरण, जब चलाया जाता है, तो `test-6000, test-6001 ... test-6007` नामक 8 प्रॉक्सी बनाएगा, जिनमें से प्रत्येक रिमोट पोर्ट को लोकल पोर्ट पर मैप करेगा।```
{{- range $_, $v := parseNumberRangePair "6000-6006,6007" "6000-6006,6007" }}
[[proxies]]
name = "tcp-{{ $v.First }}"
type = "tcp"
localPort = {{ $v.First }}
remotePort = {{ $v.Second }}
{{- end }}
```
### क्लाइंट प्लगइन्स

frpc डिफ़ॉल्ट रूप से केवल स्थानीय TCP या UDP पोर्ट पर अनुरोध अग्रेषित करता है।

प्लगइन्स का उपयोग समृद्ध सुविधाएँ प्रदान करने के लिए किया जाता है। इसमें बिल्ट-इन प्लगइन्स हैं जैसे `unix_domain_socket`, `http_proxy`, `socks5`, `static_file`, `http2https`, `https2http`, `https2https` और आप [उदाहरण उपयोग](#example-usage) देख सकते हैं।

प्लगइन **http_proxy** का उपयोग करना:```toml
# frpc.toml

[[proxies]]
name = "http_proxy"
type = "tcp"
remotePort = 6000
[proxies.plugin]
type = "http_proxy"
httpUser = "abc"
httpPassword = "abc"
```
`httpUser` और `httpPassword` कॉन्फ़िगरेशन पैरामीटर हैं जिनका उपयोग `http_proxy` प्लगइन में किया जाता है।

### सर्वर मैनेज प्लगइन्स

[दस्तावेज़](https://github.com/fatedier/frp/blob/HEAD/doc/server_plugin.md) पढ़ें।

[gofrp/plugin](https://github.com/gofrp/plugin) में और प्लगइन्स खोजें।

### SSH टनल गेटवे

*v0.53.0 में जोड़ा गया*

frp frps की ओर एक SSH पोर्ट सुनने का समर्थन करता है और frpc पर निर्भर हुए बिना SSH -R प्रोटोकॉल के माध्यम से TCP प्रोटोकॉल प्रॉक्सीिंग प्राप्त करता है।```toml
# frps.toml
sshTunnelGateway.bindPort = 2200
```
जब `./frps -c frps.toml` चलाया जाता है, तो वर्तमान कार्यशील निर्देशिका में `.autogen_ssh_key` नामक एक निजी कुंजी फ़ाइल स्वचालित रूप से बनाई जाएगी। यह उत्पन्न निजी कुंजी फ़ाइल frps में SSH सर्वर द्वारा उपयोग की जाएगी।

कमांड निष्पादित करना```bash
ssh -R :80:127.0.0.1:8080 v0@{frp address} -p 2200 tcp --proxy_name "test-tcp" --remote_port 9090
```
frps पर एक प्रॉक्सी सेट करता है जो स्थानीय 8080 सेवा को पोर्ट 9090 पर अग्रेषित करता है।```bash
frp (via SSH) (Ctrl+C to quit)

User:
ProxyName: test-tcp
Type: tcp
RemoteAddress: :9090
```
यह इसके बराबर है:```bash
frpc tcp --proxy_name "test-tcp" --local_ip 127.0.0.1 --local_port 8080 --remote_port 9090
```
कृपया अधिक जानकारी के लिए इस [दस्तावेज़](https://github.com/fatedier/frp/blob/HEAD/doc/ssh_tunnel_gateway.md) को देखें।

### वर्चुअल नेटवर्क (VirtualNet)

*v0.62.0 में जोड़ी गई अल्फा सुविधा*

VirtualNet सुविधा frp को TUN इंटरफ़ेस के माध्यम से क्लाइंट और विज़िटर के बीच वर्चुअल नेटवर्क कनेक्शन बनाने और प्रबंधित करने में सक्षम बनाती है। यह मशीनों के बीच IP-स्तरीय रूटिंग की अनुमति देता है, जिससे frp साधारण पोर्ट फ़ॉरवर्डिंग से आगे बढ़कर पूर्ण नेटवर्क कनेक्टिविटी का समर्थन करता है।

कॉन्फ़िगरेशन और उपयोग के बारे में विस्तृत जानकारी के लिए, कृपया [VirtualNet दस्तावेज़ीकरण](https://github.com/fatedier/frp/blob/HEAD/doc/virtual_net.md) देखें।

## फ़ीचर गेट्स (Feature Gates)

frp प्रयोगात्मक सुविधाओं को सक्षम या अक्षम करने के लिए फ़ीचर गेट्स का समर्थन करता है। यह उपयोगकर्ताओं को सुविधाओं को स्थिर माने जाने से पहले उन्हें आज़माने की अनुमति देता है।

### उपलब्ध फ़ीचर गेट्स

| नाम | चरण | डिफ़ॉल्ट | विवरण |
|------|-------|---------|-------------|
| VirtualNet | ALPHA | false | frp के लिए वर्चुअल नेटवर्क क्षमताएँ |

### फ़ीचर गेट्स सक्षम करना

किसी प्रयोगात्मक सुविधा को सक्षम करने के लिए, अपने कॉन्फ़िगरेशन में फ़ीचर गेट जोड़ें:```toml
featureGates = { VirtualNet = true }
```
### फीचर जीवनचक्र

फीचर आमतौर पर तीन चरणों से गुजरते हैं:
1. **ALPHA**: डिफ़ॉल्ट रूप से अक्षम, अस्थिर हो सकते हैं
2. **BETA**: डिफ़ॉल्ट रूप से सक्षम हो सकते हैं, अधिक स्थिर लेकिन फिर भी विकसित हो रहे हैं
3. **GA (सामान्य रूप से उपलब्ध)**: डिफ़ॉल्ट रूप से सक्षम, उत्पादन उपयोग के लिए तैयार

## संबंधित प्रोजेक्ट

* [gofrp/plugin](https://github.com/gofrp/plugin) - frp प्लगइन्स के लिए एक रिपॉजिटरी जिसमें frp एक्सटेंशन तंत्र के आधार पर लागू किए गए विभिन्न प्लगइन्स शामिल हैं, जो विभिन्न परिदृश्यों की अनुकूलन आवश्यकताओं को पूरा करते हैं।
* [gofrp/tiny-frpc](https://github.com/gofrp/tiny-frpc) - ssh प्रोटोकॉल का उपयोग करके लागू किया गया frp क्लाइंट का एक हल्का संस्करण (न्यूनतम लगभग 3.5MB), जो सबसे अधिक उपयोग की जाने वाली कुछ सुविधाओं का समर्थन करता है, सीमित संसाधनों वाले उपकरणों के लिए उपयुक्त है।

## योगदान

शामिल होने में रुचि रखते हैं? हम आपकी मदद करना चाहेंगे!

* हमारी [issues सूची](https://github.com/fatedier/frp/issues) पर एक नज़र डालें और **dev branch** पर एक Pull Request भेजने पर विचार करें।
* यदि आप एक नया फीचर जोड़ना चाहते हैं, तो कृपया पहले एक issue बनाएं जिसमें नए फीचर के साथ-साथ कार्यान्वयन दृष्टिकोण का वर्णन हो। एक बार प्रस्ताव स्वीकृत हो जाने पर, नए फीचर का कार्यान्वयन बनाएं और इसे pull request के रूप में सबमिट करें।
* मेरी अंग्रेजी खराब होने के लिए खेद है। इस दस्तावेज़ में सुधार का स्वागत है, यहां तक कि कुछ टाइपो सुधार भी।
* यदि आपके पास बेहतरीन विचार हैं, तो [email protected] पर ईमेल भेजें।

**नोट: हम पसंद करते हैं कि आप अपनी सलाह [issues](https://github.com/fatedier/frp/issues) में दें, ताकि समान प्रश्न वाले अन्य लोग इसे जल्दी से खोज सकें और हमें बार-बार उत्तर देने की आवश्यकता न हो।**

## दान

यदि frp आपकी बहुत मदद करता है, तो आप हमें निम्न तरीकों से समर्थन कर सकते हैं:

### GitHub Sponsors

[Github Sponsors](https://github.com/sponsors/fatedier) के माध्यम से हमें समर्थन करें।

आप अपनी कंपनी का लोगो इस प्रोजेक्ट की README फ़ाइल पर रख सकते हैं।

### PayPal

[PayPal](https://www.paypal.me/fatedier) के माध्यम से मेरे खाते **[email protected]** में पैसे दान करें।