Finagle is our fault tolerant, prot

Finagle is our fault tolerant, protocol-agnostic RPC framework built atop Netty. Twitter’s core services are built on Finagle, from backends serving user profile information, Tweets, and timelines to front end API endpoints handling HTTP requests.

Part of scaling Twitter was the shift from a monolithic Ruby on Rails application to a service-oriented architecture. In order to build out this new architecture we needed a performant, fault tolerant, protocol-agnostic, asynchronous RPC framework. Within a service-oriented architecture, services spend most of their time waiting for responses from other upstream services. Using an asynchronous library allows services to concurrently process requests and take full advantage of the hardware. While Finagle could have been built directly on top of NIO, Netty had already solved many of the problems we would have encountered as well as provided a clean and clear API.

Twitter is built atop several open source protocols: primarily HTTP, Thrift, Memcached, MySQL, and Redis. Our network stack would need to be flexible enough that it could speak any of these protocols and extensible enough that we could easily add more. Netty isn’t tied to any particular protocol. Adding to it is as simple as creating the appropriate event handlers. This extensibility has lead to many community driven protocol implementations including, SPDY, PostrgreSQL, WebSockets, IRC, and AWS.

Netty’s connection management and protocol agnosticism provided an excellent base from which Finagle could be built. However we had a few other requirements Netty couldn’t satisfy out of the box as those requirements are more “high-level”. Clients need to connect to and load balance across a cluster of servers. All services need to export metrics (request rates, latencies, etc) that provide valuable insight for debugging service behavior. With a service-oriented architecture a single request may go through dozens of services making debugging performance issues nearly impossible without a tracing framework. Finagle was built to solve these problems. In the end Finagle relies on Netty for IO multiplexing providing a transaction-oriented framework on top of Netty’s connection-oriented model.

ผลลัพธ์ (ไทย) 1:

Finagle เป็นของเราบกพร่องป้องกันความผิดพลาด agnostic โพรโทคอล RPC กรอบสร้างขึ้นบนยอด Netty บริการหลักของ twitter อยู่บน Finagle จาก backends ให้บริการข้อมูลส่วนกำหนดค่าผู้ใช้ เข้ามา และเส้นเวลาเพื่อปลายทางสิ้นสุดหน้า API การจัดการการร้องขอ HTTPส่วนของมาตราส่วน Twitter ถูกเปลี่ยนจากรูเสาหินบนรางประยุกต์สถาปัตยกรรมที่เด่น การสร้างสถาปัตยกรรมใหม่นี้ออก เราต้อง performant บกพร่องป้องกันความผิดพลาด โพรโทคอล agnostic แบบอะซิงโครนัส RPC กรอบ ภายในมีสถาปัตยกรรมที่เด่น บริการใช้เวลารอคำตอบจากการให้บริการขั้นต้นน้ำอื่น ๆ ส่วนใหญ่ ใช้ไลบรารีการแบบอะซิงโครนัสให้บริการพร้อมประมวลผลการร้องขอ และใช้ประโยชน์จากฮาร์ดแวร์ ในขณะที่ Finagle ไม่ได้ถูกสร้างขึ้นโดยตรงบน NIO, Netty มีแล้วแก้ไขปัญหาเราจะได้พบเช่นเดียว กับให้ API สะอาด และใสขึ้นทวิตเตอร์ถูกสร้างขึ้นบนยอดหลายแหล่งเปิดโปรโตคอล: หลัก HTTP เกี่ยวกับภัตตาคาร Memcached, MySQL และคุณ Redis กองซ้อนของเครือข่ายจะต้องมีความยืดหยุ่นพอที่จะสามารถพูดถึงโพรโทคอเหล่านี้ และสามารถเพิ่มความสามารถเพียงพอที่เราสามารถเพิ่มข้อมูลเพิ่มเติม Netty ไม่เชื่อมโยงกับโพรโทคอเฉพาะใด ๆ เพิ่มได้เป็นง่าย ๆ เป็นการสร้างตัวจัดการเหตุการณ์ที่เหมาะสม เพิ่มความสามารถนี้ได้นำไปหลายชุมชนขับเคลื่อนใช้งานโพรโทคอลรวม ทั้ง SPDY, PostrgreSQL, WebSockets, IRC, AWSของ netty เชื่อมต่อโพรโทคอลและจัดการลัทธิอไญยนิยมมาเที่ยวที่สามารถสร้าง Finagle แต่เรามีกันกี่ ความ Netty ไม่สามารถตอบสนองกล่อง ตามความต้องมากขึ้น "ระดับสูง" ลูกค้าที่ต้องการเชื่อมต่อ และโหลดในคลัสเตอร์ของเซิร์ฟเวอร์ บริการทั้งหมดต้องส่งวัด (ขอราคา เวลาแฝง ฯลฯ) ที่ให้ความเข้าใจที่มีคุณค่าสำหรับการดีบักพฤติกรรมบริการ ด้วยสถาปัตยกรรมที่เด่น คำเดียวอาจไปถึงของบริการที่ทำให้ประสิทธิภาพการทำงานดีบักปัญหาเกือบเป็นไปไม่ได้ โดยไม่มีกรอบการติดตาม Finagle ถูกสร้างขึ้นเพื่อแก้ปัญหาเหล่านี้ ในสุด Finagle อาศัย Netty สำหรับมัลติเพล็กซ์แบบให้กรอบเน้นธุรกรรมบนรูปแบบการมุ่งเน้นการเชื่อมต่อของ Netty IO

ผลลัพธ์ (ไทย) 2:

finagle เป็นความผิดของเราใจกว้าง, กรอบ RPC โปรโตคอลไม่เชื่อเรื่องพระเจ้าสร้างอยู่บน Netty ทวิตเตอร์ของบริการหลักที่สร้างขึ้นบน finagle จากแบ็กเอนด์ที่ให้บริการข้อมูลของผู้ใช้รายละเอียดทวีตและระยะเวลาที่จะปลายด้านหน้าปลายทาง API จัดการการร้องขอ HTTP. เป็นส่วนหนึ่งของการปรับทวิตเตอร์ก็เปลี่ยนจากการประยุกต์ใช้เสาหิน Ruby on Rails ไปยังสถาปัตยกรรมบริการเชิง เพื่อที่จะสร้างออกสถาปัตยกรรมใหม่นี้เราจำเป็นต้องมี performant ผิดใจกว้าง, โปรโตคอลไม่เชื่อเรื่องพระเจ้ากรอบ RPC ไม่ตรงกัน ภายในสถาปัตยกรรมเชิงบริการบริการใช้เวลาส่วนใหญ่ของพวกเขารอคอยสำหรับการตอบสนองจากการให้บริการอื่น ๆ ที่ต้นน้ำ การใช้ห้องสมุดที่ไม่ตรงกันที่จะช่วยให้การบริการพร้อมประมวลผลการร้องขอและการใช้ประโยชน์จากฮาร์ดแวร์ ในขณะที่ finagle จะได้รับการสร้างขึ้นโดยตรงด้านบนของ NIO, Netty ได้แก้ไขแล้วหลายปัญหาที่เราจะได้พบเช่นเดียวกับการให้สะอาดและชัดเจน API. ทวิตเตอร์ที่ถูกสร้างขึ้นบนโปรโตคอลเปิดแหล่งที่มาหลาย HTTP หลักทริฟท์, Memcached, MySQL และ Redis สแต็คของเราจะเครือข่ายต้องมีความยืดหยุ่นพอที่จะสามารถพูดใด ๆ ของโปรโตคอลเหล่านี้และขยายพอที่จะทำให้เราสามารถเพิ่มมากขึ้น Netty ไม่เชื่อมโยงกับโปรโตคอลใดโดยเฉพาะ เพิ่มไปมันเป็นเรื่องง่ายเหมือนการสร้างจัดการเหตุการณ์ที่เหมาะสม ขยายนี้จะได้นำไปสู่หลายชุมชนที่ขับเคลื่อนด้วยการใช้งานโปรโตคอลรวมถึง SPDY, PostrgreSQL, WebSockets, ไออาร์ซีและ AWS. การจัดการการเชื่อมต่อ Netty และโปรโตคอล agnosticism ให้ฐานที่ดีจากการที่ finagle สามารถสร้าง แต่เรามีความต้องการอื่น ๆ ไม่กี่ Netty ไม่สามารถตอบสนองออกมาจากกล่องตามความต้องการของผู้ที่มีมากกว่า "ระดับสูง" ลูกค้าจำเป็นต้องเชื่อมต่อและโหลดสมดุลข้ามกลุ่มของเซิร์ฟเวอร์ บริการทั้งหมดต้องตัวชี้วัดการส่งออก (อัตราค่าบริการขอเวลาแฝง ฯลฯ ) ที่ให้ข้อมูลเชิงลึกที่มีคุณค่าสำหรับพฤติกรรมการใช้บริการการแก้จุดบกพร่อง ด้วยสถาปัตยกรรมที่มุ่งเน้นบริการคำขอเดียวอาจจะผ่านไปหลายสิบของการบริการที่ทำให้ปัญหาประสิทธิภาพการทำงานการแก้จุดบกพร่องเกือบเป็นไปไม่ได้โดยไม่ต้องมีกรอบการติดตาม finagle ถูกสร้างขึ้นเพื่อแก้ปัญหาเหล่านี้ ในท้าย finagle อาศัย Netty สำหรับมัลติ IO ให้กรอบการทำธุรกรรมที่มุ่งเน้นด้านบนของรูปแบบที่มุ่งเน้นการเชื่อมต่อของ Netty

ผลลัพธ์ (ไทย) 3:

โกงมันเป็นความผิดของเราใจกว้าง , โปรโตคอล RPC agnostic กรอบสร้างบนเน็ตตี้ . บริการหลักของ Twitter ถูกสร้างขึ้นบนโกง จากแบ็คเอนต์ให้ข้อมูลรายละเอียดของผู้ใช้ทวิตเตอร์ และระยะเวลาที่จะปลายด้านหน้า API ข้อมูลการจัดการการร้องขอ HTTP

ส่วนของ Twitter คือการเปลี่ยนจากทับทิมในทางรถไฟแบบประยุกต์กับสถาปัตยกรรมเชิงบริการในการสร้างสถาปัตยกรรมใหม่นี้เราต้องการนี , ความผิดใจกว้าง , โปรโตคอล RPC agnostic กรอบไม่ตรงกัน ภายในเป็นสถาปัตยกรรมที่มุ่งเน้นบริการบริการใช้จ่ายส่วนใหญ่ของเวลาของพวกเขากำลังรอคำตอบจากการบริการน้ำอื่น ๆ การใช้ห้องสมุดให้บริการควบคู่กันไปแบบกระบวนการร้องขอและใช้ประโยชน์จากฮาร์ดแวร์ในขณะที่โกงอาจได้รับการสร้างขึ้นโดยตรงด้านบนของนีโอ Netty ได้ , แก้ไขหลายปัญหาที่เราอาจจะเคยพบเห็น รวมทั้งให้สะอาดใส API

Twitter ถูกสร้างขึ้นบนระบบเปิดแหล่งที่มาหลายหลัก http Thrift Memcached , MySQL , และไม่จำเป็นต้อง .กองเครือข่ายของเราจะต้องยืดหยุ่นพอที่จะสามารถพูดใด ๆของระบบเหล่านี้และได้มากพอที่เราสามารถจะเพิ่มมากขึ้น เน็ตตี้ไม่ได้โยงกับโปรโตคอลที่เฉพาะเจาะจงใด ๆ เพิ่มมันเป็นง่ายๆเป็นการจัดการเหตุการณ์ที่เหมาะสม สายพันธุ์นี้ได้นำไปสู่หลายชุมชนขับเคลื่อนโปรโตคอลซึ่งรวมถึง spdy postrgresql websockets , , , IRC , และ AWS .

เชื่อมต่อโปรโตคอล Netty การจัดการและอไญยนิยมมีฐานที่ดีจากที่โกงจะถูกสร้างขึ้น อย่างไรก็ตามเราได้ไม่กี่อื่น ๆไม่สามารถตอบสนองความต้องการ Netty ออกจากกล่องความต้องการเหล่านั้นมี " ระดับสูง " ลูกค้าจะต้องเชื่อมต่อและสมดุลโหลดข้ามกลุ่มของเซิร์ฟเวอร์ บริการทั้งหมดจะต้องส่งออกเมตริก ( การเกิดอัตรา ขอฯลฯ ) ที่ให้ข้อมูลเชิงลึกที่มีคุณค่าสำหรับการแก้จุดบกพร่องของพฤติกรรมบริการ ด้วยสถาปัตยกรรมเชิงบริการคำขอเดียวอาจไปผ่านหลายสิบของบริการการแก้ไขปัญหาเกี่ยวกับประสิทธิภาพเกือบเป็นไปไม่ได้โดยไม่ต้องติดตามกรอบ โกงที่ถูกสร้างขึ้นเพื่อแก้ปัญหาเหล่านี้สุดท้ายโกงอาศัย Netty สำหรับ IO เพล็กซ์ให้ธุรกรรมเชิงกรอบด้านบนของ Netty ที่มุ่งเน้นการเชื่อมต่อแบบ