เป็นที่เชื่อกันโดยทั่วไปว่า RUST API เป็น API ที่มีประสิทธิภาพมากที่สุดเนื่องจากความหมายของภาษาและการจัดการหน่วยความจำด้วยตนเอง มักถูกนำไปเปรียบเทียบกับ C++ ในแง่ของประสิทธิภาพ แง่มุมที่ทำให้ฉันสงสัยก็คือ RUST เปรียบเทียบกับ Golang อย่างไร ฉันสามารถรวบรวมตัวเลขที่สามารถช่วยในการประเมินที่ครอบคลุมได้หรือไม่? ดังนั้นฉันจึงตัดสินใจสร้างพื้นฐานสำหรับ API ที่ค่อนข้างง่ายซึ่งเขียนด้วย RUST บทความนี้เน้นผลลัพธ์สำหรับประสิทธิภาพ

ข้อจำกัดความรับผิดชอบ: อย่าพึ่งพาบทความนี้ในการตัดสินใจเกี่ยวกับ Golang และ Rust ไม่ใช่บทความ A vs B ความตั้งใจคือการให้ข้อมูลสองสามจุดเมื่อต้องประเมิน สองภาษานี้อาจมีกรณีการใช้งานที่แตกต่างกันในโลกแห่งความเป็นจริง และต้องทำการประเมินกรณีการใช้งานอย่างรอบคอบก่อนที่จะเลือกภาษาใดภาษาหนึ่ง

ฉันอยากจะแนะนำให้อ่านบทความที่ฉันเขียนเมื่อสองสามวันก่อนเปรียบเทียบ Golang และ RUST บทความนั้นเป็นแรงจูงใจสำหรับบทความนี้ Golang เป็นภาษาของระบบที่มีประสิทธิผลสูง สามารถเปรียบเทียบกับสนิมได้ด้วยเหตุผลด้านประสิทธิภาพ แต่อะไรคือความแตกต่างที่แท้จริงระหว่างประสิทธิภาพระหว่าง Golang และสนิม เราสามารถหาจำนวนนี้ได้หรือไม่? นั่นเป็นเหตุผลที่ฉันต้องการเห็นสิ่งนี้ด้วยตัวเอง

ติดตั้ง

การตั้งค่าแบ่งออกเป็นสองขั้นตอนและการทดสอบ

การตั้งค่าแรกที่ฉันสร้างคือ REST API ใหม่ใน Rust เป็น API อย่างง่ายที่รับอินพุต JSON ยกเลิกการซีเรียลไลซ์ ตรวจสอบ และส่งคืนการตอบกลับ

การตั้งค่าที่สองจะรวมถึงการคำนวณแฮช MD5 กับทุกคำขอ และดูว่าสิ่งนั้นส่งผลต่อประสิทธิภาพอย่างไร ฉันเชื่อว่าการดำเนินการที่เน้น CPU เล็กน้อยจะมีผลกระทบต่อประสิทธิภาพของ API ฉันอาจจะคิดผิด!

ฉันเชื่อมต่อบิลด์นี้แล้วเรียกใช้การทดสอบประสิทธิภาพโดยเริ่มต้น VM ใหม่บน GCP เพื่อให้แน่ใจว่าฉันสามารถกำหนดการตั้งค่าบางอย่างให้เป็นมาตรฐานและทำซ้ำอีกครั้งสำหรับ API เดียวกันใน Golang

Dockerfile

ไฟล์นักเทียบท่าสำหรับแอปพลิเคชั่น rust ของฉันนั้นเรียบง่าย

FROM rust:1.63.0 AS build

WORKDIR /src/openab
COPY . .
RUN cd management-server && cargo install --path .
RUN ls -al /usr/local/cargo/bin

FROM debian:stable-slim
COPY --from=build /usr/local/cargo/bin/management-server /bin
CMD ["/bin/management-server"]

สคริปต์

import http from 'k6/http';
export default function () {
  const url = 'http://x.x.x.x:3000/experiments';
  const payload = JSON.stringify(
{
        "name":"new_home_page",
        "variants":[
                {
                        "name":"blue_button",
                        "allocation_percent":50.0
                },
                {
                        "name":"red_button",
                        "allocation_percent":50.0
                }
        ]
}
  );
const params = {
    headers: {
      'Content-Type': 'application/json',
    },
  };
http.post(url, payload, params);
}

k6 run --vus 3000 --iterations 1000000 script.js

ผลลัพธ์ สถานการณ์ที่ 1 — ไม่มีการสร้างแฮช

ด้านล่างนี้คือผลลัพธ์สำหรับการทดสอบครั้งแรกของเรา

ดูผลลัพธ์แล้วรู้สึกดีมาก ด้วย RAM เพียง 2 คอร์ 4 GB เราสามารถบรรลุปริมาณงาน 9.5K กับผู้ใช้เสมือน 3000คน CPU สูงสุดที่ 83% สำหรับเครื่อง

ผลลัพธ์สถานการณ์ #2

สำหรับสถานการณ์นี้ ฉันอัปเดตฐานโค้ดของเราเพื่อสร้างแฮช MD5 สำหรับชื่อการทดสอบและการประทับเวลา unix ที่ต่อกัน ฉันแทนที่ชื่อการทดสอบด้วยแฮชและส่งคืนเป็นคำตอบ

let digest = md5::compute(format!("{}-{}",e.name , since_the_epoch.as_secs()));
e.name = format!("{:x}", digest) ;

ผลลัพธ์ค่อนข้างจะเปรียบเทียบได้ แม้จะมีแฮช md5 ที่เพิ่มเข้ามา ผลลัพธ์ก็ลดลง 30 คำขอต่อวินาที มีผลกระทบเล็กน้อยต่อเวลาแฝง (เวลาตอบสนองที่ได้รับ) แต่นั่นเป็นการตอบสนองต่อแฮช

บทสรุป

เป็นเรื่องที่น่าสนใจที่เห็นผล และฉันค่อนข้างพอใจกับปริมาณงาน 9.5k/วินาทีสำหรับผู้ใช้เสมือน 3000 ราย — ด้วย JSON serialization และ deserialization เป็นพื้นฐานที่ดีสำหรับe2-mediumเครื่อง สิ่งหนึ่งที่ฉันสังเกตเห็นคือการใช้งาน CPU นั้นสม่ำเสมอและไม่มีการกระตุกใดๆ เวลาในการตอบสนองคำขอหรือประสิทธิภาพของ CPU นั้นไม่แตกต่างกันมากนักสำหรับผู้ใช้เสมือน 3000 คนพร้อมๆ กันที่ใช้บริการของเรา ผลลัพธ์สามารถคาดเดาได้มาก

นั่นคือทั้งหมดสำหรับการเปรียบเทียบ Rust Baseline ในบทความถัดไป ฉันจะเขียนโปรแกรมเดียวกันใน Golang และพยายามหาตัวเลขพื้นฐานสำหรับ API นี้ มันน่าสนใจที่จะดูว่าเกิดอะไรขึ้น ฉันตื่นเต้นกับสิ่งนี้!

โปรดคอยติดตามและติดตามฉันสำหรับสิ่งเพิ่มเติม!