Home-theater-designers
HTTP משתמש בארכיטקטורת שרת-לקוח להעברת מידע ונתונים. אחת התכונות של שפות תכנות בצד השרת כמו Rust היא פיתוח שרתים ואפליקציות לקוח לאינטראקציה עם שירותים מבוססי HTTP.
Rust מתאים לבניית שרתי HTTP בשל תכונות הבטיחות, הביצועים והאמינות שלה. ארגזי צד שלישי של Rust כמו Actix ו- Rocket פופולריים לבניית שרתי אינטרנט מתוחכמים שיכולים להתמודד עם תעבורה גבוהה.
איפור של סרטון היום גלול כדי להמשיך עם התוכן
מדוע כדאי להשתמש ב- Rust לפיתוח שרת אינטרנט HTTP?
Rust צברה פופולריות לפיתוח שרתי אינטרנט מכיוון שחלק מהתכונות של השפה הן בדיוק הדרישות לבניית רוב שרתי האינטרנט.
השימוש ב-Rust מבטיח את קנה המידה של האפליקציה שלך ביעילות, מה שהופך את השפה לאידיאלית לבניית אפליקציות בעלות ביצועים גבוהים. להלן סיבות ספציפיות לשקול שימוש ב- Rust עבור שרת האינטרנט שלך ויישומים אחרים בצד השרת.
הביצועים הגבוהים של חלודה
ביצועים גבוהים הם אחת הסיבות לכך ש- Rust עושה בחירה מצוינת לבניית שרתי אינטרנט של HTTP. Rust מספקת גישה ברמה נמוכה למשאבי המערכת, כולל הזיכרון והמעבד, ומאפשרת לך לכתוב קוד שרץ מהר יותר עם פחות משאבים משפות אחרות בצד השרת.
בנוסף, מערכת הבעלות של Rust מבטלת את הצורך באיסוף אשפה בזמן הקומפילציה, וזו אחת הסיבות שחלק מהשפות בצד השרת איטיות.
בטיחות וביטחון
מערכת הבעלות של Rust לניהול זיכרון הופכת את השפה לאבטחת לפיתוח שרתי אינטרנט. אינך חווה הפניות מצביעות אפסיות או תלויות שעלולות להוביל לדליפות זיכרון ופגיעות אבטחה אחרות.
מערכת הבעלות של Rust מונע שגיאות נפוצות אלה כדי לשמור על אבטחת השרת והאפליקציות שלך. Rust מתמקדת גם במניעת הצפת מאגר ושגיאות אחרות הקשורות לזיכרון.
במקביל
במקביל היא היכולת להפעיל יחידות מרובות של תוכנית בצורה לא מסודרת מבלי להשפיע על הפלט. הפלט של תוכנית במקביל צריך להיות זהה לפלט של תוכנית אסינכרונית.
במקביל יכולה להשפיע באופן משמעותי על ביצועי האפליקציה שלך מכיוון שהשרתים צריכים לטפל במספר בקשות בו זמנית. חלודה מספקת תמיכה לדו קיום עם דגם הברגה קל משקל.
הרוטב של תכנות בו-זמנית ב-Rust הוא שמערכת הבעלות מאפשרת לך לכתוב קוד בטוח ללא צורך במנעולים ובפרימיטיבים אחרים של סנכרון.
חלודה מספקת כלי עבודה מודרניים
הספרייה הסטנדרטית של חלודה ו חבילות של צד שלישי במערכת האקולוגית של Rust לספק כלים מודרניים לאפקטיביים פיתוח שרתי אינטרנט .
Cargo, מנהל החבילות של Rust, מפשט את ניהול התלות ובונה תהליכים. בנוסף, ל-Rust יש תמיכת IDE מצוינת עם כלים כמו Rust Analyzer המספקים השלמת קוד חלקה, הדגשת שגיאות ותכונות אחרות.
סקירה כללית של ספריות Actix ו- Rocket
הספרייה הסטנדרטית של Rust כוללת את רוב כלי השירות שתצטרך לבניית שרתי אינטרנט. ספריות של צד שלישי כמו רָקֵטָה ו אקטיקס פשט את בניית יישומים בצד השרת עם Rust.
אקטיקס ו רָקֵטָה הן מסגרות אינטרנט פופולריות של Rust, אך הספריות שונות בעיצוב ובתכונות.
Rocket היא מסגרת אינטרנט ברמה גבוהה המתעדפת פרודוקטיביות וקלות שימוש. Rocket מספקת הרבה הפשטות וסוכר תחביר לבניית אפליקציות אינטרנט ב- Rust. Rocket פופולרי גם בזכות ההקלדה החזקה ועיצוב ה-API האינטואיטיבי שלה.
אתה יכול להוסיף את Rocket כתלות בפרויקט שלך charge.toml קובץ כדי להתחיל בבניית אפליקציות אינטרנט ב- Rust:
[dependencies]
rocket = "0.4.11"
מצד שני, Actix-web היא מסגרת ברמה נמוכה המתעדפת ביצועים ומדרגיות. Actix ממנפת מודל מקביליות מבוסס שחקנים ומספקת I/O לא חוסם שהופך את החבילה לאידיאלית לבניית יישומי אינטרנט בעלי ביצועים.
הוסף את Actix כתלות בפרויקט ב- תלות הקטע שלך charge.toml קוֹבֶץ:
כיצד לבטל תשלום venmo
[dependencies]
actix-web = "4.3.1"
בחירת ספרייה עבור הפרויקט שלך תהיה תלויה במפרט הפרויקט שלך, בתכונות הספרייה ובניסיון שלך עם Rust ו-HTTP.
בניית שרת אינטרנט פשוט ב- Rust
לאחר יצירת פרויקט Rust והוספת כל אחת ממסגרות Rocket או Actix לתלות של הפרויקט שלך ב- charge.toml קובץ, אתה מוכן להתחיל לבנות שרת אינטרנט ב- Rust.
בניית שרת אינטרנט פשוט עם Actix
אתה יכול להשתמש בסריאלייזר לבקשות בעת בניית שירותי אינטרנט ב- Rust.
Serde היא ספריית Rust פופולרית להסדרה וסיריאליזציה של נתונים בין סוגי Rust ותבניות נתונים כמו JSON, YAML ו-TOML. Serde מספקת מסגרת להגדרת המרת נתונים בין מבני נתונים של Rust וייצוגים מתאימים בפורמטים אחרים של נתונים.
הנה ההנחיה להוספת Serde כחבילת צד שלישי עבור הפרויקט שלך.
[dependencies]
serde = { version = "1.0.159" , features = ["derive"] }
לאחר שהוספת את Serde ו-Actix כתלות בפרויקט, תוכל להוליד שרת אינטרנט בסיסי עם Rust. הנה איך אתה יכול להגדיר פשוט שלום עולם! שרת אינטרנט שכותב מחרוזת ללקוח עם Actix:
ראשית, ייבא את המודולים והסוגים הדרושים מה- actix_web ו הליבה ארגזים:
use actix_web::{get, web, App, HttpResponse, HttpServer, Responder};
use serde::{Deserialize, Serialize};
אתה תשתמש הליבה לסידור הודעה ללקוח עם מבנה. Serde תמיר את ה-struct ל-JSON עבור הלקוח. להלן המבנה של ההודעה:
#[derive(Debug, Serialize, Deserialize)]
struct Message {
message: String,
}
כעת תוכל להגדיר את פונקציית המטפל עבור נקודת הקצה. בחלק העליון של פונקציית המטפל שלך, אתה יכול להוסיף עיצובים להתנהגויות מותאמות אישית:
#[get("/")]
async fn hello() -> impl Responder {
HttpResponse::Ok().json(Message {
message: "Hello, World!".to_owned(),
})
}
ה שלום פונקציית המטפל מטפלת בבקשות GET. הפונקציה מחזירה טיפוס שמיישם את תשובה תכונה מה אקטיקס חֲבִילָה.
ה json שיטת ה HttpResponse::Ok() סוג לוקח במופע struct ש הליבה מטפל מתחת למכסה המנוע ומחזיר את התגובה ללקוח.
לאחר הגדרת נקודת הקצה, תוכל להתחיל מופע שרת ולהעלות את נקודת הקצה במסלול.
#[actix_web::main]
async fn main() -> std::io::Result<()> {
HttpServer::new(|| App::new().service(hello))
.bind("127.0.0.1:8080")?
.run()
.await
}
ה HttpServer::חדש function הוא מופע שרת חדש. ה רָאשִׁי הפונקציה מתחילה, והשרת מעלה את שלום פונקציית מטפל עם מופע האפליקציה החדש. ה לִקְשׁוֹר השיטה קושרת את השרת לכתובת ה-URL שצוינה, ואת ה- לָרוּץ הפונקציה מפעילה את השרת.
כיצד להוריד פרקים ב- hulu
בניית שרת אינטרנט פשוט עם Rocket
Rocket הוא מינימליסטי, כך שתוכל להגדיר שרת אינטרנט פשוט ללא תלות כלשהי מלבד ה רָקֵטָה אַרְגָז.
הנה איך להגדיר שרת פשוט עם a שלום עולם! נקודת קצה באמצעות Rocket:
ראשית, ייבא את התלות הנדרשת עבור השרת שלך.
#![feature(proc_macro_hygiene, decl_macro)]
#[macro_use]
extern crate rocket;
// imports from the Rocket crate
use rocket::response::content;
use rocket::State;
ה #![feature(proc_macro_hygiene, decl_macro)] תכונה מאפשרת תכונות ניסיוניות של Rust עבור מסגרת Rocket. ה #[שימוש_מאקרו] תכונה מייבאת פקודות מאקרו מה- רָקֵטָה מודול.
להלן פונקציית מטפל המגישה HTML לפי בקשה:
#[get("/")]
fn hello_world() -> content::Html<&'static str> {
content::Html("<h1>Hello, world!</h1>")
}
ה שלום עולם הפונקציה מחזירה מחרוזת HTML סטטית עם ה- content::Html פוּנקצִיָה.
להלן הצהרת מבנה תצורה עבור השרת (מוסכמה של Rocket framework):
struct Config {
port: u16,
}
#[get("/port")]
fn port(config: State<Config>) -> String {
format!("Server running on port {}", config.port)
}
כאשר אתה מפעיל את השרת, אתה יכול להגיש בקשות ל- /נמל נקודת קצה עבור מצב הנמל.
לבסוף, תיצור מופע שרת עם ה לְהַצִית פוּנקצִיָה. הוסף את התצורות, העלה את המסלולים והפעל את השרת:
fn main() {
let config = Config { port: 8000 };
rocket::ignite()
.manage(config)
.mount("/", routes![hello_world, port])
.launch();
}
ה תצורה משתנה הוא מופע של ה Config struct. ה לְהַצִית הפונקציה מתחילה מופע שרת, ה לנהל השיטה מוסיפה את התצורה לשרת, ואת הר השיטה מעלה את פונקציית המטפל במסלולי הבסיס. סוף - סוף, ה לְהַשִׁיק השיטה מפעילה את השרת להאזנה ביציאה שצוינה.
אתה יכול לבנות יישומי אינטרנט רבי עוצמה בחלודה עם WASM
WebAssembly (WASM) הוא פורמט הוראות בינאריות המיועד לביצוע על דפדפנים והתקנים אחרים. WASM מספק פורמט קוד בתים ברמה נמוכה ששפות תכנות ברמה גבוהה יותר כמו Rust יכולות להשתמש בו כיעד הידור.
עם WASM, אתה יכול להרכיב את קוד ה-Rust שלך לפורמט בינארי שרוב הדפדפנים הפופולריים יכולים להפעיל. WASM פותח עולם של אפשרויות לבניית יישומי אינטרנט חזקים ב-Rust, כולל יישומי אינטרנט מלאים.