carbon c relay
3.8.1 (28-04-2024)
carbon-c-relay -f config-file [ options ... ]
คาร์บอน-C-Relay ยอมรับทำความสะอาดการจับคู่การเขียนใหม่ส่งต่อและรวมตัวชี้วัดกราไฟท์โดยการฟังการเชื่อมต่อที่เข้ามาและถ่ายทอดข้อความไปยังเซิร์ฟเวอร์อื่น ๆ ที่กำหนดไว้ในการกำหนดค่า ฟังก์ชั่นหลักคือการกำหนดเส้นทางข้อความผ่านกฎที่ยืดหยุ่นไปยังจุดหมายปลายทางที่ต้องการ
Carbon-C-Relay เป็นโปรแกรมง่าย ๆ ที่อ่านข้อมูลการกำหนดเส้นทางจากไฟล์ อาร์กิวเมนต์บรรทัดคำสั่งอนุญาตให้ตั้งค่าตำแหน่งสำหรับไฟล์นี้รวมถึงจำนวนของ dispatchers (เธรดคนงาน) เพื่อใช้สำหรับการอ่านข้อมูลจากการเชื่อมต่อที่เข้ามาและส่งผ่านไปยังปลายทางที่ถูกต้อง ไฟล์เส้นทางรองรับสองโครงสร้างหลัก: กลุ่มและการจับคู่ กลุ่มแรกที่กำหนดกลุ่มของโฮสต์ข้อมูลตัวชี้วัดสามารถส่งไปยังหลังกำหนดตัวชี้วัดที่ควรส่งไปยังคลัสเตอร์ใด กฎการรวมจะถูกมองว่าเป็นการจับคู่ การเขียนซ้ำคือการกระทำที่ส่งผลโดยตรงต่อการวัด ณ จุดที่ปรากฏในการกำหนดค่า
สำหรับทุกเมตริกที่ได้รับจากรีเลย์จะทำการทำความสะอาด การเปลี่ยนแปลงต่อไปนี้จะดำเนินการก่อนการแข่งขันใด ๆ การรวมหรือการเขียนซ้ำกฎจะเห็นตัวชี้วัด:
[0-9a-zA-Z-_:#] แต่สามารถแทนที่ในบรรทัดคำสั่ง โปรดทราบว่าแท็ก (เมื่อมีอยู่และอนุญาต) จะไม่ถูกประมวลผลด้วยวิธีนี้ ตัวเลือกเหล่านี้ควบคุมพฤติกรรมของ คาร์บอน-c-ralay
-v : สตริงเวอร์ชันพิมพ์และออก
-d : เปิดใช้งานโหมดดีบั๊กสถิตินี้พิมพ์ไปยัง stdout และพิมพ์ข้อความเพิ่มเติมเกี่ยวกับสถานการณ์บางอย่างที่พบโดยรีเลย์ซึ่งโดยปกติจะเปิดใช้งาน verbose เกินกว่าที่จะเปิดใช้งาน เมื่อรวมกับ -t (โหมดทดสอบ) จะพิมพ์เส้นทางสตับและเนื้อหาแหวนแบบแฮชที่สอดคล้องกัน
-s : เปิดใช้งานโหมดการส่ง ในโหมดนี้สถิติภายในไม่ได้สร้างขึ้น แต่จะมีการรายงานความดันคิวและตัวชี้วัดลดลงใน stdout โหมดนี้มีประโยชน์เมื่อใช้เป็นรีเลย์การส่งงานซึ่ง 'งานเป็นเพียงการส่งต่อไปยังรีเลย์หลัก (ชุด) สถิติเกี่ยวกับรีเลย์การส่งในกรณีนี้ไม่จำเป็นและอาจทำให้เกิดน้ำท่วมตัวชี้วัดที่ไม่ได้รับความเสียหายเช่นเมื่อใช้กับโฮสต์แต่ละตัวและทุกเครื่องในพื้นที่
-S : เปิดใช้งานโหมด Iostat-like ซึ่งทุกวินาทีจะมีการรายงานสถานะปัจจุบันของสถิติ นี่หมายถึงโหมดการส่ง -s
-t : โหมดทดสอบ โหมดนี้ไม่ได้ทำการกำหนดเส้นทางใด ๆ เลย แต่จะอ่านอินพุตจาก stdin และพิมพ์ว่าการกระทำใดจะเกิดขึ้นจากการกำหนดค่าที่โหลด โหมดนี้มีประโยชน์มากสำหรับการทดสอบเส้นทางรีเลย์สำหรับไวยากรณ์นิพจน์ทั่วไป ฯลฯ นอกจากนี้ยังช่วยให้ข้อมูลเชิงลึกเกี่ยวกับวิธีการใช้การกำหนดเส้นทางในการกำหนดค่าที่ซับซ้อนเพราะมันแสดงการเขียนซ้ำและการรวมตัวที่เกิดขึ้นเช่นกัน เมื่อทำซ้ำ -t จะทดสอบการกำหนดค่าเพื่อความถูกต้องและออกทันทีหลังจากนั้น เอาต์พุตมาตรฐานใด ๆ ถูกระงับในโหมดนี้ทำให้เหมาะสำหรับการเริ่มต้นสคริปต์เพื่อทดสอบการกำหนดค่า (ใหม่)
-f config-file : อ่านการกำหนดค่าจาก config-file การกำหนดค่าประกอบด้วยกลุ่มและเส้นทาง ดูการกำหนดค่าไวยากรณ์สำหรับข้อมูลเพิ่มเติมเกี่ยวกับตัวเลือกและไวยากรณ์ของไฟล์นี้
-l Log-File : ใช้ ไฟล์บันทึก สำหรับการเขียนข้อความ หากไม่มีตัวเลือกนี้รีเลย์จะเขียนทั้งสองไปยัง Stdout และ Stderr เมื่อลงชื่อเข้าใช้ไฟล์ข้อความทั้งหมดจะถูกนำหน้าด้วย MSG เมื่อพวกเขาถูกส่งไปยัง stdout และ ERR เมื่อพวกเขาถูกส่งไปยัง Stderr
-p พอร์ต : ฟังการเชื่อมต่อบนพอร์ต พอร์ต หมายเลขพอร์ตใช้สำหรับซ็อกเก็ตทั้ง TCP , UDP และ UNIX sockets ในกรณีหลังไฟล์ซ็อกเก็ตมีหมายเลขพอร์ต พอร์ตเริ่มต้นเป็น ปี 2003 ซึ่งใช้โดย carbon-cache.py ดั้งเดิม โปรดทราบว่าสิ่งนี้ใช้กับค่าเริ่มต้นเท่านั้นเมื่อ listen คำสั่งฟังอยู่ในการกำหนดค่าการตั้งค่านี้จะถูกละเว้น
-w คนงาน : ใช้จำนวน คนงาน จำนวนเธรด จำนวนพนักงานเริ่มต้นเท่ากับจำนวนคอร์ CPU ที่ตรวจพบ มันสมเหตุสมผลที่จะลดจำนวนนี้บนเครื่องจักรหลายคอร์หรือเมื่อการรับส่งข้อมูลต่ำ
-b batchsize : ตั้งค่าจำนวนตัวชี้วัดที่ส่งไปยังเซิร์ฟเวอร์ระยะไกลในครั้งเดียวเป็น batchsize เมื่อรีเลย์ส่งตัวชี้วัดไปยังเซิร์ฟเวอร์มันจะดึงตัวชี้วัด batchsize จากคิวที่ค้างอยู่ของตัวชี้วัดที่รอเซิร์ฟเวอร์นั้นและส่งไปทีละตัว ขนาดของแบทช์จะมีผลกระทบน้อยที่สุดในการส่งประสิทธิภาพ แต่มันควบคุมปริมาณการเชื่อมต่อล็อคในคิว ค่าเริ่มต้นคือ 2,500
-q Queuesize : แต่ละเซิร์ฟเวอร์จากการกำหนดค่าที่รีเลย์จะส่งตัวชี้วัดไปยังมีคิวที่เกี่ยวข้อง คิวนี้ช่วยให้การหยุดชะงักและการระเบิดได้รับการจัดการ ขนาดของคิวนี้จะถูกตั้งค่าเป็น คิว ซึ่งช่วยให้จำนวนตัวชี้วัดจำนวนนั้นถูกเก็บไว้ในคิวก่อนที่มันจะล้นและรีเลย์จะเริ่มลดการวัด ยิ่งคิวมีขนาดใหญ่ขึ้นตัวชี้วัดที่มากขึ้นสามารถดูดซึมได้ แต่ยังมีการใช้หน่วยความจำมากขึ้นโดยรีเลย์ ขนาดคิวเริ่มต้นคือ 25000
-L Stalls : ตั้งค่าการเมานต์สูงสุดของแผงลอยไปที่ แผงลอย ก่อนที่รีเลย์จะเริ่มวางเมตริกสำหรับเซิร์ฟเวอร์ เมื่อคิวเติมเต็มรีเลย์จะใช้กลไกที่เรียกว่าการหยุดชะงักเพื่อส่งสัญญาณลูกค้า (เขียนไปยังรีเลย์) ของเหตุการณ์นี้ โดยเฉพาะอย่างยิ่งเมื่อลูกค้าส่งตัวชี้วัดจำนวนมากในระยะเวลาอันสั้น (ระเบิด) การหยุดยั้งสามารถช่วยหลีกเลี่ยงการปล่อยตัวชี้วัดเนื่องจากลูกค้าเพียงแค่ต้องชะลอตัวลงเล็กน้อยซึ่งใน nc กรณีเป็นไปได้ อย่างไรก็ตามพฤติกรรมนี้ยังสามารถขัดขวางนักเขียนที่หยุดยั้งซึ่งไม่สามารถหยุดได้อย่างง่ายดาย สำหรับแผงลอยนี้สามารถตั้งค่าได้ตั้งแต่ 0 ถึง 15 ซึ่งแต่ละแผงสามารถใช้เวลาประมาณ 1 วินาทีบนไคลเอนต์ ค่าเริ่มต้นถูกตั้งค่าเป็น 4 ซึ่งมุ่งเป้าไปที่สถานการณ์การหยุดชะงักเป็นครั้งคราวและความพยายามสูงสุดที่จะไม่หลวมการวัดที่มีลูกค้าลดลงในระดับปานกลาง
-C CACERTPATH : อ่าน CA CERTS (สำหรับใช้กับการเชื่อมต่อ TLS/SSL) จากเส้นทางหรือไฟล์ที่กำหนด เมื่อไม่ได้รับตำแหน่งเริ่มต้นจะถูกใช้ การตรวจสอบอย่างเข้มงวดของเพียร์จะดำเนินการดังนั้นเมื่อใช้ใบรับรองที่ลงนามด้วยตนเองให้แน่ใจว่าได้รวมใบรับรอง CA ในตำแหน่งเริ่มต้นหรือให้เส้นทางไปยังใบรับรองโดยใช้ตัวเลือกนี้
-T Timeout : ระบุการหมดเวลา IO ในมิลลิวินาทีที่ใช้สำหรับการเชื่อมต่อเซิร์ฟเวอร์ ค่าเริ่มต้นคือ 600 มิลลิวินาที แต่อาจต้องเพิ่มขึ้นเมื่อใช้ลิงก์ WAN สำหรับเซิร์ฟเวอร์เป้าหมาย ค่าที่ค่อนข้างต่ำสำหรับการหมดเวลาการเชื่อมต่อช่วยให้รีเลย์สามารถสร้างเซิร์ฟเวอร์ได้อย่างรวดเร็วนั้นไม่สามารถเข้าถึงได้และเป็นกลยุทธ์การล้มเหลวที่จะเตะก่อนที่คิวจะทำงานสูง
-c Chars : กำหนดตัวละครที่อยู่ถัดจาก [A-Za-z0-9] ที่ได้รับอนุญาตในตัวชี้วัดถึง Chars อักขระใด ๆ ที่ไม่ได้อยู่ในรายการนี้จะถูกแทนที่ด้วยรีเลย์ด้วย _ (ขีดล่าง) รายการเริ่มต้นของอักขระที่อนุญาตคือ -_:#
-m ความยาว : จำกัด ชื่อตัวชี้วัดที่มี ความยาว มากที่สุดไบต์ยาว บรรทัดใด ๆ ที่มีชื่อตัวชี้วัดที่ใหญ่กว่านี้จะถูกยกเลิก
-M ความยาว จำกัด อินพุตไปยังเส้นที่ ความยาว มากที่สุดไบต์ เส้นส่วนเกินใด ๆ จะถูกยกเลิก โปรดทราบว่า -m ต้องมีขนาดเล็กกว่าค่านี้
-H HostName : Override HostName กำหนดโดยการโทรไปยัง gethostname (3) ด้วย ชื่อโฮสต์ ชื่อโฮสต์ส่วนใหญ่ใช้ในสถิติตัวชี้วัด carbon.relays.<hostname>.<...> ส่งโดยรีเลย์
-B backlog : ตั้งค่าการเชื่อมต่อ TCP ฟังการเชื่อมต่อ backlog เป็น backlog ค่าเริ่มต้นคือ 32 แต่บนเซิร์ฟเวอร์ที่ได้รับการเชื่อมต่อพร้อมกันจำนวนมากการตั้งค่านี้น่าจะต้องเพิ่มขึ้นเพื่อหลีกเลี่ยงการเชื่อมต่อที่ปฏิเสธข้อผิดพลาดในลูกค้า
-U bufsize : ตั้งค่าซ็อกเก็ตส่ง/รับขนาดบัฟเฟอร์ในไบต์สำหรับสถานการณ์ TCP และ UDP เมื่อ UNSET ใช้ค่าเริ่มต้นของระบบปฏิบัติการ ค่าสูงสุดจะถูกกำหนดโดยระบบปฏิบัติการ ขนาดถูกตั้งค่าโดยใช้ setSockOpt ด้วยแฟล็ก SO_RCVBUF และ SO_SNDBUF การตั้งค่าขนาดนี้อาจจำเป็นสำหรับสถานการณ์ระดับเสียงขนาดใหญ่ซึ่งอาจใช้ -B การตรวจสอบค่า recv-q และค่า ข้อผิดพลาดการรับ จาก NetStat ให้คำใบ้ที่ดีเกี่ยวกับการใช้บัฟเฟอร์
-E : ปิดการใช้งานการเชื่อมต่อการเชื่อมต่อที่ไม่ได้ใช้งาน โดยค่าเริ่มต้นการถ่ายทอดการเชื่อมต่อการเชื่อมต่อไคลเอนต์ที่ไม่ได้ใช้งานหลังจาก 10 นาที มันทำสิ่งนี้เพื่อป้องกันไม่ให้ทรัพยากรอุดตันเมื่อลูกค้าผิดพลาดหรือเป็นอันตรายยังคงเปิดการเชื่อมต่อโดยไม่ต้องปิด โดยทั่วไปแล้วจะป้องกันไม่ให้มีตัวอธิบายไฟล์ อย่างไรก็ตามสำหรับบางสถานการณ์มันไม่เป็นที่พึงปรารถนาสำหรับการเชื่อมต่อที่ไม่ได้ใช้งานที่จะตัดการเชื่อมต่อดังนั้นการผ่านธงนี้จะปิดการใช้งานพฤติกรรมนี้
-D : deamonise เป็นพื้นหลังหลังจากเริ่มต้น ตัวเลือกนี้ต้องการการตั้งค่าสถานะ -l และ -P ที่จะตั้งค่าเช่นกัน
-P pidfile : เขียน PID ของกระบวนการรีเลย์ไปยังไฟล์ที่เรียกว่า pidfile สิ่งนี้มีประโยชน์เป็นพิเศษเมื่อ daemonised ร่วมกับผู้จัดการ Init
-O Threshold : จำนวนกฎขั้นต่ำที่จะค้นหาก่อนที่จะพยายามเพิ่มประสิทธิภาพชุดกฎ ค่าเริ่มต้นคือ 50 เพื่อปิดการใช้งานตัวเพิ่มประสิทธิภาพใช้ -1 เพื่อเรียกใช้การใช้งาน Optimiser ใช้ 0 เสมอ Optimiser พยายามจัดกลุ่มกฎเพื่อหลีกเลี่ยงการใช้เวลามากเกินไปในการจับคู่นิพจน์
ไฟล์กำหนดค่ารองรับไวยากรณ์ต่อไปนี้โดยที่ความคิดเห็นเริ่มต้นด้วยอักขระ # และสามารถปรากฏที่ตำแหน่งใด ๆ ในบรรทัดและยับยั้งอินพุตจนกว่าจะสิ้นสุดของบรรทัดนั้น:
cluster <name>
< <forward | any_of | failover> [useall] |
<carbon_ch | fnv1a_ch | jump_fnv1a_ch> [replication <count>] [dynamic] >
<host[:port][=instance] [proto <udp | tcp>]
[type linemode]
[transport <plain | gzip | lz4 | snappy>
[ssl | mtls <pemcert> <pemkey>]]> ...
;
cluster <name>
file [ip]
</path/to/file> ...
;
match
<* | expression ...>
[validate <expression> else <log | drop>]
send to <cluster ... | blackhole>
[stop]
;
rewrite <expression>
into <replacement>
;
aggregate
<expression> ...
every <interval> seconds
expire after <expiration> seconds
[timestamp at <start | middle | end> of bucket]
compute <sum | count | max | min | average |
median | percentile<%> | variance | stddev> write to
<metric>
[compute ...]
[send to <cluster ...>]
[stop]
;
send statistics to <cluster ...>
[stop]
;
statistics
[submit every <interval> seconds]
[reset counters after interval]
[prefix with <prefix>]
[send to <cluster ...>]
[stop]
;
listen
type linemode [transport <plain | gzip | lz4 | snappy>
[<ssl | mtls> <pemcert>
[protomin <tlsproto>] [protomax <tlsproto>]
[ciphers <ssl-ciphers>] [ciphersuites <tls-suite>]
]
]
<<interface[:port] | port> proto <udp | tcp>> ...
</ptah/to/file proto unix> ...
;
# tlsproto: <ssl3 | tls1.0 | tls1.1 | tls1.2 | tls1.3>
# ssl-ciphers: see ciphers(1)
# tls-suite: see SSL_CTX_set_ciphersuites(3)
include </path/to/file/or/glob>
;
หลายกลุ่มสามารถกำหนดได้และไม่จำเป็นต้องอ้างอิงโดยกฎการจับคู่ กลุ่มทั้งหมดชี้ไปที่โฮสต์อย่างน้อยหนึ่งรายการยกเว้นคลัสเตอร์ file ที่เขียนไปยังไฟล์ในระบบไฟล์ท้องถิ่น host อาจเป็นที่อยู่ IPv4 หรือ IPv6 หรือชื่อโฮสต์ เนื่องจากโฮสต์ตามด้วยตัวเลือก : และพอร์ตสำหรับที่อยู่ IPv6 ที่จะไม่ตีความผิดต้องได้รับพอร์ตหรือที่อยู่ IPv6 ที่ล้อมรอบด้วยวงเล็บเช่น [::1] transport ทางเลือกและคำสั่ง proto สามารถใช้ในการห่อหุ้มการเชื่อมต่อในเลเยอร์การบีบอัดหรือเข้ารหัสหรือระบุการใช้ UDP หรือ TCP เพื่อเชื่อมต่อกับเซิร์ฟเวอร์ระยะไกล เมื่อละเว้นการเชื่อมต่อเริ่มต้นกับการเชื่อมต่อ TCP ธรรมดา type สามารถเป็น linemode ได้ในขณะนี้เช่นโหมด Pickle ของ Python ไม่รองรับ
ชื่อโฮสต์ DNS ได้รับการแก้ไขเป็นที่อยู่เดียวตามกฎการตั้งค่าใน RFC 3484. กลุ่ม any_of , failover และ forward Clusters มีธง useall ที่ชัดเจนซึ่งเปิดใช้งานการขยายชื่อโฮสต์เพื่อแก้ไขที่อยู่หลายแห่ง การใช้ตัวเลือกนี้ที่อยู่แต่ละประเภทจะกลายเป็นปลายทางของคลัสเตอร์ ซึ่งหมายความว่าตัวอย่างที่อยู่ทั้งที่อยู่ IPv4 และ IPv6 จะถูกเพิ่มเข้ามา
มีสองกลุ่มของกลุ่มประเภทคลัสเตอร์การส่งต่ออย่างง่ายและกลุ่มแฮชที่สอดคล้องกัน
forward และกลุ่ม file
กลุ่ม forward และ file เพียงส่งทุกสิ่งที่พวกเขาได้รับไปยังสมาชิกที่กำหนด (ที่อยู่โฮสต์หรือไฟล์) เมื่อคลัสเตอร์มีสมาชิกหลายคนตัวชี้วัดที่เข้ามาทั้งหมดจะถูกส่งไปยังสมาชิก ทุกคน โดยทั่วไปจะทำซ้ำกระแสการวัดอินพุตมากกว่าสมาชิกทุกคน
any_of คลัสเตอร์
คลัสเตอร์ any_of เป็นตัวแปรเล็ก ๆ ของคลัสเตอร์ forward แต่แทนที่จะส่งตัวชี้วัดอินพุตไปยังสมาชิกที่กำหนดทั้งหมดมันจะส่งแต่ละตัวชี้วัดที่เข้ามาไปยังสมาชิกที่กำหนดเพียงคนเดียว จุดประสงค์ของสิ่งนี้คือสถานการณ์ที่สมดุลซึ่งสมาชิกคนใดคนหนึ่งสามารถได้รับการวัดใด ๆ ตามที่ any_of เมื่อสมาชิกคนใดไม่สามารถเข้าถึงได้สมาชิกที่เหลืออยู่จะได้รับกระแสการป้อนข้อมูลแบบเต็มของตัวชี้วัดทันที นี่หมายความว่าเมื่อมีการใช้สมาชิก 4 คนแต่ละคนจะได้รับประมาณ 25% ของตัวชี้วัดอินพุต เมื่อสมาชิกคนหนึ่งไม่พร้อมใช้งาน (เช่นการหยุดชะงักของเครือข่ายหรือการรีสตาร์ทของบริการ) สมาชิก 3 คนที่เหลือจะได้รับประมาณ 25% / 3 = ~ การรับส่งข้อมูลมากขึ้น ~ 8% (33%) หรือพวกเขาจะได้รับ 1/3rd อินพุตทั้งหมด เมื่อออกแบบความจุคลัสเตอร์เราควรคำนึงถึงว่าในกรณีที่รุนแรงที่สุดสมาชิกสุดท้ายที่เหลือจะได้รับปริมาณการเข้าชมทั้งหมด
โดยเฉพาะอย่างยิ่งคลัสเตอร์ any_of มีประโยชน์เมื่อคลัสเตอร์ชี้ไปที่รีเลย์หรือแคชอื่น ๆ เมื่อใช้กับรีเลย์อื่น ๆ มันจะโหลดสมดุลอย่างมีประสิทธิภาพและปรับให้เข้ากับเป้าหมายที่ไม่สามารถใช้งานได้ทันที เมื่อใช้กับแคชมีรายละเอียดเล็ก ๆ น้อย ๆ เกี่ยวกับวิธีการทำงาน any_of ซึ่งทำให้เหมาะสมมาก การใช้งานของเราเตอร์นี้ไม่ได้เป็นไปรอบ ๆ สมาชิกที่มีอยู่ แต่แทนที่จะใช้กลยุทธ์การแฮชที่สอดคล้องกันเพื่อส่งมอบตัวชี้วัดเดียวกันไปยังปลายทางเดียวกันตลอดเวลา สิ่งนี้จะช่วยแคชและทำให้ง่ายต่อการดึงข้อมูล Datapoints ที่ไม่มีข้อผูกมัด (จากแคชเดียว) แต่ก็ยังช่วยให้สามารถรีสตาร์ทแคชได้ เมื่อสมาชิกไม่พร้อมใช้งานจุดหมายปลายทางแฮชจะไม่เปลี่ยนแปลง แต่การรับส่งข้อมูลที่กำหนดไว้สำหรับโหนดที่ไม่พร้อมใช้งานนั้นจะแพร่กระจายอย่างสม่ำเสมอผ่านโหนดที่มีอยู่
คลัสเตอร์ failover
คลัสเตอร์ failover เป็นเหมือนคลัสเตอร์ any_of แต่ยึดตามลำดับที่เซิร์ฟเวอร์ถูกกำหนดไว้ นี่คือการใช้สถานการณ์การล้มเหลวที่บริสุทธิ์ระหว่างเซิร์ฟเวอร์ ตัวชี้วัดทั้งหมดถูกส่งไปยังสมาชิกมากที่สุด 1 คนดังนั้นจึงไม่มีการแฮชหรือการปรับสมดุลเกิดขึ้น ตัวอย่างเช่นคลัสเตอร์ failover ที่มีสมาชิกสองคนจะส่งตัวชี้วัดไปยังสมาชิกคนที่สองเมื่อสมาชิกคนแรกไม่สามารถใช้งานได้ ทันทีที่สมาชิกคนแรกกลับมาเมตริกทั้งหมดจะถูกส่งไปยังโหนดแรกอีกครั้ง
คลัสเตอร์ carbon_ch
คลัสเตอร์ carbon_ch ส่งตัวชี้วัดไปยังสมาชิกที่รับผิดชอบตามอัลกอริทึมแฮชที่สอดคล้องกันตามที่ใช้ในรีเลย์คาร์บอนหลาม สมาชิกหลายคนเป็นไปได้หากการจำลองแบบถูกตั้งค่าเป็นค่าที่สูงกว่า 1 เมื่อตั้งค่า dynamic ความล้มเหลวของเซิร์ฟเวอร์ใด ๆ ไม่ได้ส่งผลให้ตัวชี้วัดถูกทิ้งสำหรับเซิร์ฟเวอร์นั้น แต่แทนที่จะส่งตัวชี้วัดที่ไม่สามารถส่งได้จะถูกส่งไปยังเซิร์ฟเวอร์อื่น ๆ ในคลัสเตอร์ สิ่งนี้มีประโยชน์มากที่สุดเมื่อการจำลองแบบคือ 1
การคำนวณแฮชริงซึ่งกำหนดวิธีการกระจายตัวชี้วัดนั้นขึ้นอยู่กับโฮสต์เซิร์ฟเวอร์ (หรือที่อยู่ IP) และอินสแตน instance เสริมของสมาชิก ซึ่งหมายความว่าการใช้สองเป้าหมาย carbon_ch บนพอร์ตที่แตกต่างกัน แต่ในโฮสต์เดียวกันจะแมปกับแฮชคีย์เดียวกันซึ่งหมายความว่าไม่มีการกระจายตัวของตัวชี้วัดเกิดขึ้น อินสแตนซ์ใช้เพื่อแก้ไขสถานการณ์นั้น อินสแตนซ์ถูกผนวกเข้ากับสมาชิกหลังจากพอร์ตและคั่นด้วยเครื่องหมายเท่ากับเช่น 127.0.0.1:2006=a a อินสแตนซ์เป็นแนวคิดที่แนะนำโดย CACHACH CACHE PYTHON ดั้งเดิมและจำเป็นต้องใช้ตามการกำหนดค่าของสิ่งเหล่านั้น
แฮชที่สอดคล้องกันมีความสอดคล้องกันในแง่ที่ว่าการลบสมาชิกออกจากคลัสเตอร์ไม่ควรส่งผลให้มีการแมปการวัดทั้งหมดทั้งหมดให้กับสมาชิกใหม่ แต่แทนที่จะเพิ่มตัวชี้วัดจากสมาชิกที่ถูกลบออกให้กับสมาชิกที่เหลือทั้งหมด อีกวิธีหนึ่งเมื่อมีการเพิ่มสมาชิกสมาชิกแต่ละคนควรเห็นชุดย่อยของตัวชี้วัดของมันตอนนี้ถูกส่งไปยังสมาชิกใหม่ นี่เป็นข้อได้เปรียบที่สำคัญกว่าแฮชปกติซึ่งการลบหรือการเพิ่มสมาชิกแต่ละครั้ง (เช่นผ่านการเปลี่ยนแปลงที่อยู่ IP หรือชื่อโฮสต์) จะทำให้การแมปเต็มของตัวชี้วัดทั้งหมดทั้งหมดผ่านการวัดทั้งหมดที่มีอยู่ทั้งหมด
คลัสเตอร์ fnv1a_ch
คลัสเตอร์ fnv1a_ch เป็นการปรับปรุงที่เข้ากันไม่ได้กับ carbon_ch ที่แนะนำโดย Carbon-C-Relay มันใช้เทคนิคแฮชที่แตกต่างกัน (FNV1A) ซึ่งเร็วกว่า MD5-Hashing ที่ใช้โดย carbon_ch ที่สำคัญกว่านั้นกลุ่ม fnv1a_ch ใช้ทั้งโฮสต์และพอร์ตเพื่อแยกความแตกต่างของสมาชิก สิ่งนี้มีประโยชน์เมื่อมีหลายเป้าหมายอยู่บนโฮสต์เดียวกันเพิ่งคั่นด้วยพอร์ต
เนื่องจากคุณสมบัติ instance ไม่จำเป็นอีกต่อไปกับ fnv1a_ch ด้วยวิธีนี้จึงใช้เพื่อแทนที่โฮสต์อย่างสมบูรณ์: สตริงพอร์ตที่แฮชคีย์จะถูกคำนวณ นี่เป็นสิ่งสำคัญเนื่องจากแฮชคีย์กำหนดตัวชี้วัดที่สมาชิกได้รับ การแทนที่ดังกล่าวช่วยให้หลายสิ่งหลายอย่างรวมถึงการปลอมแปลงที่อยู่ IP เก่าเช่นเมื่อเครื่องย้ายไปยังฮาร์ดแวร์ใหม่ ตัวอย่างนี้จะเป็น 10.0.0.5:2003=10.0.0.2:2003 โดยที่เครื่องที่อยู่ 5 ตอนนี้ได้รับการวัดสำหรับเครื่องที่อยู่ที่ที่อยู่ 2
ในขณะที่ใช้อินสแตนซ์ด้วยวิธีนี้จะมีประโยชน์มากในการอพยพในกลุ่มที่มีอยู่สำหรับกลุ่มการตั้งค่าใหม่อินสแตนซ์อนุญาตให้หลีกเลี่ยงงานนี้โดยใช้อินสแตนซ์จากวันแรกเพื่อแยกตำแหน่งของเครื่องออกจากตัวชี้วัดที่ได้รับ พิจารณาตัวอย่างเช่น 10.0.0.1:2003=4d79d13554fa1301476c1f9fe968b0ac โดยใช้แฮชแบบสุ่มเป็นอินสแตนซ์ สิ่งนี้จะอนุญาตให้เปลี่ยนพอร์ตและ/หรือที่อยู่ IP ของเซิร์ฟเวอร์ที่ได้รับข้อมูลหลายครั้งโดยไม่ต้องจัดการกับมรดกใด ๆ ที่มองเห็นได้โดยสมมติว่าแฮชแบบสุ่มจะถูกเก็บไว้ โปรดทราบว่าเนื่องจากชื่ออินสแตนซ์ถูกใช้เป็นอินพุตแฮชแบบเต็มอินสแตนซ์เป็น a , b ฯลฯ จะส่งผลให้เกิดการแจกแจงแฮชที่ไม่ดีเนื่องจากแฮชของพวกเขามีอินพุตน้อยมาก ด้วยเหตุผลดังกล่าวให้พิจารณาการใช้ชื่ออินสแตนซ์ที่ยาวขึ้นและส่วนใหญ่เช่นแฮชแบบสุ่มตามที่ใช้ในตัวอย่างข้างต้นเพื่อพฤติกรรมการแจกแจงแฮชที่ดีขึ้น
Cluster jump_fnv1a_ch
คลัสเตอร์ jump_fnv1a_ch ก็เป็นคลัสเตอร์แฮชที่สอดคล้องกันเช่นสองก่อนหน้า แต่ไม่ได้ใช้โฮสต์สมาชิกพอร์ตหรืออินสแตนซ์เข้าบัญชีเลย ซึ่งหมายความว่าประเภทคลัสเตอร์นี้จะดูที่คำสั่งที่สมาชิกกำหนดดูเพิ่มเติมด้านล่างสำหรับคำสั่งซื้อเพิ่มเติม สิ่งนี้มีประโยชน์สำหรับคุณหรือไม่นั้นขึ้นอยู่กับสถานการณ์ของคุณ ตรงกันข้ามกับสองประเภทแฮชคลัสเตอร์ที่สอดคล้องกันก่อนหน้านี้แฮชกระโดดมีความสมดุลที่สมบูรณ์แบบเหนือสมาชิกที่กำหนดไว้ในคลัสเตอร์ อย่างไรก็ตามสิ่งนี้มาพร้อมกับค่าใช้จ่ายที่ไม่สามารถลบสมาชิกใด ๆ แต่สุดท้ายจากคลัสเตอร์โดยไม่ก่อให้เกิดการแมปของตัวชี้วัดทั้งหมดทั้งหมดที่สมบูรณ์มากกว่าสมาชิกทุกคน สิ่งนี้หมายถึงโดยทั่วไปคือแฮชนี้ใช้งานได้ดีกับกลุ่มที่คงที่
หากคุณมีคลัสเตอร์ที่การกำจัดโหนดเก่าเกิดขึ้นแฮชกระโดดไม่เหมาะสำหรับคุณ กระโดดแฮชทำงานร่วมกับเซิร์ฟเวอร์ในรายการที่สั่งซื้อ เนื่องจากคำสั่งนี้มีความสำคัญจึงสามารถทำให้ชัดเจนโดยใช้อินสแตนซ์ที่ใช้ในประเภทคลัสเตอร์ก่อนหน้า เมื่อมีการให้อินสแตนซ์กับสมาชิกมันจะถูกใช้เป็นคีย์การเรียงลำดับ หากไม่มีอินสแตนซ์นี้คำสั่งซื้อจะเป็นไปตามที่กำหนดในไฟล์การกำหนดค่าซึ่งอาจมีแนวโน้มที่จะเปลี่ยนแปลงเมื่อสร้างโดยซอฟต์แวร์การจัดการการกำหนดค่าบางอย่าง เช่นนี้อาจเป็นวิธีปฏิบัติที่ดีในการแก้ไขลำดับของเซิร์ฟเวอร์ด้วยอินสแตนซ์เพื่อให้ชัดเจนว่าโหนดที่เหมาะสมสำหรับการกระโดดแฮชคืออะไร หนึ่งสามารถใช้ตัวเลขสำหรับสิ่งเหล่านี้ แต่โปรดทราบว่าการเรียงลำดับ 1, 2 และ 10 ผลลัพธ์ใน 1, 10, 2, ดีกว่าที่จะใช้บางอย่างเช่น P0001, P0002, P0010 แทน
กฎการจับคู่เป็นวิธีที่จะส่งตัวชี้วัดที่เข้ามาโดยตรงไปยังกลุ่มหนึ่งหรือมากกว่า กฎการจับคู่จะถูกประมวลผลจากบนลงล่างตามที่กำหนดไว้ในไฟล์ เป็นไปได้ที่จะกำหนดการแข่งขันหลายรายการในกฎเดียวกัน แต่ละกฎการจับคู่สามารถส่งข้อมูลไปยังกลุ่มหนึ่งหรือมากกว่า เนื่องจากกฎการจับคู่ "ตกผ่าน" เว้นแต่จะมีการเพิ่มคำหลัก stop นิพจน์การจับคู่ที่สร้างขึ้นอย่างระมัดระวังสามารถใช้เพื่อกำหนดเป้าหมายหลายกลุ่มหรือการรวมกัน ความสามารถนี้ช่วยให้สามารถทำซ้ำตัวชี้วัดรวมถึงส่งตัวชี้วัดบางอย่างไปยังกลุ่มทางเลือกด้วยการสั่งซื้ออย่างรอบคอบและการใช้คำหลัก stop blackhole กลุ่มพิเศษทิ้งการวัดใด ๆ ที่ส่งไป สิ่งนี้มีประโยชน์สำหรับการกำจัดตัวชี้วัดที่ไม่พึงประสงค์ในบางกรณี เนื่องจากการโยนเมตริกออกไปนั้นไม่มีจุดหมายหากการแข่งขันอื่น ๆ จะยอมรับข้อมูลเดียวกันการจับคู่กับปลายทางเป็นคลัสเตอร์แบล็กฮอลจึงมี stop โดยนัย ประโยค validation เพิ่มการตรวจสอบข้อมูล (สิ่งที่เกิดขึ้นหลังจากตัวชี้วัด) ในรูปแบบของนิพจน์ทั่วไป เมื่อนิพจน์นี้ตรงกับกฎการจับคู่จะดำเนินการราวกับว่าไม่มีการตรวจสอบส่วนใด อย่างไรก็ตามหากล้มเหลวกฎการจับคู่จะถูกยกเลิกและจะไม่มีการส่งตัวชี้วัดไปยังจุดหมายปลายทางนี่คือพฤติกรรม drop เมื่อใช้ log ตัวชี้วัดจะถูกบันทึกไปยัง Stderr ควรใช้ความระมัดระวังกับหลังเพื่อหลีกเลี่ยงการท่วมท่วม เมื่อมีการตรวจสอบส่วนที่มีอยู่ปลายทางไม่จำเป็นต้องมีอยู่สิ่งนี้จะช่วยให้ใช้กฎการตรวจสอบความถูกต้องทั่วโลก โปรดทราบว่ามีการใช้กฎการทำความสะอาดก่อนที่จะทำการตรวจสอบดังนั้นข้อมูลจะไม่มีช่องว่างที่ซ้ำกัน route using ประโยคใช้เพื่อทำการปรับเปลี่ยนชั่วคราวไปยังคีย์ที่ใช้สำหรับอินพุตไปยังรูทีนการแฮชที่สอดคล้องกัน วัตถุประสงค์หลักคือการกำหนดเส้นทางการรับส่งข้อมูลเพื่อให้ข้อมูลที่เหมาะสมถูกส่งไปยังอินสแตนซ์การรวมที่จำเป็น
กฎการเขียนใหม่ใช้นิพจน์ปกติเป็นอินพุตเพื่อให้ตรงกับตัวชี้วัดที่เข้ามาและแปลงเป็นชื่อตัวชี้วัดใหม่ที่ต้องการ ในการเปลี่ยนการย้อนกลับจะได้รับอนุญาตให้จับคู่กลุ่มจับภาพที่กำหนดไว้ในนิพจน์ปกติอินพุต การจับคู่ของ server.(x|y|z). อนุญาตให้ใช้เช่น role.1. ในการทดแทน หากจำเป็นสามารถใช้สัญลักษณ์ของ g{n} แทน n โดยที่ backreference ตามด้วยจำนวนเต็มเช่น g{1}100 คำเตือนสองสามข้อนำไปใช้กับการใช้งานกฎการเขียนซ้ำในปัจจุบัน ขั้นแรกตำแหน่งของพวกเขาในไฟล์ config กำหนดว่าจะทำการเขียนใหม่เมื่อใด การเขียนซ้ำจะดำเนินการในสถานที่เช่นกฎการจับคู่ก่อนที่การเขียนใหม่จะตรงกับชื่อเดิมกฎการจับคู่หลังจากการเขียนใหม่ไม่ตรงกับชื่อเดิมอีกต่อไป ควรใช้ความระมัดระวังกับการสั่งซื้อเนื่องจากกฎการเขียนซ้ำหลายครั้งสามารถสืบทอดได้เช่น a ได้รับการแทนที่ด้วย b และ b จะถูกแทนที่ด้วย c ในกฎการเขียนซ้ำที่ประสบความสำเร็จ ข้อแม้ที่สองที่มีการนำไปใช้ในปัจจุบันคือชื่อตัวชี้วัดที่เขียนใหม่ไม่ได้รับการทำความสะอาดเช่นตัวชี้วัดที่เข้ามาใหม่คือ ดังนั้นจุดสองจุดและอักขระอันตรายที่อาจเกิดขึ้นสามารถปรากฏขึ้นหากสตริงการเปลี่ยนถูกสร้างขึ้นเพื่อผลิต มันเป็นความรับผิดชอบของนักเขียนเพื่อให้แน่ใจว่าตัวชี้วัดนั้นสะอาด หากนี่เป็นปัญหาสำหรับการกำหนดเส้นทางเราสามารถพิจารณาว่ามีอินสแตนซ์ที่เขียนใหม่เท่านั้นที่ส่งต่อตัวชี้วัดทั้งหมดไปยังอินสแตนซ์อื่นที่จะทำการกำหนดเส้นทาง เห็นได้ชัดว่าอินสแตนซ์ที่สองจะทำความสะอาดตัวชี้วัดตามที่พวกเขาเข้ามาสัญกรณ์ backreference อนุญาตให้ตัวพิมพ์เล็กและเพิ่มสตริงการเปลี่ยนด้วยการใช้ขีดล่าง ( _ ) และสัญลักษณ์ carret ( ^ ) หลังจาก backslash โดยตรง ตัวอย่างเช่น role._1. เนื่องจากการทดแทนจะช่วยลดเนื้อหาของ 1 DOT ( . ) สามารถใช้ในลักษณะที่คล้ายกันหรือตามหลังขีดล่างหรือ Caret เพื่อแทนที่จุดด้วยขีดล่างในการทดแทน สิ่งนี้มีประโยชน์สำหรับบางสถานการณ์ที่ส่งตัวชี้วัดไปยังกราไฟท์
การรวมตัวที่กำหนดจะใช้ตัวชี้วัดอินพุตหนึ่งตัวหรือมากกว่าที่แสดงโดยการแสดงออกปกติอย่างน้อยหนึ่งรายการคล้ายกับกฎการจับคู่ ตัวชี้วัดที่เข้ามาจะถูกรวมเข้าด้วยกันในช่วงเวลาที่กำหนดโดยช่วงเวลาในไม่กี่วินาที เนื่องจากเหตุการณ์อาจมาถึงในเวลาต่อมาเวลาหมดอายุในไม่กี่วินาทีจะกำหนดเมื่อการรวมควรได้รับการพิจารณาขั้นสุดท้ายเนื่องจากไม่อนุญาตให้เพิ่มรายการใหม่อีกต่อไป ด้านบนของการรวมการรวมหลายการรวมสามารถคำนวณได้ พวกเขาสามารถเป็นประเภทการรวมตัวเดียวกันหรือแตกต่างกัน แต่ควรเขียนลงในตัวชี้วัดใหม่ที่ไม่ซ้ำกัน ชื่อตัวชี้วัดอาจรวมถึงการอ้างอิงกลับเช่นในการเขียนใหม่เพื่อให้ได้กฎการรวมตัวเดียวที่มีประสิทธิภาพซึ่งให้ผลในการรวมตัวหลายครั้ง เมื่อไม่มี send to ประโยคตัวชี้วัดที่ผลิตจะถูกส่งไปยังรีเลย์ราวกับว่าพวกเขาถูกส่งจากภายนอกดังนั้นจึงมีการจับคู่และกฎการรวมเข้าด้วยกัน ควรใช้ความระมัดระวังว่าจะหลีกเลี่ยงลูปด้วยวิธีนี้ ด้วยเหตุนี้จึงสนับสนุนการใช้ประโยค send to ประโยคเพื่อควบคุมการรับส่งสัญญาณที่เป็นไปได้ เช่นเดียวกับกฎการจับคู่มันเป็นไปได้ที่จะกำหนดเป้าหมายหลายคลัสเตอร์ เช่นเดียวกับกฎการจับคู่คำหลัก stop ใช้เพื่อควบคุมการไหลของตัวชี้วัดในกระบวนการจับคู่
send statistics to สร้างเลิกใช้แล้วและจะถูกลบออกในรุ่นถัดไป ใช้การสร้าง statistics พิเศษแทน
การสร้าง statistics สามารถควบคุมสองสิ่งเกี่ยวกับสถิติ (ภายใน) ที่ผลิตโดยรีเลย์ การ send to เป้าหมายสามารถใช้เพื่อหลีกเลี่ยงลูปเราเตอร์โดยการส่งสถิติไปยังคลัสเตอร์ปลายทางที่แน่นอน โดยค่าเริ่มต้นตัวชี้วัดจะถูกนำหน้าด้วย carbon.relays.<hostname> โดยที่ชื่อโฮสต์จะถูกกำหนดในการเริ่มต้นและสามารถแทนที่โดยใช้อาร์กิวเมนต์ -H คำนำหน้านี้สามารถตั้งค่าได้โดยใช้ prefix with ข้อคล้ายกับเป้าหมายกฎการเขียนซ้ำ การจับคู่อินพุตในกรณีนี้คือนิพจน์ปกติที่ตั้งค่าไว้ล่วงหน้า ^(([^.]+)(..*)?)$ บนชื่อโฮสต์ ดังนั้นเราจะเห็นว่าคำนำหน้าเริ่มต้นถูกตั้งค่าโดย carbon.relays..1 โปรดทราบว่าสิ่งนี้ใช้คุณลักษณะการแทนที่แบบแทนที่-กับ-ไม่ได้รับการตอบโต้จากกฎการเขียนซ้ำ เมื่อพิจารณาจากนิพจน์อินพุตกลุ่มการจับคู่ต่อไปนี้จะพร้อมใช้งาน: 1 ชื่อโฮสต์ทั้งหมด, 2 ชื่อโฮสต์สั้นและ 3 ชื่อโดเมน (พร้อมจุดนำ) มันอาจสมเหตุสมผลที่จะแทนที่ค่าเริ่มต้นโดยบางอย่างเช่น carbon.relays._2 สำหรับสถานการณ์บางอย่างเพื่อใช้ชื่อโฮสต์สั้น ๆ ที่ลดลงเสมอซึ่งตามนิพจน์ไม่มีจุด โดยค่าเริ่มต้นตัวชี้วัดจะถูกส่งทุก ๆ 60 วินาทีสิ่งนี้สามารถเปลี่ยนแปลงได้โดยใช้ submit every <interval> seconds เพื่อให้ได้ชุดค่าที่เข้ากันได้มากขึ้นไปยังคาร์บอนแคชใช้ reset counters after interval เพื่อทำให้ค่าไม่สะสมนั่นคือพวกเขาจะรายงานการเปลี่ยนแปลง
พอร์ตและโปรโตคอลรีเลย์ควรฟังการเชื่อมต่อที่เข้ามาสามารถระบุได้โดยใช้คำสั่ง listen ปัจจุบันผู้ฟังทุกคนจำเป็นต้องเป็นประเภท linemode สามารถระบุการบีบอัดหรือการเข้ารหัสที่เป็นตัวเลือกสำหรับพอร์ตและอินเทอร์เฟซเสริมที่กำหนดโดยที่อยู่ IP หรือซ็อกเก็ต Unix ตามไฟล์ เมื่อไม่ได้ระบุอินเตอร์เฟสอินเทอร์เฟซใด ๆ ในโปรโตคอล IP ที่มีอยู่ทั้งหมดจะถูกสันนิษฐาน หากไม่มี listen คำสั่งการถ่ายทอดรีเลย์จะใช้ตัวฟังเริ่มต้นสำหรับพอร์ต 2003 บน TCP และ UDP รวมถึงซ็อกเก็ต Unix /tmp/.s.carbon-c-relay.2003 โดยทั่วไปจะขยายไปยังผู้ฟัง 5 คนในระบบที่เปิดใช้งาน IPv6 ค่าเริ่มต้นตรงกับพฤติกรรมของเวอร์ชันก่อน v3.2
ในกรณีที่การกำหนดค่าจะยาวมากหรือมีการจัดการที่ดีขึ้นในไฟล์แยกต่างหากคำสั่ง include สามารถใช้อ่านไฟล์อื่นได้ ไฟล์ที่กำหนดจะถูกอ่านและเพิ่มลงในการกำหนดค่าเราเตอร์ในเวลาที่รวม ผลลัพธ์ที่ได้คือการกำหนดค่าเส้นทางที่ยิ่งใหญ่อย่างหนึ่ง สามารถใช้คำ include หลายรายการได้ตลอดทั้งไฟล์การกำหนดค่า การวางตำแหน่งจะมีผลต่อลำดับของกฎตามปกติ ระวังว่ารองรับการรวมแบบเรียกซ้ำ ( include จากไฟล์ที่รวมอยู่) ได้รับการสนับสนุนและในปัจจุบันไม่มีการป้องกันสำหรับการวนรอบ สำหรับสิ่งที่คุ้มค่าคุณลักษณะนี้น่าจะใช้กับไฟล์การกำหนดค่าที่ดีที่สุด (เช่นไม่มี include ในนั้น)
คาร์บอน-C-Relay พัฒนาขึ้นเมื่อเวลาผ่านไปคุณลักษณะที่เพิ่มขึ้นตามความต้องการเนื่องจากเครื่องมือพิสูจน์แล้วว่ามีความมั่นคงและเหมาะสมกับงานได้ดี ด้านล่างติดตามตัวอย่างของการสร้างที่สามารถใช้กับรีเลย์ได้
กลุ่มสามารถกำหนดได้มากเท่าที่จำเป็น พวกเขาได้รับข้อมูลจากกฎการจับคู่และประเภทของพวกเขาจะกำหนดสมาชิกของคลัสเตอร์ในที่สุดจะได้รับข้อมูลการวัด แบบฟอร์มคลัสเตอร์ที่ง่ายที่สุดคือคลัสเตอร์ forward :
cluster send-through
forward
10.1.0.1
;
ตัวชี้วัดใด ๆ ที่ส่งไปยังคลัสเตอร์ send-through จะถูกส่งต่อไปยังเซิร์ฟเวอร์ที่ที่อยู่ IPv4 10.1.0.1 หากเรากำหนดเซิร์ฟเวอร์หลายเครื่องเซิร์ฟเวอร์ทั้งหมดเหล่านั้นจะได้รับการวัดเดียวกันดังนั้น:
cluster send-through
forward
10.1.0.1
10.2.0.1
;
ผลลัพธ์ข้างต้นในการทำซ้ำของตัวชี้วัดส่งไปยังทั้งสองเครื่อง สิ่งนี้มีประโยชน์ แต่ส่วนใหญ่ไม่ได้ ประเภทของคลัสเตอร์ any_of เป็นเหมือน forward แต่จะส่งแต่ละตัวชี้วัดที่เข้ามาให้กับสมาชิกคนใด ๆ ตัวอย่างเดียวกันกับคลัสเตอร์ดังกล่าวจะเป็น:
cluster send-to-any-one
any_of 10.1.0.1:2010 10.1.0.1:2011;
สิ่งนี้จะใช้สถานการณ์หลายอย่างที่ใช้เซิร์ฟเวอร์สองเซิร์ฟเวอร์โหลดระหว่างพวกเขาจะแพร่กระจาย แต่หากมีการใด ๆ ล้มเหลวตัวชี้วัดทั้งหมดจะถูกส่งไปยังเซิร์ฟเวอร์ที่เหลือ โดยทั่วไปจะใช้งานได้ดีสำหรับรีเลย์ต้นน้ำหรือเพื่อปรับสมดุลกระบวนการแคชคาร์บอนที่ทำงานบนเครื่องเดียวกัน หากสมาชิกคนใดไม่สามารถใช้งานได้เช่นเนื่องจากการรีสตาร์ทการรีสตาร์ทสมาชิกคนอื่น ๆ จะได้รับการจราจร หากมีความจำเป็นที่จะต้องมีความล้มเหลวอย่างแท้จริงโดยที่เซิร์ฟเวอร์รองจะใช้ก็ต่อเมื่อมีการลงครั้งแรกสิ่งต่อไปนี้จะนำไปใช้:
cluster try-first-then-second
failover 10.1.0.1:2010 10.1.0.1:2011;
ประเภทเหล่านี้แตกต่างจากสองประเภทแฮชที่สอดคล้องกัน:
cluster graphite
carbon_ch
127.0.0.1:2006=a
127.0.0.1:2007=b
127.0.0.1:2008=c
;
หากสมาชิกในตัวอย่างนี้ล้มเหลวตัวชี้วัดทั้งหมดที่จะไปหาสมาชิกนั้นจะถูกเก็บไว้ในคิวรอให้สมาชิกกลับมา สิ่งนี้มีประโยชน์สำหรับกลุ่มเครื่องแคชคาร์บอนซึ่งเป็นที่พึงปรารถนาที่ตัวชี้วัดเดียวกันจะจบลงบนเซิร์ฟเวอร์เดียวกันเสมอ ประเภทคลัสเตอร์ carbon_ch เข้ากันได้กับแฮชที่สอดคล้องกับคาร์บอนที่สอดคล้องกันและสามารถใช้สำหรับกลุ่มที่มีอยู่ซึ่งมีคาร์บอน-การปล่อยคาร์บอน อย่างไรก็ตามสำหรับคลัสเตอร์ใหม่จะเป็นการดีกว่าที่จะใช้ประเภทคลัสเตอร์ fnv1a_ch เพราะมันเร็วขึ้นและอนุญาตให้สมดุลกับที่อยู่เดียวกัน แต่พอร์ตที่แตกต่างกันโดยไม่มีหมายเลขอิน carbon_ch
เนื่องจากเราสามารถใช้หลายกลุ่มเราจึงสามารถทำซ้ำได้โดยไม่ต้องใช้ประเภทคลัสเตอร์ forward ด้วยวิธีที่ชาญฉลาดยิ่งขึ้น:
cluster dc-old
carbon_ch replication 2
10.1.0.1
10.1.0.2
10.1.0.3
;
cluster dc-new1
fnv1a_ch replication 2
10.2.0.1
10.2.0.2
10.2.0.3
;
cluster dc-new2
fnv1a_ch replication 2
10.3.0.1
10.3.0.2
10.3.0.3
;
match *
send to dc-old
;
match *
send to
dc-new1
dc-new2
stop
;
ในตัวอย่างนี้ตัวชี้วัดที่เข้ามาทั้งหมดจะถูกส่งไปยัง dc-old เป็นครั้งแรกจากนั้น dc-new1 และในที่สุดก็ถึง dc-new2 โปรดทราบว่าประเภทคลัสเตอร์ของ dc-old นั้นแตกต่างกัน ตัวชี้วัดที่เข้ามาแต่ละตัวจะถูกส่งไปยังสมาชิก 2 คนของทั้งสามกลุ่มดังนั้นจึงเลียนแบบไปยังจุดหมายปลายทางทั้งหมด 6 แห่ง สำหรับแต่ละคลัสเตอร์สมาชิกปลายทางจะถูกคำนวณอย่างอิสระ ความล้มเหลวของกลุ่มหรือสมาชิกไม่ส่งผลกระทบต่อผู้อื่นเนื่องจากทุกคนมีคิวแต่ละรายการ ตัวอย่างข้างต้นสามารถเขียนได้โดยใช้กฎการจับคู่สามข้อสำหรับแต่ละ DC หรือกฎการจับคู่หนึ่งรายการสำหรับ DC ทั้งสาม ความแตกต่างส่วนใหญ่ในประสิทธิภาพจำนวนครั้งที่ตัวชี้วัดที่เข้ามาจะต้องจับคู่กับนิพจน์ กฎ stop ในกฎการจับคู่ dc-new ไม่จำเป็นอย่างเคร่งครัดในตัวอย่างนี้เนื่องจากไม่มีกฎการจับคู่ต่อไปนี้อีกต่อไป อย่างไรก็ตามหากการจับคู่จะกำหนดเป้าหมายชุดย่อยเฉพาะเช่น ^sys. และกลุ่มอื่น ๆ จะถูกกำหนดสิ่งนี้อาจจำเป็นเช่นในตัวอย่างย่อต่อไปนี้:
cluster dc1-sys ... ;
cluster dc2-sys ... ;
cluster dc1-misc ... ;
cluster dc2-misc ... ;
match ^sys. send to dc1-sys;
match ^sys. send to dc2-sys stop;
match * send to dc1-misc;
match * send to dc2-misc stop;
ดังที่เห็นได้โดยไม่ต้อง stop ในกฎการจับคู่ DC2-SYS ตัวชี้วัดทั้งหมดเริ่มต้นด้วย sys. จะส่งไปยัง DC1-MISC และ DC2-MISC แน่นอนว่านี่เป็นที่ต้องการแน่นอน แต่ในตัวอย่างนี้มีคลัสเตอร์เฉพาะสำหรับตัวชี้วัด sys
สมมติว่าจะมีตัวชี้วัดที่ไม่พึงประสงค์บางอย่างที่น่าเสียดายที่ถูกสร้างขึ้นมาสมมติว่าซอฟต์แวร์ที่ไม่ดี/เก่า เราไม่ต้องการเก็บเมตริกนี้ คลัสเตอร์ blackhole นั้นเหมาะสำหรับสิ่งนั้นเมื่อมันยากที่จะยกระดับตัวชี้วัดทั้งหมดที่ต้องการ พิจารณาสิ่งต่อไปนี้:
match
some_legacy1$
some_legacy2$
send to blackhole
stop;
สิ่งนี้จะทิ้งการวัดทั้งหมดที่ลงท้ายด้วย some_legacy ซึ่งอาจเป็นเรื่องยากที่จะกรองออก เนื่องจากการสั่งซื้อมีความสำคัญสามารถใช้ในโครงสร้างเช่นนี้:
cluster old ... ;
cluster new ... ;
match * send to old;
match unwanted send to blackhole stop;
match * send to new;
ในตัวอย่างนี้คลัสเตอร์เก่าจะได้รับตัวชี้วัดที่ไม่ต้องการสำหรับคลัสเตอร์ใหม่ ดังนั้นลำดับที่กฎเกิดขึ้นมีความสำคัญสำหรับการดำเนินการ
การตรวจสอบความถูกต้องสามารถใช้เพื่อให้แน่ใจว่าข้อมูลสำหรับตัวชี้วัดเป็นไปตามที่คาดไว้ การตรวจสอบความถูกต้องทั่วโลกสำหรับค่าเพียงจำนวน (ไม่มีจุดลอยตัว) อาจเป็น:
match *
validate ^[0-9]+ [0-9]+$ else drop
;
(หมายเหตุการหลบหนีด้วย backslash ของพื้นที่คุณอาจใช้ s หรือ [:space:] แทนสิ่งนี้ขึ้นอยู่กับการใช้งาน Regex ที่กำหนดค่าของคุณ)
ประโยคการตรวจสอบสามารถมีอยู่ในกฎการแข่งขันทุกครั้งดังนั้นในหลักการต่อไปนี้จึงถูกต้อง:
match ^foo
validate ^[0-9]+ [0-9]+$ else drop
send to integer-cluster
;
match ^foo
validate ^[0-9.e+-]+ [0-9.e+-]+$ else drop
send to float-cluster
stop;
โปรดทราบว่าพฤติกรรมนั้นแตกต่างกันในสองตัวอย่างก่อนหน้า เมื่อไม่ได้ระบุ send to กลุ่มข้อผิดพลาดการตรวจสอบความถูกต้องจะทำให้การจับคู่ทำงานเหมือนคำหลัก stop มีอยู่ Likewise, when validation passes, processing continues with the next rule. When destination clusters are present, the match respects the stop keyword as normal. When specified, processing will always stop when specified so. However, if validation fails, the rule does not send anything to the destination clusters, the metric will be dropped or logged, but never sent.
The relay is capable of rewriting incoming metrics on the fly. This process is done based on regular expressions with capture groups that allow to substitute parts in a replacement string. Rewrite rules allow to cleanup metrics from applications, or provide a migration path. In it's simplest form a rewrite rule looks like this:
rewrite ^server.(.+).(.+).([a-zA-Z]+)([0-9]+)
into server._1.2.3.34
;
In this example a metric like server.DC.role.name123 would be transformed into server.dc.role.name.name123 . For rewrite rules hold the same as for matches, that their order matters. Hence to build on top of the old/new cluster example done earlier, the following would store the original metric name in the old cluster, and the new metric name in the new cluster:
rewrite ^server.(.+).(.+).([a-zA-Z]+)([0-9]+)
into server._1.2.3.34
;
rewrite ^server.(.+).(.+).([a-zA-Z]+)([0-9]+)
into server.g{_1}.g{2}.g{3}.g{3}g{4}
;
The alternate syntax for backreference notation using g{n} instead of n notation shown above. Both rewrite rules are identical.
match * send to old;
rewrite ... ;
match * send to new;
Note that after the rewrite, the original metric name is no longer available, as the rewrite happens in-place.
Aggregations are probably the most complex part of carbon-c-relay. Two ways of specifying aggregates are supported by carbon-c-relay. The first, static rules, are handled by an optimiser which tries to fold thousands of rules into groups to make the matching more efficient. The second, dynamic rules, are very powerful compact definitions with possibly thousands of internal instantiations. A typical static aggregation looks like:
aggregate
^sys.dc1.somehost-[0-9]+.somecluster.mysql.replication_delay
^sys.dc2.somehost-[0-9]+.somecluster.mysql.replication_delay
every 10 seconds
expire after 35 seconds
timestamp at end of bucket
compute sum write to
mysql.somecluster.total_replication_delay
compute average write to
mysql.somecluster.average_replication_delay
compute max write to
mysql.somecluster.max_replication_delay
compute count write to
mysql.somecluster.replication_delay_metric_count
;
In this example, four aggregations are produced from the incoming matching metrics. In this example we could have written the two matches as one, but for demonstration purposes we did not. Obviously they can refer to different metrics, if that makes sense. The every 10 seconds clause specifies in what interval the aggregator can expect new metrics to arrive. This interval is used to produce the aggregations, thus each 10 seconds 4 new metrics are generated from the data received sofar. Because data may be in transit for some reason, or generation stalled, the expire after clause specifies how long the data should be kept before considering a data bucket (which is aggregated) to be complete. In the example, 35 was used, which means after 35 seconds the first aggregates are produced. It also means that metrics can arrive 35 seconds late, and still be taken into account. The exact time at which the aggregate metrics are produced is random between 0 and interval (10 in this case) seconds after the expiry time. This is done to prevent thundering herds of metrics for large aggregation sets. The timestamp that is used for the aggregations can be specified to be the start , middle or end of the bucket. Original carbon-aggregator.py uses start , while carbon-c-relay's default has always been end . The compute clauses demonstrate a single aggregation rule can produce multiple aggregates, as often is the case. Internally, this comes for free, since all possible aggregates are always calculated, whether or not they are used. The produced new metrics are resubmitted to the relay, hence matches defined before in the configuration can match output of the aggregator. It is important to avoid loops, that can be generated this way. In general, splitting aggregations to their own carbon-c-relay instance, such that it is easy to forward the produced metrics to another relay instance is a good practice.
The previous example could also be written as follows to be dynamic:
aggregate
^sys.dc[0-9].(somehost-[0-9]+).([^.]+).mysql.replication_delay
every 10 seconds
expire after 35 seconds
compute sum write to
mysql.host.1.replication_delay
compute sum write to
mysql.host.all.replication_delay
compute sum write to
mysql.cluster.2.replication_delay
compute sum write to
mysql.cluster.all.replication_delay
;
Here a single match, results in four aggregations, each of a different scope. In this example aggregation based on hostname and cluster are being made, as well as the more general all targets, which in this example have both identical values. Note that with this single aggregation rule, both per-cluster, per-host and total aggregations are produced. Obviously, the input metrics define which hosts and clusters are produced.
With use of the send to clause, aggregations can be made more intuitive and less error-prone. Consider the below example:
cluster graphite fnv1a_ch ip1 ip2 ip3;
aggregate ^sys.somemetric
every 60 seconds
expire after 75 seconds
compute sum write to
sys.somemetric
send to graphite
stop
;
match * send to graphite;
It sends all incoming metrics to the graphite cluster, except the sys.somemetric ones, which it replaces with a sum of all the incoming ones. Without a stop in the aggregate, this causes a loop, and without the send to , the metric name can't be kept its original name, for the output now directly goes to the cluster.
When configuring cluster you might want to check how the metrics will be routed and hashed. That's what the -t flag is for. For the following configuration:
cluster graphite_swarm_odd
fnv1a_ch replication 1
host01.dom:2003=31F7A65E315586AC198BD798B6629CE4903D089947
host03.dom:2003=9124E29E0C92EB63B3834C1403BD2632AA7508B740
host05.dom:2003=B653412CD96B13C797658D2C48D952AEC3EB667313
;
cluster graphite_swarm_even
fnv1a_ch replication 1
host02.dom:2003=31F7A65E315586AC198BD798B6629CE4903D089947
host04.dom:2003=9124E29E0C92EB63B3834C1403BD2632AA7508B740
host06.dom:2003=B653412CD96B13C797658D2C48D952AEC3EB667313
;
match *
send to
graphite_swarm_odd
graphite_swarm_even
stop
;
Running the command: echo "my.super.metric" | carbon-c-relay -f config.conf -t , will result in:
[...]
match
* -> my.super.metric
fnv1a_ch(graphite_swarm_odd)
host03.dom:2003
fnv1a_ch(graphite_swarm_even)
host04.dom:2003
stop
You now know that your metric my.super.metric will be hashed and arrive on the host03 and host04 machines. Adding the -d flag will increase the amount of information by showing you the hashring
When carbon-c-relay is run without -d or -s arguments, statistics will be produced. By default they are sent to the relay itself in the form of carbon.relays.<hostname>.* . See the statistics construct to override this prefix, sending interval and values produced. While many metrics have a similar name to what carbon-cache.py would produce, their values are likely different. By default, most values are running counters which only increase over time. The use of the nonNegativeDerivative() function from graphite is useful with these.
The following metrics are produced under the carbon.relays.<hostname> namespace:
metricsReceived
The number of metrics that were received by the relay. Received here means that they were seen and processed by any of the dispatchers.
metricsSent
The number of metrics that were sent from the relay. This is a total count for all servers combined. When incoming metrics are duplicated by the cluster configuration, this counter will include all those duplications. In other words, the amount of metrics that were successfully sent to other systems. Note that metrics that are processed (received) but still in the sending queue (queued) are not included in this counter.
metricsDiscarded
The number of input lines that were not considered to be a valid metric. Such lines can be empty, only containing whitespace, or hitting the limits given for max input length and/or max metric length (see -m and -M options).
metricsQueued
The total number of metrics that are currently in the queues for all the server targets. This metric is not cumulative, for it is a sample of the queue size, which can (and should) go up and down. Therefore you should not use the derivative function for this metric.
metricsDropped
The total number of metric that had to be dropped due to server queues overflowing. A queue typically overflows when the server it tries to send its metrics to is not reachable, or too slow in ingesting the amount of metrics queued. This can be network or resource related, and also greatly depends on the rate of metrics being sent to the particular server.
metricsBlackholed
The number of metrics that did not match any rule, or matched a rule with blackhole as target. Depending on your configuration, a high value might be an indication of a misconfiguration somewhere. These metrics were received by the relay, but never sent anywhere, thus they disappeared.
metricStalls
The number of times the relay had to stall a client to indicate that the downstream server cannot handle the stream of metrics. A stall is only performed when the queue is full and the server is actually receptive of metrics, but just too slow at the moment. Stalls typically happen during micro-bursts, where the client typically is unaware that it should stop sending more data, while it is able to.
connections
The number of connect requests handled. This is an ever increasing number just counting how many connections were accepted.
disconnects
The number of disconnected clients. A disconnect either happens because the client goes away, or due to an idle timeout in the relay. The difference between this metric and connections is the amount of connections actively held by the relay. In normal situations this amount remains within reasonable bounds. Many connections, but few disconnections typically indicate a possible connection leak in the client. The idle connections disconnect in the relay here is to guard against resource drain in such scenarios.
dispatch_wallTime_us
The number of microseconds spent by the dispatchers to do their work. In particular on multi-core systems, this value can be confusing, however, it indicates how long the dispatchers were doing work handling clients. It includes everything they do, from reading data from a socket, cleaning up the input metric, to adding the metric to the appropriate queues. The larger the configuration, and more complex in terms of matches, the more time the dispatchers will spend on the cpu. But also time they do /not/ spend on the cpu is included in this number. It is the pure wallclock time the dispatcher was serving a client.
dispatch_sleepTime_us
The number of microseconds spent by the dispatchers sleeping waiting for work. When this value gets small (or even zero) the dispatcher has so much work that it doesn't sleep any more, and likely can't process the work in a timely fashion any more. This value plus the wallTime from above sort of sums up to the total uptime taken by this dispatcher. Therefore, expressing the wallTime as percentage of this sum gives the busyness percentage draining all the way up to 100% if sleepTime goes to 0.
server_wallTime_us
The number of microseconds spent by the servers to send the metrics from their queues. This value includes connection creation, reading from the queue, and sending metrics over the network.
dispatcherX
For each indivual dispatcher, the metrics received and blackholed plus the wall clock time. The values are as described above.
destinations.X
For all known destinations, the number of dropped, queued and sent metrics plus the wall clock time spent. The values are as described above.
aggregators.metricsReceived
The number of metrics that were matched an aggregator rule and were accepted by the aggregator. When a metric matches multiple aggregators, this value will reflect that. A metric is not counted when it is considered syntactically invalid, eg no value was found.
aggregators.metricsDropped
The number of metrics that were sent to an aggregator, but did not fit timewise. This is either because the metric was too far in the past or future. The expire after clause in aggregate statements controls how long in the past metric values are accepted.
aggregators.metricsSent
The number of metrics that were sent from the aggregators. These metrics were produced and are the actual results of aggregations.
Please report them at: https://github.com/grobian/carbon-c-relay/issues
Fabian Groffen <[email protected]>
All other utilities from the graphite stack.
This project aims to be a fast replacement of the original Carbon relay. carbon-c-relay aims to deliver performance and configurability. Carbon is single threaded, and sending metrics to multiple consistent-hash clusters requires chaining of relays. This project provides a multithreaded relay which can address multiple targets and clusters for each and every metric based on pattern matches.
There are a couple more replacement projects out there, which are carbon-relay-ng and graphite-relay.
Compared to carbon-relay-ng, this project does provide carbon's consistent-hash routing. graphite-relay, which does this, however doesn't do metric-based matches to direct the traffic, which this project does as well. To date, carbon-c-relay can do aggregations, failover targets and more.
This program was originally developed for Booking.com, which approved that the code was published and released as Open Source on GitHub, for which the author would like to express his gratitude. Development has continued since with the help of many contributors suggesting features, reporting bugs, adding patches and more to make carbon-c-relay into what it is today.
