Toxiproxy

Toxiproxy नेटवर्क स्थितियों का अनुकरण करने के लिए एक फ्रेमवर्क है। इसे विशेष रूप से परीक्षण, CI और विकास वातावरणों में काम करने के लिए बनाया गया है, जो कनेक्शनों के साथ नियतात्मक छेड़छाड़ का समर्थन करता है, साथ ही यादृच्छिक अराजकता और अनुकूलन के लिए भी समर्थन प्रदान करता है। Toxiproxy वह उपकरण है जिसकी आपको यह साबित करने के लिए आवश्यकता है कि आपका एप्लिकेशन विफलता के एकल बिंदुओं से मुक्त है। हम अक्टूबर 2014 से Shopify पर सभी विकास और परीक्षण वातावरणों में इसे सफलतापूर्वक उपयोग कर रहे हैं। अधिक जानकारी के लिए सहनशीलता पर हमारा [ब्लॉग पोस्ट][blog] देखें।

Toxiproxy का उपयोग दो भागों में विभाजित है। एक TCP प्रॉक्सी जो Go में लिखा गया है (जो इस रिपॉजिटरी में शामिल है) और एक क्लाइंट जो HTTP के माध्यम से प्रॉक्सी के साथ संचार करता है। आप अपने एप्लिकेशन को कॉन्फ़िगर करते हैं ताकि सभी परीक्षण कनेक्शन Toxiproxy से होकर गुजरें और फिर HTTP के माध्यम से उनकी स्थिति में हेरफेर कर सकें। अपना प्रोजेक्ट सेट अप करने के तरीके के लिए नीचे Usage देखें।

उदाहरण के लिए, Ruby क्लाइंट से MySQL के प्रतिक्रिया में 1000ms की विलंबता जोड़ने के लिए:```ruby Toxiproxy[:mysql_master].downstream(:latency, latency: 1000).apply do Shop.first # this takes at least 1s end

सभी Redis इंस्टेंस को बंद करने के लिए:```ruby
Toxiproxy[/redis/].down do
  Shop.first # this will throw an exception
end

हालाँकि इस README के उदाहरण वर्तमान में Ruby में हैं, आपको किसी भी अन्य भाषा में क्लाइंट बनाने से कोई नहीं रोकता (देखें क्लाइंट्स).

विषय सूची

Toxiproxy

एक और अराजक TCP प्रॉक्सी क्यों?

हमें जो मौजूदा उपकरण मिले, उनमें वह डायनामिक API नहीं था जिसकी हमें इंटीग्रेशन और यूनिट टेस्टिंग के लिए ज़रूरत थी। Linux के nc जैसे उपकरण क्रॉस-प्लेटफ़ॉर्म नहीं हैं और उन्हें रूट की आवश्यकता होती है, जिससे वे टेस्ट, विकास और CI वातावरण में समस्याग्रस्त हो जाते हैं।

क्लाइंट्स

उदाहरण

आइए एक Rails एप्लिकेशन के साथ एक उदाहरण देखें। ध्यान दें कि Toxiproxy किसी भी तरह से Ruby से बंधा नहीं है, यह बस हमारा पहला उपयोग-मामला था। पूरा उदाहरण आप इस लिंक पर देख सकते हैं sirupsen/toxiproxy-rails-example. तुरंत शुरू करने के लिए, नीचे उपयोग पर जाएँ।

हमारे लोकप्रिय ब्लॉग के लिए, किसी कारण से हम अपने पोस्ट के टैग Redis में और पोस्ट खुद MySQL में संग्रहीत कर रहे हैं। हमारे पास एक Post क्लास हो सकती है जिसमें Redis set में टैग्स को संशोधित करने के कुछ तरीके शामिल हैं:```ruby class Post < ActiveRecord::Base

Return an Array of all the tags.

def tags TagRedis.smembers(tag_key) end

Add a tag to the post.

def add_tag(tag) TagRedis.sadd(tag_key, tag) end

Remove a tag from the post.

def remove_tag(tag) TagRedis.srem(tag_key, tag) end

Return the key in Redis for the set of tags for the post.

def tag_key "post:tags:#{self.id}" end end

हमने तय किया है कि टैग डेटा स्टोर में लिखते समय त्रुटि होना
(जोड़ना/हटाना) ठीक है। हालाँकि, यदि टैग डेटा स्टोर डाउन है, तो हमें
पोस्ट को बिना टैग के देखने में सक्षम होना चाहिए। हम बस
`Redis::CannotConnectError` को `tags` विधि में `SMEMBERS` Redis कॉल के आस-पास
रेस्क्यू कर सकते हैं। आइए इसका परीक्षण करने के लिए Toxiproxy का उपयोग करें।

चूँकि हमने पहले ही Toxiproxy स्थापित कर लिया है और यह हमारी मशीन पर चल रहा है, हम
चरण 2 पर जा सकते हैं। यहाँ हमें यह सुनिश्चित करने की आवश्यकता है कि Toxiproxy के पास
Redis टैग के लिए मैपिंग है। `config/boot.rb` में (कोई भी कनेक्शन बनाने से पहले) हम जोड़ते हैं:```ruby
require 'toxiproxy'

Toxiproxy.populate([
  {
    name: "toxiproxy_test_redis_tags",
    listen: "127.0.0.1:22222",
    upstream: "127.0.0.1:6379"
  }
])

फिर config/environments/test.rb में हम TagRedis को एक Redis क्लाइंट के रूप में सेट करते हैं जो Toxiproxy के माध्यम से Redis से जुड़ता है, यह पंक्ति जोड़कर:```ruby TagRedis = Redis.new(port: 22222)

परीक्षण वातावरण में सभी कॉल अब Toxiproxy से होकर जाती हैं। इसका मतलब है कि हम
एक यूनिट टेस्ट जोड़ सकते हैं जहाँ हम विफलता का अनुकरण करते हैं:```ruby
test "should return empty array when tag redis is down when listing tags" do
  @post.add_tag "mammals"

  # Take down all Redises in Toxiproxy
  Toxiproxy[/redis/].down do
    assert_equal [], @post.tags
  end
end

परीक्षण Redis::CannotConnectError के साथ विफल हो जाता है। बढ़िया! Toxiproxy ने क्लोज़र की अवधि के लिए सफलतापूर्वक Redis को डाउन कर दिया। आइए tags विधि को लचीला बनाने के लिए ठीक करें:```ruby def tags TagRedis.smembers(tag_key) rescue Redis::CannotConnectError [] end

परीक्षण पास हो गए! अब हमारे पास एक यूनिट टेस्ट है जो साबित करता है कि जब Redis
डाउन होता है तो टैग्स लाने पर एक खाली array मिलता है, बजाय exception फेंकने के। पूर्ण
कवरेज के लिए आपको एक इंटीग्रेशन टेस्ट भी लिखना चाहिए जो Redis के डाउन होने पर
पूरे ब्लॉग पोस्ट पेज को लाने की प्रक्रिया को कवर करता है।

पूर्ण उदाहरण एप्लिकेशन यहाँ है:
[sirupsen/toxiproxy-rails-example](https://github.com/sirupsen/toxiproxy-rails-example).

## उपयोग

Toxiproxy का उपयोग करने के लिए किसी प्रोजेक्ट को कॉन्फ़िगर करने में तीन चरण शामिल हैं:

1. Toxiproxy स्थापित करना
2. Toxiproxy को पॉप्युलेट करना
3. Toxiproxy का उपयोग करना

### 1. Toxiproxy स्थापित करना

**Linux**

अपनी आर्किटेक्चर के लिए नवीनतम बाइनरी और सिस्टम पैकेज हेतु
[`Releases`](https://github.com/Shopify/toxiproxy/releases) देखें।

**Ubuntu**```bash
$ wget -O toxiproxy-2.1.4.deb https://github.com/Shopify/toxiproxy/releases/download/v2.1.4/toxiproxy_2.1.4_amd64.deb
$ sudo dpkg -i toxiproxy-2.1.4.deb
$ sudo service toxiproxy start

OS X

Homebrew के साथ:```bash $ brew tap shopify/shopify $ brew install toxiproxy

या [MacPorts](https://www.macports.org/) के साथ:```bash
$ port install toxiproxy

विंडोज़

Toxiproxy for Windows निम्न लिंक पर डाउनलोड के लिए उपलब्ध है: https://github.com/Shopify/toxiproxy/releases/download/v2.1.4/toxiproxy-server-windows-amd64.exe

Docker

Toxiproxy Github container registry पर उपलब्ध है। पुराने संस्करण <= 2.1.4 Docker Hub पर उपलब्ध हैं।```bash $ docker pull ghcr.io/shopify/toxiproxy $ docker run --rm -it ghcr.io/shopify/toxiproxy

यदि अन्य कंटेनरों के बजाय होस्ट से Toxiproxy का उपयोग कर रहे हैं, तो `--net=host` के साथ होस्ट नेटवर्किंग सक्षम करें।```shell
$ docker run --rm --entrypoint="/toxiproxy-cli" -it ghcr.io/shopify/toxiproxy list

यदि आपके पास Go इंस्टॉल है, तो आप make file का उपयोग करके Toxiproxy को स्रोत से बना सकते हैं:```bash $ make build $ ./toxiproxy-server

#### Toxiproxy 1.x से अपग्रेड करना

Toxiproxy 2.0 में API में कई बदलाव किए गए हैं जो इसे संस्करण 1.x के साथ असंगत बनाते हैं।
Toxiproxy सर्वर के संस्करण 2.x का उपयोग करने के लिए, आपको यह सुनिश्चित करना होगा कि आपकी क्लाइंट
लाइब्रेरी उसी संस्करण का समर्थन करती है। आप `/version` एंडपॉइंट को देखकर जांच सकते हैं कि आप कौन सा Toxiproxy संस्करण चला रहे हैं।

अपनी क्लाइंट लाइब्रेरी के लिए विशिष्ट लाइब्रेरी परिवर्तनों हेतु उसका दस्तावेज़ देखें। Toxiproxy
सर्वर के विस्तृत परिवर्तन [CHANGELOG.md](https://github.com/shopify/toxiproxy/blob/HEAD/CHANGELOG.md) में पाए जा सकते हैं।

### 2. Toxiproxy को पॉप्युलेट करना

जब आपका एप्लिकेशन बूट होता है, तो उसे यह सुनिश्चित करने की आवश्यकता होती है कि Toxiproxy को पता हो कि कौन से
एंडपॉइंट कहाँ प्रॉक्सी करने हैं। मुख्य पैरामीटर हैं: नाम, Toxiproxy के **सुनने** के लिए पता, और अपस्ट्रीम का पता।

कुछ क्लाइंट लाइब्रेरी में इस कार्य हेतु सहायक (helpers) होते हैं, जो मूल रूप से यह सुनिश्चित करने के लिए होते हैं कि
सूची में प्रत्येक प्रॉक्सी बना दी गई है। Ruby क्लाइंट से उदाहरण:```ruby
# Make sure `shopify_test_redis_master` and `shopify_test_mysql_master` are
# present in Toxiproxy
Toxiproxy.populate([
  {
    name: "shopify_test_redis_master",
    listen: "127.0.0.1:22220",
    upstream: "127.0.0.1:6379"
  },
  {
    name: "shopify_test_mysql_master",
    listen: "127.0.0.1:24220",
    upstream: "127.0.0.1:3306"
  }
])

यह कोड बूट में जितनी जल्दी हो सके चलना चाहिए, इससे पहले कि कोई भी कोड Toxiproxy के माध्यम से कनेक्शन स्थापित करे। कृपया population helpers के दस्तावेज़ीकरण के लिए अपने क्लाइंट लाइब्रेरी की जाँच करें।

वैकल्पिक रूप से proxies बनाने के लिए CLI का उपयोग करें, उदाहरण के लिए:```bash toxiproxy-cli create -l localhost:26379 -u localhost:6379 shopify_test_redis_master

हम ऊपर दिए गए जैसे नामकरण की सलाह देते हैं: `<app>_<env>_<data store>_<shard>`।
यह सुनिश्चित करता है कि एक ही Toxiproxy का उपयोग करने वाले अनुप्रयोगों के बीच कोई टकराव न हो।

बड़े अनुप्रयोगों के लिए हम Toxiproxy कॉन्फ़िगरेशन को एक अलग कॉन्फ़िगरेशन फ़ाइल में संग्रहीत करने की सलाह देते हैं। हम `config/toxiproxy.json` का उपयोग करते हैं। इस फ़ाइल को `-config` विकल्प का उपयोग करके सर्वर को पास किया जा सकता है, या `populate` फ़ंक्शन के साथ उपयोग करने के लिए अनुप्रयोग द्वारा लोड किया जा सकता है।

एक उदाहरण `config/toxiproxy.json`:```json
[
  {
    "name": "web_dev_frontend_1",
    "listen": "[::]:https://raw.githubusercontent.com/shopify/toxiproxy/HEAD/18080%22,
    "upstream": "webapp.domain:8080",
    "enabled": true
  },
  {
    "name": "web_dev_mysql_1",
    "listen": "[::]:13306",
    "upstream": "database.domain:3306",
    "enabled": true
  }
]

अस्थायी पोर्ट रेंज के बाहर के पोर्ट का उपयोग करें ताकि यादृच्छिक पोर्ट विरोध से बचा जा सके। Linux पर डिफ़ॉल्ट रूप से यह 32,768 से 61,000 तक होता है, देखें /proc/sys/net/ipv4/ip_local_port_range।

3. Toxiproxy का उपयोग करना

Toxiproxy का उपयोग करने के लिए, अब आपको अपने एप्लिकेशन को Toxiproxy के माध्यम से कनेक्ट होने के लिए कॉन्फ़िगर करना होगा। दूसरे चरण के हमारे उदाहरण को जारी रखते हुए, हम अपने Redis क्लाइंट को Toxiproxy के माध्यम से कनेक्ट होने के लिए कॉन्फ़िगर कर सकते हैं:```ruby

old straight to redis

redis = Redis.new(port: 6380)

new through toxiproxy

redis = Redis.new(port: 22220)

अब आप Toxiproxy API के माध्यम से इसके साथ छेड़छाड़ कर सकते हैं। Ruby में:```ruby
redis = Redis.new(port: 22220)

Toxiproxy[:shopify_test_redis_master].downstream(:latency, latency: 1000).apply do
  redis.get("test") # will take 1s
end

या CLI के माध्यम से:```bash toxiproxy-cli toxic add -t latency -a latency=1000 shopify_test_redis_master

कृपया उपयोग के लिए अपने संबंधित क्लाइंट लाइब्रेरी से परामर्श करें।

### 4. लॉगिंग

लॉग स्तर निम्नलिखित होते हैं: panic, fatal, error, warn या warning, info, debug और trace।
लेवल को पर्यावरण चर `LOG_LEVEL` के माध्यम से अपडेट किया जा सकता है।

### Toxics

Toxics क्लाइंट और upstream के बीच के पाइप (pipe) को नियंत्रित करते हैं। इन्हें [HTTP api](#http-api) का उपयोग करके proxies में जोड़ा और हटाया जा सकता है। प्रत्येक toxic के अपने पैरामीटर होते हैं जो यह बदलते हैं कि यह proxy लिंक्स को कैसे प्रभावित करता है।

कस्टम toxics लागू करने के दस्तावेज़ के लिए, [CREATING_TOXICS.md](https://github.com/shopify/toxiproxy/blob/HEAD/CREATING_TOXICS.md) देखें।

#### latency

प्रॉक्सी से गुजरने वाले सभी डेटा में देरी जोड़ता है। देरी `latency` +/- `jitter` के बराबर होती है।

विशेषताएँ:

 - `latency`: मिलीसेकंड में समय
 - `jitter`: मिलीसेकंड में समय

#### down

Toxiproxy के कार्यान्वयन में किसी सेवा को बंद (down) करना तकनीकी रूप से toxic नहीं है। यह `/proxies/{proxy}` पर `POST` करके और `enabled` फ़ील्ड को `false` पर सेट करके किया जाता है।

#### bandwidth

किसी कनेक्शन को प्रति सेकंड अधिकतम किलोबाइट की संख्या तक सीमित करता है।

विशेषताएँ:

 - `rate`: KB/s में दर

#### slow_close

TCP socket को `delay` बीत जाने तक बंद होने से विलंबित करता है।

विशेषताएँ:

 - `delay`: मिलीसेकंड में समय

#### timeout

सभी डेटा को आगे जाने से रोकता है, और `timeout` के बाद कनेक्शन बंद कर देता है। यदि `timeout` 0 है, तो कनेक्शन बंद नहीं होगा, और toxic हटाए जाने तक डेटा ड्रॉप कर दिया जाएगा।

विशेषताएँ:

 - `timeout`: मिलीसेकंड में समय

#### reset_peer

stub Input को तुरंत या `timeout` के बाद बंद करके कनेक्शनों पर TCP RESET (Connection reset by peer) का अनुकरण करता है।

विशेषताएँ:

 - `timeout`: मिलीसेकंड में समय

#### slicer

TCP डेटा को छोटे-छोटे टुकड़ों में काटता है, वैकल्पिक रूप से प्रत्येक कटे हुए "packet" के बीच देरी जोड़ता है।

विशेषताएँ:

 - `average_size`: बाइट्स में औसत पैकेट का आकार
 - `size_variation`: औसत पैकेट की बाइट्स में भिन्नता (average_size से छोटा होना चाहिए)
 - `delay`: प्रत्येक पैकेट को विलंबित करने हेतु समय माइक्रोसेकंड में

#### limit_data

जब प्रेषित डेटा सीमा से अधिक हो जाता है तो कनेक्शन बंद कर देता है।

 - `bytes`: कनेक्शन बंद होने से पहले प्रेषित किए जाने वाले बाइट्स की संख्या

#### packet_loss

प्रॉक्सी से गुजरने वाले चंक्स (chunks) को बेतरतीब ढंग से ड्रॉप करके अस्थिर Wi-Fi, मोबाइल या सैटेलाइट नेटवर्क स्थितियों का अनुकरण करता है।

विशेषताएँ:
 - `loss_rate`: किसी चंक के ड्रॉप होने की प्रायिकता [0.0-1.0] (डिफ़ॉल्ट 0.0)
 - `correlation`: पिछला चंक ड्रॉप होने पर अतिरिक्त ड्रॉप प्रायिकता, जो बर्स्ट लॉस (burst loss) को मॉडल करती है (डिफ़ॉल्ट 0.0)

### HTTP API

क्लाइंट से Toxiproxy डेमन (daemon) के साथ सभी संचार HTTP इंटरफ़ेस के माध्यम से होता है, जिसका वर्णन यहाँ किया गया है।

Toxiproxy HTTP के लिए पोर्ट **8474** पर सुनता है।

#### Proxy फ़ील्ड्स:

 - `name`: प्रॉक्सी का नाम (string)
 - `listen`: listen एड्रेस (string)
 - `upstream`: प्रॉक्सी का upstream एड्रेस (string)
 - `enabled`: true/false (निर्माण पर डिफ़ॉल्ट true)

किसी proxy का नाम बदलने के लिए, उसे हटाकर पुनः बनाना होता है।

`listen` या `upstream` फ़ील्ड बदलने से proxy पुनः प्रारंभ हो जाएगा और सभी सक्रिय कनेक्शन ड्रॉप हो जाएंगे।

यदि `listen` को पोर्ट 0 के साथ निर्दिष्ट किया जाता है, तो toxiproxy एक एफेमरल पोर्ट (ephemeral port) चुन लेगा। प्रतिक्रिया में `listen` फ़ील्ड को वास्तविक पोर्ट के साथ अपडेट किया जाएगा।

यदि आप `enabled` को `false` में बदलते हैं, तो यह proxy को बंद कर देगा। आप इसे पुनः सक्षम करने के लिए वापस `true` पर स्विच कर सकते हैं।

#### Toxic फ़ील्ड्स:

 - `name`: toxic का नाम (string, डिफ़ॉल्ट `<type>_<stream>`)
 - `type`: toxic का प्रकार (string)
 - `stream`: प्रभावित करने के लिए लिंक दिशा (डिफ़ॉल्ट `downstream`)
 - `toxicity`: किसी लिंक पर toxic लागू होने की प्रायिकता (डिफ़ॉल्ट 1.0, 100%)
 - `attributes`: toxic-विशिष्ट विशेषताओं का एक मैप (map)

toxic-विशिष्ट विशेषताओं के लिए [Toxics](#toxics) देखें।

`stream` दिशा या तो `upstream` या `downstream` होनी चाहिए। `upstream` toxic को `client -> server` कनेक्शन पर लागू करता है, जबकि `downstream` toxic को `server -> client` कनेक्शन पर लागू करता है। इसका उपयोग अनुरोधों (requests) और प्रतिक्रियाओं (responses) को अलग-अलग संशोधित करने के लिए किया जा सकता है।

#### एंडपॉइंट्स

सभी एंडपॉइंट JSON हैं।

 - **GET /proxies** - मौजूदा proxies और उनके toxics की सूची दिखाएँ
 - **POST /proxies** - एक नया proxy बनाएँ
 - **POST /populate** - proxies की सूची बनाएँ या बदलें
 - **GET /proxies/{proxy}** - proxy को उसके सभी सक्रिय toxics के साथ दिखाएँ
 - **POST /proxies/{proxy}** - proxy के फ़ील्ड अपडेट करें
 - **DELETE /proxies/{proxy}** - मौजूदा proxy को हटाएँ
 - **GET /proxies/{proxy}/toxics** - सक्रिय toxics की सूची दिखाएँ
 - **POST /proxies/{proxy}/toxics** - एक नया toxic बनाएँ
 - **GET /proxies/{proxy}/toxics/{toxic}** - किसी सक्रिय toxic के फ़ील्ड प्राप्त करें
 - **POST /proxies/{proxy}/toxics/{toxic}** - किसी सक्रिय toxic को अपडेट करें
 - **DELETE /proxies/{proxy}/toxics/{toxic}** - किसी सक्रिय toxic को हटाएँ
 - **POST /reset** - सभी proxies को सक्षम करें और सभी सक्रिय toxics हटाएँ
 - **GET /version** - सर्वर संस्करण संख्या लौटाता है
 - **GET /metrics** - Prometheus-संगत मेट्रिक्स लौटाता है

#### Proxies को पॉप्युलेट करना

Proxies को `/populate` एंडपॉइंट का उपयोग करके थोक में (bulk) जोड़ा और कॉन्फ़िगर किया जा सकता है। यह toxiproxy को proxies की एक json array पास करके किया जाता है। यदि उसी नाम वाला कोई proxy पहले से मौजूद है, तो उसकी तुलना नए proxy से की जाएगी और यदि `upstream` और `listen` पता मेल नहीं खाते हैं तो उसे बदल दिया जाएगा।

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

### CLI उदाहरण```bash
$ toxiproxy-cli create -l localhost:26379 -u localhost:6379 redis
Created new proxy redis
$ toxiproxy-cli list
Listen          Upstream        Name  Enabled Toxics
======================================================================
127.0.0.1:26379 localhost:6379  redis true    None

Hint: inspect toxics with `toxiproxy-client inspect <proxyName>`

The input content for chunk 41 is missing; please provide the Markdown text to translate.```bash $ redis-cli -p 26379 127.0.0.1:26379> SET omg pandas OK 127.0.0.1:26379> GET omg "pandas"

The input chunk is empty—no content was provided to translate. Please provide the actual Markdown text for chunk 43.```bash
$ toxiproxy-cli toxic add -t latency -a latency=1000 redis
Added downstream latency toxic 'latency_downstream' on proxy 'redis'

कोई इनपुट सामग्री प्रदान नहीं की गई है, इसलिए अनुवाद करने के लिए कुछ नहीं है। कृपया वास्तविक Markdown सामग्री भेजें।```bash $ redis-cli -p 26379 127.0.0.1:26379> GET omg "pandas" (1.00s) 127.0.0.1:26379> DEL omg (integer) 1 (1.00s)

[No content provided in the input section.]```bash
$ toxiproxy-cli toxic remove -n latency_downstream redis
Removed toxic 'latency_downstream' on proxy 'redis'

I notice the input section is empty — no source text was provided for chunk 49. Please provide the Markdown content to translate, and I'll translate it into Hindi.```bash $ redis-cli -p 26379 127.0.0.1:26379> GET omg (nil)

Please provide the Markdown content to translate.```bash
$ toxiproxy-cli delete redis
Deleted proxy redis

INPUT:```bash $ redis-cli -p 26379 Could not connect to Redis at 127.0.0.1:26379: Connection refused

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

Toxiproxy अपने HTTP API के माध्यम से /metrics पर Prometheus-संगत मेट्रिक्स प्रदान करता है।
पूर्ण विवरण के लिए [METRICS.md](https://github.com/shopify/toxiproxy/blob/HEAD/METRICS.md) देखें।

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

**Toxiproxy कितना तेज़ है?** Toxiproxy की गति काफी हद तक आपके हार्डवेयर पर निर्भर करती है,
लेकिन जब कोई toxic सक्षम नहीं होता है तो आप *< 100µs* की विलंबता की उम्मीद कर सकते हैं। Macbook Pro पर
`GOMAXPROCS=4` के साथ चलाने पर हमने *~1000MB/s* का थ्रूपुट प्राप्त किया, और एक उच्च-स्तरीय डेस्कटॉप पर
*2400MB/s* तक। मूल रूप से, आप उम्मीद कर सकते हैं कि Toxiproxy डेटा को आपके परीक्षण किए जा रहे ऐप की कम से कम गति से स्थानांतरित करेगा।

**क्या Toxiproxy यादृच्छिक परीक्षण कर सकता है?** उपलब्ध कई toxics को यादृच्छिकता के साथ कॉन्फ़िगर किया जा सकता है,
जैसे `latency` toxic में `jitter`। एक वैश्विक
`toxicity` पैरामीटर भी है जो उन कनेक्शनों का प्रतिशत निर्दिष्ट करता है जिन्हें एक toxic प्रभावित करेगा।
यह `timeout` toxic जैसी चीज़ों के लिए सबसे उपयोगी है, जो X% कनेक्शनों को timeout होने देगा।

**मुझे MySQL के लिए अपने Toxiproxy क्रियाएँ प्रतिबिंबित नहीं दिख रही हैं**। MySQL कुछ क्लाइंट्स के लिए स्थानीय Unix domain socket को प्राथमिकता देगा, चाहे आप कोई भी port दें,
यदि होस्ट `localhost` पर सेट है। अपने MySQL सर्वर को socket न बनाने के लिए कॉन्फ़िगर करें, और होस्ट के रूप में `127.0.0.1` का उपयोग करें। सर्वर को पुनः आरंभ करने के बाद पुराने socket को हटाना याद रखें।

**Toxiproxy आंतरायिक कनेक्शन विफलताओं का कारण बनता है**। यादृच्छिक पोर्ट टकराव से बचने के लिए ephemeral पोर्ट सीमा के बाहर के पोर्ट का उपयोग करें। Linux पर डिफ़ॉल्ट रूप से यह `32,768` से `61,000` है, `/proc/sys/net/ipv4/ip_local_port_range` देखें।

**क्या मुझे प्रत्येक एप्लिकेशन के लिए एक Toxiproxy चलाना चाहिए?** नहीं, हम सभी एप्लिकेशन्स के लिए एक ही Toxiproxy का उपयोग करने की सलाह देते हैं। सेवाओं के बीच अंतर करने के लिए हम आपके proxies को इस योजना के साथ नाम देने की सलाह देते हैं: `<app>_<env>_<data store>_<shard>`। उदाहरण के लिए, `shopify_test_redis_master` या `shopify_development_mysql_1`।

### विकास

* `make`। वर्तमान प्लेटफ़ॉर्म के लिए एक toxiproxy डेवलपमेंट बाइनरी बनाएँ।
* `make all`। सभी प्लेटफ़ॉर्म के लिए Toxiproxy बाइनरी और पैकेज बनाएँ। Linux और Darwin (amd64) पर क्रॉस कंपाइलेशन सक्षम के साथ Go संकलित होना आवश्यक है, साथ ही Linux पैकेज की बाइनरी बनाने के लिए आपके `$PATH` में [`goreleaser`](https://goreleaser.com/) होना चाहिए।
* `make test`। Toxiproxy परीक्षण चलाएँ।

### रिलीज़

[RELEASE.md](https://github.com/shopify/toxiproxy/blob/HEAD/RELEASE.md) देखें।

[blog]: https://shopify.engineering/building-and-testing-resilient-ruby-on-rails-applications

toxiproxy

सबसे लोकप्रिय