Learn Rust Coding · บทเรียน

การยืนยันตัวตนและการอนุญาตสิทธิ์

นำกลไกยืนยันตัวตนผู้ใช้ที่ปลอดภัย (เช่น JWT) และการอนุญาตสิทธิ์มาใช้เพื่อปกป้องจุดเชื่อมต่อบริการเว็บของคุณ

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

รักษาความปลอดภัยให้บริการเว็บของคุณ

ยินดีต้อนรับค่ะ/ครับ! ในบทเรียนนี้ เราจะเจาะลึกเรื่อง การยืนยันตัวตน และ การอนุญาตสิทธิ์ ซึ่งเป็นแนวคิดสำคัญสำหรับการสร้างบริการเว็บที่ปลอดภัยด้วย Rust

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

การยืนยันตัวตนกับการอนุญาตสิทธิ์

คำสองคำนี้ฟังดูคล้ายกัน แต่มีความหมายต่างกัน:

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

เราจะนำทั้งสองแนวคิดมาใช้เพื่อรักษาความปลอดภัยให้บริการเว็บ Rust ของเรา

เหตุใดจึงต้องรักษาความปลอดภัยให้ API

การปกป้องจุดปลายทาง API มีความสำคัญด้วยเหตุผลหลายประการ:

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

ชั้นความปลอดภัยที่รัดกุมช่วยสร้างความไว้วางใจและปกป้องแอปพลิเคชันของคุณ

โทเค็นเว็บ JSON (JWT)

วิธีที่ได้รับความนิยมสำหรับการยืนยันตัวตนในบริการเว็บสมัยใหม่คือการใช้ โทเค็นเว็บ JSON (JWT) ซึ่งอ่านออกเสียงว่า "จอต"

JWT เป็นวิธีที่มีขนาดกะทัดรัดและปลอดภัยสำหรับ URL ในการแทน Claims ที่ส่งต่อระหว่างสองฝ่าย โดยมักใช้สำหรับการยืนยันตัวตนแบบไม่เก็บสถานะ

นั่นหมายความว่าเซิร์ฟเวอร์ไม่จำเป็นต้องเก็บข้อมูลเซสชันของผู้ใช้แต่ละคน

ภายใน JWT: ส่วนหัว ข้อมูลบรรจุ และลายเซ็น

JWT ประกอบด้วยสามส่วน คั่นด้วยจุด:

ส่วนหัว: มีข้อมูลเมตาเกี่ยวกับ token เช่น ประเภทของ token (JWT) และอัลกอริทึมการลงนาม เช่น HS256
ข้อมูลบรรจุ: มี "Claims" หรือข้อความที่ระบุเกี่ยวกับเอนทิตี (โดยทั่วไปคือผู้ใช้) และข้อมูลเพิ่มเติม
ลายเซ็น: ใช้ตรวจสอบว่า token ไม่ได้ถูกแก้ไข โดยสร้างขึ้นจากการเข้ารหัสส่วนหัวและข้อมูลบรรจุด้วยคีย์ลับ

การสร้างและตรวจสอบ JWT ใน Rust

มาดูวิธีสร้างและตรวจสอบ JWT โดยใช้กล่อง jsonwebtoken ใน Rust กัน โปรดจำไว้ว่าคุณต้องเพิ่ม jsonwebtoken, serde (พร้อมคุณลักษณะ "derive") และ chrono (พร้อมคุณลักษณะ "serde") ลงใน Cargo.toml

ตัวอย่างนี้จะสร้าง token แล้วตรวจสอบ token นั้นทันที

use jsonwebtoken::{encode, decode, Header, EncodingKey, DecodingKey, Validation};
use serde::{Deserialize, Serialize};
use chrono::{Utc, Duration};

#[derive(Debug, Serialize, Deserialize)]
struct Claims {
    sub: String, // Subject (user ID)
    company: String,
    exp: usize,  // Expiration time
}

fn main() {
    // --- Setup (requires crates: jsonwebtoken, serde, chrono) ---
    let secret_key = "my_super_secret_key";

    // --- 1. Generate a JWT ---
    let my_claims = Claims {
        sub: "user123".to_string(),
        company: "CoddyKit".to_string(),
        exp: (Utc::now() + Duration::minutes(10)).timestamp() as usize,
    };
    let token = encode(
        &Header::default(),
        &my_claims,
        &EncodingKey::from_secret(secret_key.as_ref()),
    ).expect("Failed to encode token");
    println!("Generated JWT:\n{}", token);
    println!("\n--- Verifying the Token ---");

    // --- 2. Verify the JWT ---
    let validation = Validation::default();
    let decoded_result = decode::<Claims>(
        &token,
        &DecodingKey::from_secret(secret_key.as_ref()),
        &validation,
    );

    match decoded_result {
        Ok(token_data) => {
            println!("Token valid!");
            println!("Subject: {}", token_data.claims.sub);
            println!("Company: {}", token_data.claims.company);
        },
        Err(err) => println!("Token invalid: {:?}", err),
    }
}

การอนุญาตสิทธิ์: การกำหนดการเข้าถึง

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

รูปแบบการอนุญาตสิทธิ์ที่พบบ่อย ได้แก่:

การควบคุมการเข้าถึงตามบทบาท (RBAC): กำหนดบทบาทให้ผู้ใช้ เช่น "ผู้ดูแลระบบ", "ผู้แก้ไข" และ "ผู้ดู" แล้วกำหนดสิทธิ์เฉพาะให้แต่ละบทบาท
การควบคุมการเข้าถึงตามคุณลักษณะ (ABAC): อนุญาตการเข้าถึงโดยพิจารณาจากคุณลักษณะของผู้ใช้ ทรัพยากร หรือสภาพแวดล้อม

แนวคิดมิดเดิลแวร์สำหรับการอนุญาตสิทธิ์

ในบริการเว็บ การอนุญาตสิทธิ์มักจัดการด้วย มิดเดิลแวร์ ซึ่งเป็นโค้ดที่ทำงานก่อนตัวจัดการเส้นทางหลักของคุณ

มิดเดิลแวร์จะ:

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

วิธีนี้ช่วยให้ตัวจัดการเส้นทางสะอาดและมุ่งเน้นที่ตรรกะทางธุรกิจ

ทดสอบความรู้ของคุณ

มาทบทวนความเข้าใจของคุณเกี่ยวกับการยืนยันตัวตนและการอนุญาตสิทธิ์กันอย่างรวดเร็ว

สรุป: การรักษาความปลอดภัยบริการเว็บ

ทำได้ดีมาก! ในบทเรียนนี้ เราได้ครอบคลุมพื้นฐานสำคัญของการรักษาความปลอดภัยให้บริการเว็บ Rust:

ความแตกต่างระหว่าง การยืนยันตัวตน (คุณคือใคร) กับ การอนุญาตสิทธิ์ (คุณทำอะไรได้บ้าง)
ความสำคัญของการปกป้องจุดปลายทาง API
การทำงานของ โทเค็นเว็บ JSON (JWT) สำหรับการยืนยันตัวตนแบบไม่เก็บสถานะ รวมถึงโครงสร้างของโทเค็น
ตัวอย่างการสร้างและตรวจสอบ JWT ใน Rust
แนวคิดเรื่อง การควบคุมการเข้าถึงตามบทบาท และวิธีที่ มิดเดิลแวร์ นำการตรวจสอบการอนุญาตสิทธิ์ไปใช้

ตอนนี้คุณพร้อมสร้างแอปพลิเคชัน Rust ที่ปลอดภัยและแข็งแกร่งยิ่งขึ้นแล้ว!

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

บทเรียน “การยืนยันตัวตนและการอนุญาตสิทธิ์” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การยืนยันตัวตนและการอนุญาตสิทธิ์”

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

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

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

บทเรียน “การยืนยันตัวตนและการอนุญาตสิทธิ์” ใช้เวลานานแค่ไหน

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

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

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

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

REST APIs ด้วย Actix-web/Rocket
การเชื่อมต่อฐานข้อมูล (SQLx/Diesel)
การยืนยันตัวตนและการอนุญาตสิทธิ์

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