Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

การตั้งค่า

ผมเคยเห็นบั๊กที่เกิดจากการตั้งค่าคอนฟิกูเรชันผิดพลาดมามากเกินพอแล้วตลอดชีวิตการทำงาน ตั้งแต่ URL ฐานข้อมูลที่รันผ่านบนเครื่องตนเองแต่ใช้การไม่ได้บน Staging, ค่า JWT Secret ที่หลุดเข้าไปใน git commit, ไปจนถึง Environment Variable สำคัญที่ขาดหายไป แต่คุณกลับเพิ่งมารู้ตัวเอาสิบนาทีหลังจากการดีพลอยต์ เมื่อมีคำขอแรกวิ่งชนโค้ดในเส้นทางที่ต้องใช้ค่านั้น ปัญหาเหล่านี้ล้วนเป็นสิ่งที่หลีกเลี่ยงได้ และกลยุทธ์ที่เราจะใช้ในบทนี้จะช่วยป้องกันปัญหาดังกล่าวได้อย่างเบ็ดเสร็จ

แนวคิดหลักนั้นเรียบง่ายและตรงไปตรงมา: โหลดค่าคอนฟิกจากสภาพแวดล้อม ตรวจสอบความถูกต้องทันทีตั้งแต่ตอนเริ่มต้นระบบ (eager validation) และปกป้องข้อมูลที่เป็นความลับ (secrets) ในหน่วยความจำอย่างปลอดภัย มาดูกันว่าเราจะนำแนวคิดนี้ไปปฏิบัติจริงได้อย่างไร

struct การตั้งค่าแบบกำหนดชนิดชัดเจน

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

#![allow(unused)]
fn main() {
use secrecy::{SecretString, ExposeSecret};
use serde::Deserialize;

#[derive(Debug, Clone, Deserialize)]
pub struct Config {
    #[serde(default = "default_port")]
    pub port: u16,

    #[serde(default = "default_environment")]
    pub environment: Environment,

    pub database_url: SecretString,

    pub jwt_secret: SecretString,

    #[serde(default = "default_log_level")]
    pub log_level: String,

    #[serde(default)]
    pub cors_origins: Vec<String>,
}

#[derive(Debug, Deserialize, Clone, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum Environment {
    Development,
    Staging,
    Production,
}

fn default_port() -> u16 { 3000 }
fn default_environment() -> Environment { Environment::Development }
fn default_log_level() -> String { "info".to_string() }
}

มีข้อพิจารณาในการออกแบบที่สำคัญหลายประการในโค้ดชุดนี้ที่ควรกล่าวถึง:

โปรดสังเกตว่าฟิลด์ database_url และ jwt_secret จะถูกห่อหุ้มด้วย SecretString จากเครต secrecy แทนที่จะเป็น String ธรรมดา ซึ่งให้ประโยชน์หลัก 2 ประการ: ประการแรก ค่าของความลับจะถูกปกปิด (redact) โดยอัตโนมัติเมื่อมีการสั่งพิมพ์ struct ผ่านการจัดรูปแบบ Debug (คุณจะเห็นเป็น [REDACTED] แทนค่าความลับจริง) และประการที่สอง ข้อมูลในหน่วยความจำจะถูกเขียนทับด้วยศูนย์ (zeroize) ทันทีที่ค่านั้นหลุดพ้นขอบเขต (drop) ผมเคยเห็นความลับบน Production หลุดเข้าไปใน Log Files มาบ่อยจนไม่อยากจะนึกถึง การป้องกันในระดับนี้จึงมีคุณค่ามหาศาล

enum Environment ถูกสร้างขึ้นเป็นชนิดข้อมูลเฉพาะตัวแทนการใช้สตริงธรรมดา ทำให้คุณสามารถตรวจสอบเงื่อนไขผ่าน match ได้อย่างครอบคลุมทุกกรณี (exhaustively) โดยคอมไพเลอร์จะแจ้งเตือนทันทีหากคุณลืมจัดการกรณีใดกรณีหนึ่ง นอกจากนี้ยังช่วยดักจับข้อผิดพลาดจากการพิมพ์ผิด เช่น prodduction ได้ตั้งแต่ขั้นตอนการแปลงข้อมูล (parsing) แทนที่จะปล่อยให้ผ่านไปเงียบๆ

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

การโหลดจากตัวแปรสภาพแวดล้อม

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

#![allow(unused)]
fn main() {
impl Config {
    pub fn from_env() -> anyhow::Result<Self> {
        // In development, load from a .env file if present.
        // The .ok() is intentional: in production there is no .env file,
        // and that is fine.
        dotenvy::dotenv().ok();

        let config = config::Config::builder()
            .add_source(
                config::Environment::default()
                    .separator("__")
            )
            .build()
            .context("failed to build configuration")?;

        let parsed: Config = config
            .try_deserialize()
            .context("failed to deserialize configuration")?;

        parsed.validate()?;

        Ok(parsed)
    }

    fn validate(&self) -> anyhow::Result<()> {
        if self.jwt_secret.expose_secret().len() < 48 {
            anyhow::bail!(
                "JWT_SECRET must be at least 48 characters for adequate security"
            );
        }
        Ok(())
    }
}
}

การกำหนดตัวคั่น __ ช่วยให้คุณสามารถตั้งค่าฟิลด์ที่มีโครงสร้างซ้อนกัน (nested configuration) ได้โดยใช้เครื่องหมายขีดล่างสองตัว (double-underscore) ในชื่อตัวแปรสภาพแวดล้อม เช่น หากคุณมีฟิลด์ย่อย database.max_connections คุณสามารถกำหนดค่าผ่าน DATABASE__MAX_CONNECTIONS ได้อย่างง่ายดาย

สำหรับเมธอด validate จะทำหน้าที่ตรวจสอบเงื่อนไขเพิ่มเติมที่ไม่สามารถแสดงออกผ่านระบบชนิดข้อมูลเพียงอย่างเดียวได้ ในที่นี้คือการตรวจสอบว่า JWT secret มีความยาวเพียงพอที่จะต้านทานการโจมตีแบบ Brute-force หรือไม่ หากการตรวจสอบไม่ผ่าน แอปพลิเคชันจะหยุดการทำงานทันทีพร้อมแจ้งข้อความข้อผิดพลาดที่ชัดเจน ซึ่งดีกว่าการปล่อยให้ระบบเปิดทำงานได้อย่างราบรื่นแล้วไปพังเอาตอนที่มีผู้ใช้พยายามล็อกอินเข้าสู่ระบบ เพียงเพราะระบบเพิ่งตรวจพบว่า JWT secret มีความยาวแค่ 3 ตัวอักษร

ไฟล์ .env สำหรับการพัฒนา

ในระหว่างการพัฒนาบนเครื่อง Local การเก็บค่าคอนฟิกไว้ในไฟล์ .env จะช่วยเพิ่มความสะดวกอย่างมาก เพราะคุณไม่ต้องคอยสั่ง export ตัวแปรสภาพแวดล้อมด้วยตัวเองทุกครั้งที่เริ่มรันแอปพลิเคชัน:

DATABASE_URL=postgres://localhost:5432/myapp_dev
JWT_SECRET=this-is-a-local-dev-secret-that-is-long-enough-for-validation
LOG_LEVEL=debug
ENVIRONMENT=development

ไฟล์นี้จะต้องถูกระบุไว้ใน .gitignore เสมอ และห้าม commit เข้าสู่ระบบควบคุมเวอร์ชันโดยเด็ดขาด แม้ว่าจะมีเพียงความลับที่ใช้เฉพาะในสภาพแวดล้อมการพัฒนาก็ตาม จากประสบการณ์ของผม ความเคยชินในการ commit ไฟล์ .env มักจะลงเอยด้วยการที่มีใครสักคนเผลอ push ความลับของระบบ Production ขึ้นไปโดยไม่ตั้งใจในที่สุด ทางออกที่ดีคือการจัดเตรียมไฟล์ .env.example เพื่อเป็นคู่มืออ้างอิงว่าระบบต้องการตัวแปรใดบ้าง:

# Copy this file to .env and fill in the values
DATABASE_URL=postgres://localhost:5432/myapp_dev
JWT_SECRET=<generate a random string of at least 48 characters>
LOG_LEVEL=info
ENVIRONMENT=development

การใช้ความลับอย่างปลอดภัย

เครต secrecy เป็นไลบรารีขนาดเล็กแต่เปี่ยมด้วยประสิทธิภาพ เมื่อคุณห่อหุ้มค่าใดๆ ไว้ใน SecretString คุณจะได้รับการปกป้องถึง 3 ชั้นด้วยกัน:

  1. การปกปิดค่าอัตโนมัติใน Debug (Redaction) ไม่ว่าโค้ดส่วนใดจะสั่งพิมพ์ struct คอนฟิกออกมา ไม่ว่าจะตั้งใจหรือเผลอทำโดยไม่รู้ตัว สิ่งที่ปรากฏจะเป็นข้อความ [REDACTED] เสมอแทนที่จะเป็นความลับจริง ประเด็นนี้มีความสำคัญอย่างยิ่ง เพราะระบบ Structured Logging หรือ Error Reporting อาจเผลอ serialize struct คอนฟิกทั้งก้อนออกมาได้หากไม่ได้ระวัง

  2. การล้างหน่วยความจำเป็นศูนย์อย่างปลอดภัย (Secure Zeroization) เมื่อตัวแปร SecretString หลุดพ้นขอบเขตการทำงาน (drop) พื้นที่หน่วยความจำของมันจะถูกเขียนทับด้วยเลขศูนย์ทั้งหมดทันทีก่อนที่จะคืนหน่วยความจำกลับสู่ระบบ ซึ่งช่วยลดความเสี่ยงที่ข้อมูลความลับจะค้างอยู่ใน Memory Dump ลงได้อย่างมาก

  3. การเปิดเผยข้อมูลอย่างตั้งใจและชัดเจน (Explicit Exposure) ในการนำค่าความลับออกมาใช้งานจริง คุณจะต้องเรียกใช้เมธอด .expose_secret() ซึ่งจะส่งคืนค่าการอ้างอิงไปยังสตริงภายในออกมาอย่างชัดเจน ทำให้ทุกจุดที่มีการเข้าถึงความลับสังเกตเห็นได้ง่าย และสามารถค้นหาด้วยคำสั่ง grep ได้อย่างสะดวกรวดเร็วในระหว่างการรีวิวโค้ด

#![allow(unused)]
fn main() {
// When you need to use the secret, you explicitly expose it.
// Keep the exposed value's lifetime as short as possible.
let decoding_key = DecodingKey::from_secret(
    config.jwt_secret.expose_secret().as_bytes()
);
}

กฎเหล็กที่ควรจำไว้: เรียกใช้ expose_secret() เฉพาะ ณ จุดที่จะใช้งานจริงเท่านั้น อย่าเรียกใช้ล่วงหน้า อย่าเก็บค่าที่เปิดเผยแล้วไว้ในตัวแปรที่มีอายุการใช้งานยาวนานเกินความจำเป็น และห้ามพิมพ์ค่านั้นลงในไฟล์ Log โดยเด็ดขาด

การดีพลอยต์ใน production

เมื่อขึ้นสู่ระบบ Production ค่าคอนฟิกูเรชันทั้งหมดควรถูกส่งเข้ามาผ่านระบบจัดการความลับ (Secrets Management) ของแพลตฟอร์มการดีพลอยต์โดยตรง ไม่ใช่การอ่านจากไฟล์ในเครื่อง ซึ่งอาจอยู่ในรูปแบบต่างๆ เช่น:

  • Kubernetes Secrets ที่ถูก mount เข้ามาเป็นตัวแปรสภาพแวดล้อม
  • Environment block ของ Docker ในไฟล์ Compose หรือคอนฟิกของ Container Orchestrator
  • บริการจัดการความลับของผู้ให้บริการคลาวด์ เช่น AWS Secrets Manager, GCP Secret Manager ฯลฯ

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

ล้มเหลวเร็ว (Fail fast)

หากมีกฎเหล็กเพียงข้อเดียวที่ผมอยากจะเน้นย้ำกับทุกทีมพัฒนา กฎข้อนั้นคือ: จงสั่งให้ระบบล้มเหลวทันทีและส่งเสียงดังๆ (Fail fast and loud) ตั้งแต่ตอนเริ่มระบบ หากพบว่าการตั้งค่าที่จำเป็นขาดหายไปหรือไม่ถูกต้อง การที่ระบบพังตั้งแต่ตอนเริ่มต้นพร้อมแจ้งข้อความข้อผิดพลาดที่ชัดเจนและตรงไปตรงมา (เช่น “JWT_SECRET environment variable is not set”) นั้นย่อมดีกว่าการปล่อยให้ระบบเปิดทำงานได้ แล้วไปพังเอาสิบนาทีหลังจากนั้นเมื่อมีคำขอยืนยันตัวตนเข้ามาครั้งแรก แล้วเพิ่งมารู้ตัวว่าไม่มีค่า JWT secret

นี่คือเหตุผลที่ฟังก์ชัน Config::from_env() ของเราทำการ Deserialize และตรวจสอบความถูกต้องอย่างเข้มงวดตั้งแต่ตอนเริ่มระบบ (eager validation) ทำให้มั่นใจได้ว่าเมื่อใดก็ตามที่แอปพลิเคชันเริ่มเปิดรับคำขอ การตั้งค่าทั้งหมดจะมีอยู่ครบถ้วน ถูกต้องตามชนิดข้อมูล และผ่านการตรวจสอบความถูกต้องแล้วทั้งหมด จึงหมดกังวลเรื่องบั๊กการตั้งค่าแอบแฝงที่จะโผล่มาสร้างความประหลาดใจตอนตีสองในคืนวันเสาร์ เมื่อรากฐานด้านการตั้งค่าของเรามั่นคงแล้ว ในบทถัดไปเราจะไปดูกันว่าเราจะจัดการกับข้อผิดพลาดในส่วนอื่นๆ ของแอปพลิเคชันอย่างไร