บทเรียนที่ได้เรียนรู้จากการเปลี่ยนจาก Python ไปใช้ Rust

เมื่อตอนแรกที่ผมตัดสินใจย้ายสแต็กแบ็กเอนด์ของเราจาก Python ไปเป็น Rust มันไม่ได้เป็นเพียงแค่เรื่องของความอยากรู้ – แต่เกิดจากปัญหาจริงๆ ที่เกี่ยวกับประสิทธิภาพ ค่าใช้จ่ายในการดีพลอย และความเชื่อถือได้ภายใต้โหลดงาน ระบบนิเวศเว็บของ Python – โดยเฉพาะ FastAPI – นั้นสนุกในการทำงานด้วยเพื่อประสิทธิภาพการทำงานและการพัฒนาที่รวดเร็ว แต่เมื่อทราฟฟิกของเราเติบโตขึ้นและเพดานประสิทธิภาพชัดเจนขึ้น ผมอยากสำรวจว่า Rust จะเสนออะไรได้บ้าง

ในบทความนี้ผมจะแบ่งปันสิ่งที่ผมได้เรียนรู้ระหว่างทาง: ข้อดี ปัญหาต่างๆ และจุดที่แต่ละระบบนิเวศยังคงโดดเด่น

การเปรียบเทียบประสิทธิภาพ: Rust (Actix-Web) เทียบกับ Python (FastAPI)

ปริมาณงานดิบและความหน่วง

หนึ่งในสิ่งแรกที่ทำให้ผมตระหนักเมื่อทำการเบนช์มาร์กคือความแตกต่างของโปรไฟล์ประสิทธิภาพระหว่างเฟรมเวิร์กเว็บของ Rust และ Python

จากการเบนช์มาร์กอิสระหลายรายการ Actix-Web ของ Rust มีประสิทธิภาพเหนือกว่า FastAPI อย่างสม่ำเสมอในเรื่องคำขอต่อวินาทีและประสิทธิภาพหน่วยความจำ ในการเบนช์มาร์กของชุมชนหนึ่ง Actix-Web จัดการคำขอได้มากกว่าหลายพันคำขอต่อวินาทีด้วยความหน่วงที่ต่ำกว่าและการใช้หน่วยความจำที่ต่ำกว่ามากเมื่อเทียบกับ FastAPI

นี่สอดคล้องกับการสังเกตที่กว้างขึ้นว่า การนามธรรมที่ไม่มีต้นทุน ของ Rust และการขาดตัวรวบรวมขยะ ทำให้มันมีประสิทธิภาพเป็นพิเศษเมื่อให้บริการ HTTP ในระดับใหญ่

ผลกระทบในโลกจริง

จากประสบการณ์ของผม สิ่งนี้แปลเป็น:

• ปริมาณงานที่ยั่งยืนสูงกว่ามากในการทดสอบความเครียด
• ความแปรปรวนน้อยลงภายใต้โหลด
• การใช้หน่วยความจำในสภาวะไม่ทำงานที่ต่ำกว่าเมื่อเทียบกับโปรเซส Python

อย่างไรก็ตาม การเบนช์มาร์กบอกเพียงบางส่วนของเรื่องราว: ปัญหาคอขวดในโลกจริงมักจะถูกจำกัดโดยฐานข้อมูลหรือเครือข่าย สำหรับแอปพลิเคชันหลายตัว ประสิทธิภาพของ FastAPI นั้นเพียงพอ และการปรับแต่งการเข้าถึงฐานข้อมูลหรือการแคชให้ผลตอบแทนมากกว่าการเลือกภาษาเพียงอย่างเดียว

ความแตกต่างของ ORM: Diesel เทียบกับ SQLAlchemy

การเปลี่ยนกระบวนทัศน์ ORM เป็นหนึ่งในส่วนที่แตกต่างมากที่สุดในทางวัฒนธรรมของการย้ายข้อมูล

ระบบการย้ายข้อมูล

ใน Python เราใช้ SQLAlchemy กับการย้ายข้อมูล Alembic – วิธีการที่เปรียบเทียบโมเดลของคุณและสร้างสคริปต์การย้ายข้อมูลโดยอัตโนมัติ

ใน Rust เราย้ายไปใช้ Diesel ซึ่งมีจุดยืนที่แตกต่างกันมาก:

• การย้ายข้อมูลถูกเขียนด้วยมือเป็นไฟล์ SQL ที่ชัดเจน
• ไม่มีเครื่องมือเปรียบเทียบอัตโนมัติ
• คุณได้รับการควบคุมมากขึ้น – และความรับผิดชอบมากขึ้น

สิ่งนี้ทำให้หงุดหงิดในตอนแรก แต่ระเบียบวินัยในการเขียนการย้ายข้อมูลด้วยมือนำไปสู่การตรวจสอบที่ชัดเจนขึ้นและความประหลาดใจน้อยลงในโปรดักชัน

ความปลอดภัยของประเภทและการรับประกันเวลาคอมไพล์

นี่คือจุดที่ Diesel เปลี่ยนแปลงวิธีคิดของผมเกี่ยวกับโค้ดฐานข้อมูลจริงๆ: ความปลอดภัยของประเภทในเวลาคอมไพล์

Diesel สร้างประเภท Rust ตามสคีมาของคุณ ดังนั้นชื่อคอลัมน์ที่ไม่ตรงกันหรือโครงสร้างคิวรีที่ไม่ถูกต้องก็ไม่สามารถคอมไพล์ได้ แนวคิดต่างๆ เช่น check_for_backend และการต้องการการประกาศ table_name ที่ชัดเจน หมายความว่าบั๊กทั่วไปทั้งหมดหายไปก่อนที่คุณจะรันคิวรี

เมื่อเปรียบเทียบ SQLAlchemy จับข้อผิดพลาดหลายอย่างได้เฉพาะตอนรันไทม์เท่านั้น แม้ว่าจะเพิ่มความยืดหยุ่น แต่ก็หมายความว่าต้องพึ่งพาการทดสอบมากขึ้นเพื่อความถูกต้อง

การสร้างและดำเนินการคิวรี

ตัวสร้างคิวรีของ Diesel ใช้ระบบประเภทของ Rust และใช้โค้ดหลายบรรทัดมากกว่าเมื่อเทียบกับสไตล์การแสดงออกแบบไดนามิกของ SQLAlchemy – แต่การแลกเปลี่ยนคือคอมไพเลอร์พิสูจน์สิ่งต่างๆ ให้คุณมากมาย

หลังจากช่วงการปรับตัว ผมเริ่มชื่นชมว่าความชัดเจนของ Rust ช่วยอย่างไรเมื่อต้องนำทางตรรกะคิวรีที่ซับซ้อนระหว่างการรีแฟคเตอร์

การสนับสนุนการสร้าง OpenAPI อัตโนมัติ

หนึ่งในพื้นที่ที่ Python ยังคงรู้สึกนำหน้าแบบ out-of-the-box คือการสร้างสคีมา API

FastAPI สร้างเอกสาร OpenAPI โดยอัตโนมัติและมาพร้อมกับ UI เบราว์เซอร์เช่น ReDoc และ Swagger UI ที่ /docs และ /redoc ทำให้ง่ายมากสำหรับลูกค้าและเพื่อนร่วมทีมในการทำความเข้าใจและสำรวจ API ของคุณ

ระบบนิเวศของ Rust กำลังพัฒนาในที่นี่ เครื่องมือเช่น utoipa สามารถสร้างข้อมูลจำเพาะ OpenAPI สำหรับ Actix-Web แต่พวกเขารู้สึกด้วยตนเองและแยกส่วนมากกว่าเมื่อเทียบกับประสบการณ์ที่ไร้รอยต่อของ FastAPI มี crate ชุมชนเพื่อให้บริการ Swagger หรือ Redoc UI ด้วย แต่พวกเขาต้องการการตั้งค่าและคำอธิบายเพิ่มเติม

ผมคาดว่าช่องว่างนี้จะแคบลงต่อไป – มีความพยายามที่ดำเนินการอยู่ในชุมชน Rust เพื่อนำประสบการณ์เอกสาร API ที่ราบรื่นกว่าซึ่งแข่งขันกับ FastAPI

ขนาดการดีพลอย: การคอมไพล์เทียบกับการพึ่งพา

เวลาคอมไพล์ของ Rust

การคอมไพล์ของ Rust มีชื่อเสียงว่าช้ากว่าภาษาที่ตีความได้ ระหว่างการพัฒนา การรีบิลด์ – โดยเฉพาะกับ crate ขนาดใหญ่ – อาจรู้สึกเชื่องช้าเมื่อเทียบกับการรันสคริปต์ Python ใหม่

แต่ต้นทุนนี้คือเวลาพัฒนา ไม่ใช่เวลาโปรดักชัน เมื่อคอมไพล์แล้ว ไบนารี Rust จะ:

• คอมไพล์เต็มรูปแบบล่วงหน้า
• มีทุกอย่างในตัว (ไม่มี virtualenv โดยปกติไม่มีการพึ่งพาแบบไดนามิก)
• รอยเท้าที่เล็กมากในอิมเมจคอนเทนเนอร์

นั่นทำให้การดีพลอยง่ายและคาดเดาได้มากขึ้น

รอยเท้าการพึ่งพาของ Python

แอป Python มักนำกราฟการพึ่งพาขนาดใหญ่มาด้วย: FastAPI เอง uvicorn, pydantic (ตอนนี้เร็วขึ้นมากขอบคุณภายใน Rust) ไดรเวอร์ฐานข้อมูล ฯลฯ

สิ่งนี้เพิ่ม:

• ขนาดคอนเทนเนอร์
• ความซับซ้อนในการบิลด์
• พื้นที่สำหรับความขัดแย้งของการพึ่งพา

Cargo ของ Rust สร้างไบนารีหนึ่งตัวที่รวมทุกอย่างไว้ (โดยปกติ) ซึ่งทำให้เรื่องการดีพลอยง่ายขึ้นอย่างมาก

ความสามารถในการบำรุงรักษา

นี่คือพื้นที่ที่อาจมีการเติบโตส่วนบุคคลมากที่สุด

Rust ผลักดันคุณไปสู่ขอบเขตความเป็นเจ้าของที่ชัดเจน การจัดการข้อผิดพลาดที่ชัดเจน และการออกแบบที่ระมัดระวัง เมื่อคุณซึมซับข้อผิดพลาดการคอมไพล์ของ Rust แล้ว คอมไพเลอร์เองจะกลายเป็นราวกั้นที่แข็งแกร่งต่อการถดถอย

ในทางตรงกันข้าม ความเป็นไดนามิกของ Python สามารถรู้สึกง่ายดายระหว่างการพัฒนาในช่วงแรก – แต่ความยืดหยุ่นเดียวกันนั้นบางครั้งนำไปสู่บั๊กที่วินิจฉัยได้ยากกว่าในโปรดักชันเว้นแต่จะได้รับการสนับสนุนจากชุดทดสอบที่แข็งแกร่ง

โค้ดเบสของเรา Rust รู้สึกยืดหยุ่นมากขึ้นระหว่างการรีแฟคเตอร์ขนาดใหญ่ ส่วนใหญ่เป็นผลมาจากความเข้มงวดของคอมไพเลอร์

เอกสารและประสบการณ์นักพัฒนา

เอกสารอัตโนมัติของ FastAPI

การรวม FastAPI กับ OpenAPI พร้อมกับ ReDoc และ Swagger UI ทำให้การเข้าร่วมของนักพัฒนาใหม่ง่ายมาก มันเป็นหนึ่งในชิงชัยที่ใหญ่ที่สุดที่ผมได้เห็นในประสิทธิภาพการทำงานของทีม

การสร้างเอกสารของ Rust

เครื่องมือเอกสารในตัวของ Rust (cargo doc) นั้นยอดเยี่ยมสำหรับเอกสารระดับโค้ด มันสนับสนุนการเขียนเอกสารข้างๆ โค้ดของคุณ และ Rustdoc สร้างเอกสาร HTML ที่สะอาดและค้นหาได้

แม้ว่าจะไม่ได้แทนที่เอนด์พอยต์ /docs ที่ดีแบบ out of the box แต่ก็ปรับปรุงคุณภาพและการค้นพบเอกสารที่เน้นโค้ดได้อย่างมาก

บทสรุป

การเปลี่ยนจาก Python ไปเป็น Rust สำหรับการพัฒนาแบ็กเอนด์ไม่ได้เกี่ยวกับการชอบภาษาหนึ่งมากกว่าอีกภาษาหนึ่ง – มันเกี่ยวกับการจัดตำแหน่งให้สอดคล้องกับลำดับความสำคัญของโครงการของเรา

• Rust ให้ประสิทธิภาพ ความสามารถในการคาดเดา และความเชื่อถือได้ในทราฟฟิกโปรดักชัน
• Python ให้ความเร็วในการพัฒนาและการยศาสตร์ระดับโลก

ทั้งสองระบบนิเวศมีความแข็งแกร่ง สิ่งที่เปลี่ยนแปลงกับ Rust คือปัญหาหลายอย่างที่จะปรากฏเฉพาะตอนรันไทม์ใน Python จะถูกจับได้ตอนคอมไพล์ใน Rust แทน ลดความประหลาดใจและการหยุดทำงาน

การเลือก Rust หมายถึงการลงทุนในเส้นโค้งการเรียนรู้ – แต่สำหรับทีมที่ประสิทธิภาพและความถูกต้องสำคัญที่สุด การแลกเปลี่ยนนั้นคุ้มค่าสำหรับเรา

หมายเหตุผู้เขียน

บทความนี้เขียนโดยผู้สร้าง Hytale Multiplayer เว็บไซต์ที่เน้นบทความทางเทคนิคและการเจาะลึกเกม Hytale รวมถึงการพัฒนาเซิร์ฟเวอร์ เครื่องมือ และการเปรียบเทียบกับระบบนิเวศที่เกี่ยวข้องเช่น Minecraft หากคุณสนุกกับเนื้อหาที่เน้นวิศวกรรมแบบปฏิบัติ อย่าลังเลที่จะสำรวจบทความเพิ่มเติมที่นั่น