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 כתלות בפרויקט שלך Cargo.toml קובץ כדי להתחיל בבניית אפליקציות אינטרנט ב- Rust:

[תלות]
רָקֵטָה = "0.4.11"

מצד שני, Actix-web היא מסגרת ברמה נמוכה המתעדפת ביצועים ומדרגיות. Actix ממנפת מודל מקביליות מבוסס שחקנים ומספקת I/O לא חוסם שהופך את החבילה לאידיאלית לבניית יישומי אינטרנט בעלי ביצועים.

הוסף את Actix כתלות בפרויקט ב- תלות הקטע שלך Cargo.toml קוֹבֶץ:

[תלות]
actix-web = "4.3.1"

בחירת ספרייה עבור הפרויקט שלך תהיה תלויה במפרט הפרויקט שלך, בתכונות הספרייה ובניסיון שלך עם Rust ו-HTTP.

בניית שרת אינטרנט פשוט ב- Rust

לאחר יצירת פרויקט Rust והוספת כל אחת ממסגרות Rocket או Actix לתלות של הפרויקט שלך ב- Cargo.toml קובץ, אתה מוכן להתחיל לבנות שרת אינטרנט ב- Rust.

בניית שרת אינטרנט פשוט עם Actix

אתה יכול להשתמש בסריאלייזר לבקשות בעת בניית שירותי אינטרנט ב- Rust.

Serde היא ספריית Rust פופולרית להסדרה וסיריאליזציה של נתונים בין סוגי Rust ותבניות נתונים כמו JSON, YAML ו-TOML. Serde מספקת מסגרת להגדרת המרת נתונים בין מבני נתונים של Rust וייצוגים מתאימים בפורמטים אחרים של נתונים.

הנה ההנחיה להוספת Serde כחבילת צד שלישי עבור הפרויקט שלך.

[תלות]
serde = { גרסה = "1.0.159", תכונות = ["לְהָפִיק"] }

לאחר שהוספת את Serde ו-Actix כתלות בפרויקט, תוכל להוליד שרת אינטרנט בסיסי עם Rust. הנה איך אתה יכול להגדיר פשוט שלום עולם! שרת אינטרנט שכותב מחרוזת ללקוח עם Actix:

ראשית, ייבא את המודולים והסוגים הדרושים מה- actix_web ו serde ארגזים:

להשתמש actix_web::{get, web, App, HttpResponse, HttpServer, Responder};
להשתמש serde::{Deserialize, Serialize};

אתה תשתמש serde לסידור הודעה ללקוח עם מבנה. Serde תמיר את ה-struct ל-JSON עבור הלקוח. להלן המבנה של ההודעה:

#[נגזר (Debug, Serialize, Deserialize)]
structהוֹדָעָה {
 הוֹדָעָה: חוּט,
}

כעת תוכל להגדיר את פונקציית המטפל עבור נקודת הקצה. בחלק העליון של פונקציית המטפל שלך, אתה יכול להוסיף עיצובים להתנהגויות מותאמות אישית:

#[לקבל("/")]
אסינכרוןfnשלום() -> impl מגיב {
 HttpResponse::בסדר().json (הודעה {
 הוֹדָעָה: "שלום עולם!".to_owned(),
 })
}

ה שלום פונקציית המטפל מטפלת בבקשות GET. הפונקציה מחזירה טיפוס שמיישם את מגיב תכונה מה אקטיקס חֲבִילָה.

ה json שיטת ה HttpResponse:: אוקי() סוג לוקח במופע struct ש סרדה מטפל מתחת למכסה המנוע ומחזיר את התגובה ללקוח.

לאחר הגדרת נקודת הקצה, תוכל להתחיל מופע שרת ולהעלות את נקודת הקצה במסלול.

#[actix_web:: main]
אסינכרוןfnרָאשִׁי() -> std:: io::תוֹצָאָה {
 HttpServer:: new(|| App:: new().service (שלום))
 .לִקְשׁוֹר("127.0.0.1:8080")?
 .לָרוּץ()
 .לְהַמתִין
}

ה HttpServer:: חדש function הוא מופע שרת חדש. ה רָאשִׁי הפונקציה מתחילה, והשרת מעלה את שלום פונקציית מטפל עם מופע האפליקציה החדש. ה לִקְשׁוֹר השיטה קושרת את השרת לכתובת ה-URL שצוינה, ואת ה- לָרוּץ הפונקציה מפעילה את השרת.

בניית שרת אינטרנט פשוט עם Rocket

Rocket הוא מינימליסטי, כך שתוכל להגדיר שרת אינטרנט פשוט ללא תלות כלשהי מלבד ה רָקֵטָה אַרְגָז.

הנה איך להגדיר שרת פשוט עם a שלום עולם! נקודת קצה באמצעות Rocket:

ראשית, ייבא את התלות הנדרשת עבור השרת שלך.

#![תכונה (proc_macro_hygiene, decl_macro)]
#[שימוש_מאקרו]
חיצוניאַרְגָז רָקֵטָה;
// יבוא מארגית Rocket
להשתמש rocket:: תגובה:: תוכן;
להשתמש רקטה:: מדינה;

ה #![תכונה (proc_macro_hygiene, decl_macro)] תכונה מאפשרת תכונות ניסיוניות של Rust עבור מסגרת Rocket. ה #[שימוש_מאקרו] תכונה מייבאת פקודות מאקרו מה- רָקֵטָה מודול.

להלן פונקציית מטפל המגישה HTML לפי בקשה:

#[לקבל("/")]
fnשלום עולם() -> content:: Html'סטָטִיstr> {
 content:: HTML("
שלום עולם!
")
}

ה שלום עולם הפונקציה מחזירה מחרוזת HTML סטטית עם ה- תוכן:: HTML פוּנקצִיָה.

להלן הצהרת מבנה תצורה עבור השרת (מוסכמה של Rocket framework):

structConfig {
 נמל: u16,
}
#[לקבל("/נמל")]
fnנמל(תצורה: מדינה) -> חוּט {
פוּרמָט!("שרת פועל ביציאה {}", config.port)
}

כאשר אתה מפעיל את השרת, אתה יכול להגיש בקשות ל- /port נקודת קצה עבור מצב הנמל.

לבסוף, תיצור מופע שרת עם ה לְהַצִית פוּנקצִיָה. הוסף את התצורות, העלה את המסלולים והפעל את השרת:

fnרָאשִׁי() {
לתת config = Config { port: 8000 };
 rocket:: ignite()
 .manage (config)
 .הר("/", מסלולים![hello_world, port])
 .לְהַשִׁיק();
}

ה תצורה משתנה הוא מופע של ה Config struct. ה לְהַצִית הפונקציה מתחילה מופע שרת, ה לנהל השיטה מוסיפה את התצורה לשרת, ואת הר השיטה מעלה את פונקציית המטפל במסלולי הבסיס. סוף - סוף, ה לְהַשִׁיק השיטה מפעילה את השרת להאזנה ביציאה שצוינה.

אתה יכול לבנות יישומי אינטרנט רבי עוצמה בחלודה עם WASM

WebAssembly (WASM) הוא פורמט הוראות בינאריות המיועד לביצוע על דפדפנים והתקנים אחרים. WASM מספק פורמט קוד בתים ברמה נמוכה ששפות תכנות ברמה גבוהה יותר כמו Rust יכולות להשתמש בו כיעד הידור.

עם WASM, אתה יכול להרכיב את קוד ה-Rust שלך לפורמט בינארי שרוב הדפדפנים הפופולריים יכולים להפעיל. WASM פותח עולם של אפשרויות לבניית יישומי אינטרנט חזקים ב-Rust, כולל יישומי אינטרנט מלאים.