Learn Rust Coding · บทเรียน

การตั้งค่าโครงการ

จัดโครงสร้าง API

การตั้งค่าโครงการ เป็นบทเรียน Learn Rust Coding ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn Rust Coding และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

การสร้าง REST API ด้วย Rust

ในหลักสูตรนี้ คุณจะสร้างREST API ขนาดเล็กด้วย Rust เราใช้เฟรมเวิร์กเว็บAxum ซึ่งสร้างอยู่บน Tokio (ระบบรันไทม์แบบอะซิงโครนัส) และ Tower (มิดเดิลแวร์) เฟรมเวิร์กนี้ใช้งานสะดวก ปลอดภัยด้านชนิดข้อมูล และใช้งานอย่างแพร่หลายในระบบจริง

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

การสร้างโครงการ

เริ่มต้นด้วย Cargo โครงการแบบไบนารีจะมีจุดเริ่มต้น src/main.rs:

cargo new rest_api สร้างโฟลเดอร์
cd rest_api เข้าไปยังโฟลเดอร์นั้น
cargo run สร้างและเรียกใช้โครงการ

คำสั่งเหล่านี้เป็นคำสั่งของเชลล์และ cargo ไม่ใช่ส่วนย่อยของ Rust ที่เรียกใช้ได้โดยตรง

// terminal
// cargo new rest_api
// cd rest_api
// cargo run

การเพิ่มส่วนพึ่งพา

API ของ Axum ต้องมีเครตบางรายการใน Cargo.toml:

axum สำหรับการกำหนดเส้นทางและตัวจัดการ
tokio สำหรับระบบรันไทม์แบบอะซิงโครนัส
serde สำหรับการทำอนุกรมเป็น JSON

// Cargo.toml
// [dependencies]
// axum = "0.7"
// tokio = { version = "1", features = ["full"] }
// serde = { version = "1", features = ["derive"] }
// serde_json = "1"

ระบบรันไทม์แบบอะซิงโครนัส

เว็บเซิร์ฟเวอร์จัดการการเชื่อมต่อจำนวนมากพร้อมกัน ดังนั้น Axum จึงเป็นแบบอะซิงโครนัส แอตทริบิวต์ #[tokio::main] เปลี่ยน main แบบอะซิงโครนัสให้เป็นจุดเริ่มต้นจริงโดยเริ่มระบบรันไทม์ของ Tokio ตัวจัดการทุกตัวสามารถใช้ .await สำหรับการรับส่งข้อมูลที่ไม่บล็อกได้

// src/main.rs
use tokio;

#[tokio::main]
async fn main() {
    println!("runtime started");
}

เซิร์ฟเวอร์แบบพื้นฐาน

แอป Axum ที่เล็กที่สุดจะสร้าง Router ผูกตัวรับ TCP และให้บริการ เส้นทางเดียวจะจับคู่ GET / กับตัวจัดการที่ส่งคืนสตริง ตัวจัดการเป็นเพียงฟังก์ชันแบบอะซิงโครนัสที่ส่งคืนสิ่งที่ทำตาม IntoResponse ได้

use axum::{routing::get, Router};

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(root));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

async fn root() -> &'static str {
    "Hello, API!"
}

การกำหนดเส้นทางทำงานอย่างไร

Router จับคู่เส้นทางและเมธอด HTTP กับตัวจัดการ เรียก .route(path, method(handler)) ต่อกันเพื่อลงทะเบียนจุดปลายทาง ตัวช่วยของเมธอด เช่น get, post, put และ delete มาจาก axum::routing คุณสามารถรวมหลายเมธอดไว้บนเส้นทางเดียวกันได้

use axum::{routing::{get, post}, Router};

async fn list() -> &'static str { "list" }
async fn create() -> &'static str { "created" }

fn build_router() -> Router {
    Router::new()
        .route("/items", get(list).post(create))
        .route("/health", get(|| async { "ok" }))
}

โครงสร้างโมดูลที่แนะนำ

เมื่อ API เติบโตขึ้น ให้แยกโค้ดเป็นโมดูลแทนการรวมทุกอย่างไว้ใน main.rs ขนาดใหญ่ไฟล์เดียว:

main.rs — การเริ่มต้นและการเชื่อมต่อเซิร์ฟเวอร์
routes.rs — นิยามตัวกำหนดเส้นทาง
handlers.rs — ตัวจัดการคำขอ
models.rs — โครงสร้างข้อมูล

การแยกเช่นนี้ทำให้แต่ละไฟล์มีหน้าที่ชัดเจนและทดสอบได้

// src/main.rs
mod routes;
mod handlers;
mod models;

#[tokio::main]
async fn main() {
    let app = routes::build();
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

สถานะแอปพลิเคชันที่ใช้ร่วมกัน

API ส่วนใหญ่ต้องใช้สถานะร่วมกัน เช่น กลุ่มการเชื่อมต่อฐานข้อมูลหรือที่เก็บข้อมูลในหน่วยความจำ Axum เก็บสถานะนี้ด้วย .with_state(state) บนตัวกำหนดเส้นทาง ตัวจัดการรับสถานะผ่านตัวดึงข้อมูล State สถานะต้องเป็น Clone และควรห่อข้อมูลที่เปลี่ยนแปลงได้ด้วย Arc และตัวล็อก

use axum::{routing::get, Router, extract::State};
use std::sync::{Arc, Mutex};

type Db = Arc<Mutex<Vec<String>>>;

async fn count(State(db): State<Db>) -> String {
    let n = db.lock().unwrap().len();
    format!("{} items", n)
}

fn build(db: Db) -> Router {
    Router::new().route("/count", get(count)).with_state(db)
}

การส่งคืน JSON

หากต้องการส่ง JSON ให้ห่อค่าที่ทำอนุกรมได้ด้วย axum::Json เมื่อใช้ serde สร้าง Serialize ให้กับโครงสร้างของคุณ Axum จะกำหนดชนิดเนื้อหาและเนื้อหาการตอบกลับที่ถูกต้องให้อัตโนมัติ

use axum::Json;
use serde::Serialize;

#[derive(Serialize)]
struct Status {
    service: String,
    healthy: bool,
}

async fn health() -> Json<Status> {
    Json(Status { service: "api".into(), healthy: true })
}

การกำหนดค่าและพอร์ต

การกำหนดพอร์ตตายตัวเหมาะสำหรับการสาธิต แต่บริการจริงควรอ่านการกำหนดค่าจากสภาพแวดล้อม ใช้ std::env::var พร้อมค่าเริ่มต้น วิธีนี้ทำให้คุณเปลี่ยนที่อยู่สำหรับผูกได้โดยไม่ต้องคอมไพล์ใหม่ และทำงานร่วมกับคอนเทนเนอร์ได้ดี

use std::env;

async fn main_inner() {
    let port = env::var("PORT").unwrap_or_else(|_| "3000".to_string());
    let addr = format!("0.0.0.0:{}", port);
    println!("binding to {}", addr);
    // bind and serve with addr ...
}

รวมการตั้งค่าเข้าด้วยกัน

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

use axum::{routing::get, Router};
use std::sync::{Arc, Mutex};

#[tokio::main]
async fn main() {
    let db = Arc::new(Mutex::new(Vec::<String>::new()));
    let app = Router::new()
        .route("/health", get(|| async { "ok" }))
        .with_state(db);
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจเกี่ยวกับการตั้งค่าโครงการ

สรุปทบทวน

คุณได้ตั้งค่าโครงการ REST API ด้วย Rust:

ใช้ cargo new และเพิ่ม axum, tokio และ serde
#[tokio::main] จัดเตรียมระบบรันไทม์แบบอะซิงโครนัส
Router จับคู่เส้นทางและเมธอดกับตัวจัดการแบบอะซิงโครนัส
ใช้ข้อมูลร่วมกันด้วย .with_state และตัวดึงข้อมูล State
แยกโค้ดเป็นโมดูลเส้นทาง ตัวจัดการ และแบบจำลอง พร้อมอ่านพอร์ตจากสภาพแวดล้อม

คำถามที่พบบ่อย

บทเรียน “การตั้งค่าโครงการ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การตั้งค่าโครงการ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn Rust Coding ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การตั้งค่าโครงการ”

จัดโครงสร้าง API คุณปฏิบัติ Learn Rust Coding ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn Rust Coding หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn Rust Coding บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “การตั้งค่าโครงการ” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Learn Rust Coding นี้ได้ไหม

ได้ บทเรียน Learn Rust Coding ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Learn Rust Coding