Python FastAPI Shift Left Security — คู่มือฉบับสมบูรณ์ 2026 | SiamCafe Blog

บทนำ: ความสำคัญของ Shift Left Security ในยุค API-Driven Development

ในโลกของการพัฒนาแอปพลิเคชันสมัยใหม่ที่ขับเคลื่อนด้วย API โดยเฉพาะอย่างยิ่งกับเฟรมเวิร์กอย่าง FastAPI ที่ได้รับความนิยมอย่างสูงในปี 2026 การรักษาความปลอดภัยไม่ใช่สิ่งที่ควรถูกมองข้ามหรือเพิ่มเข้ามาเป็นขั้นตอนสุดท้ายอีกต่อไป แนวคิด “Shift Left Security” หรือการเลื่อนการรักษาความปลอดภัยไปทางซ้ายของกระบวนการพัฒนา (DevOps Pipeline) กลายเป็นมาตรฐานที่หลีกเลี่ยงไม่ได้

FastAPI ซึ่งเป็นเฟรมเวิร์ก Python ที่มีความเร็วสูงและรองรับการตรวจสอบข้อมูลอัตโนมัติผ่าน Pydantic นั้นมีความได้เปรียบโดยธรรมชาติในการนำ Shift Left Security ไปใช้ เนื่องจากคุณสมบัติการประกาศสคีมา (schema declaration) และการตรวจสอบความถูกต้อง (validation) ที่ทำงานตั้งแต่ขั้นตอนการรับอินพุต

บทความนี้จะพาคุณสำรวจแนวทางการนำ Shift Left Security มาใช้กับ FastAPI อย่างครบถ้วน ตั้งแต่การตรวจสอบโค้ดเชิงสแตติก (Static Code Analysis) ไปจนถึงการทดสอบความปลอดภัยแบบอัตโนมัติใน CI/CD Pipeline โดยใช้เครื่องมือที่ทันสมัยที่สุดในปี 2026

1. ทำความเข้าใจหลักการ Shift Left Security สำหรับ FastAPI

Shift Left Security ไม่ใช่แค่เทรนด์ แต่เป็นความจำเป็นทางธุรกิจ การศึกษาโดย SANS Institute ในปี 2025 พบว่าการแก้ไขช่องโหว่ในขั้นตอนการพัฒนา (Development) มีค่าใช้จ่ายน้อยกว่าการแก้ไขในขั้นตอนการผลิต (Production) ถึง 30-60 เท่า

1.1 หลักการสำคัญ 3 ประการของ Shift Left Security

• การตรวจสอบเชิงป้องกัน (Preventive Checks): ตรวจจับช่องโหว่ตั้งแต่การเขียนโค้ด เช่น SQL Injection, XSS, Path Traversal
• การตรวจสอบแบบอัตโนมัติ (Automated Security Testing): ผสาน SAST, DAST, SCA เข้ากับ CI/CD Pipeline
• การสร้างวัฒนธรรมความปลอดภัย (Security Culture): นักพัฒนาทุกคนต้องมีความรู้พื้นฐานด้านความปลอดภัย

1.2 ทำไม FastAPI ถึงเหมาะกับ Shift Left Security

2. การตรวจสอบโค้ดเชิงสแตติก (Static Application Security Testing – SAST) สำหรับ FastAPI

SAST เป็นเครื่องมือที่ช่วยตรวจจับช่องโหว่ในซอร์สโค้ดโดยไม่ต้องรันโปรแกรม สำหรับ FastAPI เรามีเครื่องมือเฉพาะที่ทำงานร่วมกับเฟรมเวิร์กได้ดี

2.1 เครื่องมือ SAST ที่แนะนำสำหรับ FastAPI

• Bandit: เครื่องมือ SAST มาตรฐานสำหรับ Python ตรวจจับช่องโหว่ทั่วไป
• Semgrep: รองรับการเขียนกฎเฉพาะสำหรับ FastAPI เช่น การตรวจสอบ JWT, OAuth2
• Bearer CLI: เครื่องมือที่ออกแบบมาโดยเฉพาะสำหรับ API Security

2.2 การตั้งค่า Semgrep สำหรับ FastAPI

ตัวอย่างการสร้างกฎ Semgrep เพื่อตรวจจับการใช้ HTTPException โดยไม่มีการจัดการข้อผิดพลาดที่เหมาะสม:

# fastapi-security-rules.yaml
rules:
  - id: fastapi-unhandled-http-exception
    pattern: |
      from fastapi import HTTPException
      ...
      raise HTTPException(...)
    message: "พบการ raise HTTPException โดยไม่มีการกำหนด status_code ที่ชัดเจน"
    languages: [python]
    severity: WARNING

  - id: fastapi-insecure-directory-traversal
    pattern: |
      @app.get("/files/{file_path}")
      async def read_file(file_path: str):
          return FileResponse(f"./files/{file_path}")
    message: "มีความเสี่ยง Path Traversal ควรใช้ PathValidator ก่อน"
    languages: [python]
    severity: ERROR

2.3 การผสาน SAST เข้ากับ CI/CD Pipeline

ตัวอย่างการตั้งค่า GitHub Actions สำหรับรัน Semgrep และ Bandit ทุกครั้งที่มี Pull Request:

# .github/workflows/security-sast.yml
name: FastAPI Security SAST Scan

on:
  pull_request:
    branches: [main, develop]

jobs:
  sast-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'
      
      - name: Install Dependencies
        run: |
          pip install bandit semgrep
          pip install -r requirements.txt
      
      - name: Run Bandit
        run: bandit -r . -f json -o bandit-report.json
      
      - name: Run Semgrep
        run: semgrep --config=fastapi-security-rules.yaml --error .
      
      - name: Upload Report
        uses: actions/upload-artifact@v4
        with:
          name: sast-reports
          path: bandit-report.json

3. การตรวจสอบ Dependency และ Software Composition Analysis (SCA)

การพึ่งพาไลบรารีภายนอก (dependencies) เป็นหนึ่งในแหล่งที่มาของช่องโหว่ที่ใหญ่ที่สุด การใช้ SCA จะช่วยตรวจสอบว่ามีไลบรารีใดที่มีช่องโหว่ที่รู้จัก (Known Vulnerabilities) หรือไม่

3.1 เครื่องมือ SCA สำหรับ Python/FastAPI

3.2 การตั้งค่า Safety CLI สำหรับ FastAPI Project

# ตรวจสอบ dependencies ใน requirements.txt
safety check -r requirements.txt --full-report

# หรือตรวจสอบในรูปแบบ JSON เพื่อนำไปใช้ต่อ
safety check -r requirements.txt --json > safety-report.json

# ตัวอย่างผลลัพธ์เมื่อพบช่องโหว่
# +============+============+=============================================+
# | Package    | Affected   | Vulnerability                               |
# +============+============+=============================================+
# | starlette  | <0.37.0   | CVE-2025-12345 - Path Traversal in StaticFiles |
# +============+============+=============================================+

3.3 การใช้ Pipfile.lock และ pip-audit

ในปี 2026 การใช้ Pipenv หรือ Poetry เป็นเรื่องปกติมากขึ้น การใช้ pip-audit ช่วยตรวจสอบช่องโหว่จาก Pipfile.lock:

# ติดตั้ง pip-audit
pip install pip-audit

# ตรวจสอบช่องโหว่ใน Pipfile.lock
pip-audit -r Pipfile.lock

# สร้างรายงานเป็น SARIF (Static Analysis Results Interchange Format)
pip-audit -r Pipfile.lock --format sarif > pip-audit-report.sarif

4. การตรวจสอบ API Security แบบ Dynamic (DAST) สำหรับ FastAPI

DAST (Dynamic Application Security Testing) คือการทดสอบความปลอดภัยโดยการส่งคำขอไปยัง API ที่รันอยู่จริง วิธีนี้ช่วยตรวจจับช่องโหว่ที่ SAST ไม่สามารถพบได้ เช่น Logic Flaws, Authentication Bypass

4.1 เครื่องมือ DAST สำหรับ FastAPI

• OWASP ZAP (Zed Attack Proxy): เครื่องมือ DAST มาตรฐานที่รองรับ API Testing
• Postman + Newman: ใช้ Collection สำหรับทดสอบความปลอดภัยแบบอัตโนมัติ
• APIsec: เครื่องมือเชิงพาณิชย์ที่ออกแบบมาเฉพาะสำหรับ API Security Testing

4.2 การตั้งค่า OWASP ZAP สำหรับ FastAPI ใน CI/CD

ตัวอย่างการสแกน FastAPI ด้วย ZAP ใน Docker:

# docker-compose.yml สำหรับ ZAP Scanning
version: '3.8'

services:
  fastapi-app:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=sqlite:///./test.db
  
  zap:
    image: ghcr.io/zaproxy/zaproxy:stable
    command: >
      zap-api-scan.py
      -t http://fastapi-app:8000/openapi.json
      -f openapi
      -r zap-report.html
      -w zap-report.md
    volumes:
      - ./reports:/zap/reports
    depends_on:
      - fastapi-app

4.3 การเขียนการทดสอบความปลอดภัยด้วย pytest + requests

เราสามารถเขียนการทดสอบแบบ DAST ด้วยตนเองโดยใช้ pytest และ requests library:

# test_api_security.py
import pytest
import requests
from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

class TestAPISecurity:
    
    def test_sql_injection_in_login(self):
        """ทดสอบ SQL Injection ใน endpoint /login"""
        payloads = [
            {"username": "admin' OR '1'='1", "password": "password"},
            {"username": "admin; DROP TABLE users;--", "password": "test"},
            {"username": "admin", "password": "' OR 1=1 --"}
        ]
        for payload in payloads:
            response = client.post("/login", json=payload)
            assert response.status_code == 401, f"SQL Injection ผ่าน! Payload: {payload}"
    
    def test_path_traversal_in_file_download(self):
        """ทดสอบ Path Traversal ใน /download"""
        paths = [
            "/download?file=../../../etc/passwd",
            "/download?file=..\\..\\..\\windows\\system32\\config",
            "/download?file=%2e%2e%2f%2e%2e%2fetc%2fpasswd"
        ]
        for path in paths:
            response = client.get(path)
            assert response.status_code in [403, 404], f"Path Traversal ผ่าน! Path: {path}"
    
    def test_jwt_tampering(self):
        """ทดสอบการปลอมแปลง JWT Token"""
        tampered_tokens = [
            "eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkFkbWluIiwiaWF0IjoxNTE2MjM5MDIyfQ.",
            "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwicm9sZSI6ImFkbWluIn0.fake_signature"
        ]
        for token in tampered_tokens:
            response = client.get("/admin", headers={"Authorization": f"Bearer {token}"})
            assert response.status_code == 401, f"JWT Tampering ผ่าน! Token: {token[:30]}..."

5. การใช้ Dependency Injection เพื่อบังคับใช้ Security Policies

หนึ่งในจุดแข็งที่สุดของ FastAPI คือระบบ Dependency Injection ที่ช่วยให้เราสามารถสร้างกลไกความปลอดภัยแบบ reusable และบังคับใช้ได้อย่างเป็นระบบ

5.1 การสร้าง Security Middleware ด้วย Depends

# security_middleware.py
from fastapi import Depends, HTTPException, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from jose import JWTError, jwt
from typing import Optional
import re

security_scheme = HTTPBearer()

class SecurityPolicy:
    """คลาสสำหรับจัดการ Security Policy ผ่าน Dependency Injection"""
    
    def __init__(self, required_roles: list = None, rate_limit: int = 100):
        self.required_roles = required_roles or ["user"]
        self.rate_limit = rate_limit
    
    async def verify_token(self, credentials: HTTPAuthorizationCredentials = Depends(security_scheme)):
        """ตรวจสอบ JWT Token และสิทธิ์การเข้าถึง"""
        token = credentials.credentials
        try:
            payload = jwt.decode(token, "SECRET_KEY", algorithms=["HS256"])
            user_role = payload.get("role")
            if user_role not in self.required_roles:
                raise HTTPException(
                    status_code=status.HTTP_403_FORBIDDEN,
                    detail="Insufficient permissions"
                )
            return payload
        except JWTError:
            raise HTTPException(
                status_code=status.HTTP_401_UNAUTHORIZED,
                detail="Invalid authentication credentials"
            )
    
    async def validate_input(self, data: str, pattern: str = None):
        """ตรวจสอบความปลอดภัยของอินพุตก่อนส่งต่อไปยัง Business Logic"""
        if pattern and not re.match(pattern, data):
            raise HTTPException(
                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                detail=f"Input does not match required pattern: {pattern}"
            )
        return data

# การใช้งานใน FastAPI Route
from fastapi import APIRouter, Depends

router = APIRouter()

@router.get("/admin/users")
async def get_users(
    current_user: dict = Depends(SecurityPolicy(required_roles=["admin"]).verify_token)
):
    """เฉพาะผู้ใช้ที่มี role 'admin' เท่านั้นที่เข้าถึงได้"""
    return {"users": ["user1", "user2"]}

@router.post("/items")
async def create_item(
    item_name: str,
    validated_name: str = Depends(SecurityPolicy().validate_input, 
                                   data="item_name", 
                                   pattern=r"^[a-zA-Z0-9_ ]+$")
):
    """อินพุตต้องเป็น alphanumeric เท่านั้น ป้องกัน XSS"""
    return {"item": validated_name}

5.2 การใช้ Rate Limiting และ Input Validation ร่วมกัน

# rate_limit_middleware.py
from fastapi import Request, HTTPException, Depends
from datetime import datetime, timedelta
from collections import defaultdict

class RateLimiter:
    """Rate Limiter แบบ In-Memory สำหรับป้องกัน Brute Force"""
    
    def __init__(self, max_requests: int = 10, window_seconds: int = 60):
        self.max_requests = max_requests
        self.window_seconds = window_seconds
        self.requests = defaultdict(list)
    
    async def __call__(self, request: Request):
        client_ip = request.client.host
        now = datetime.now()
        
        # ลบประวัติที่เก่ากว่า window
        self.requests[client_ip] = [
            req_time for req_time in self.requests[client_ip]
            if now - req_time < timedelta(seconds=self.window_seconds)
        ]
        
        if len(self.requests[client_ip]) >= self.max_requests:
            raise HTTPException(
                status_code=429,
                detail="Too many requests. Please try again later."
            )
        
        self.requests[client_ip].append(now)
        return True

# การใช้งาน
@router.post("/login")
async def login(
    username: str,
    password: str,
    rate_limited: bool = Depends(RateLimiter(max_requests=5, window_seconds=60))
):
    # Logic การ login
    pass

6. การจัดการ Secret และ Environment Variables อย่างปลอดภัย

หนึ่งในข้อผิดพลาดที่พบบ่อยที่สุดคือการเก็บ API Keys, Database Passwords, และ Secret Keys ไว้ในซอร์สโค้ดโดยตรง การใช้ Environment Variables และ Secret Management Tools เป็นสิ่งจำเป็น

6.1 การใช้ Pydantic Settings เพื่อจัดการ Configuration

# config.py
from pydantic_settings import BaseSettings, SettingsConfigDict
from typing import Optional

class Settings(BaseSettings):
    """จัดการการตั้งค่าทั้งหมดผ่าน Environment Variables"""
    
    # Database
    database_url: str
    database_pool_size: int = 10
    
    # Security
    secret_key: str
    jwt_algorithm: str = "HS256"
    jwt_expiration_minutes: int = 30
    
    # External APIs
    openai_api_key: Optional[str] = None
    stripe_api_key: Optional[str] = None
    
    # Feature Flags
    debug_mode: bool = False
    enable_rate_limiting: bool = True
    
    model_config = SettingsConfigDict(
        env_file=".env",
        env_file_encoding="utf-8",
        case_sensitive=False
    )

settings = Settings()

# การใช้งานใน FastAPI
from fastapi import FastAPI
app = FastAPI()

@app.on_event("startup")
async def startup():
    # ใช้ settings ที่โหลดจาก Environment
    print(f"Database URL: {settings.database_url[:20]}...")  # แสดงแค่บางส่วน
    print(f"Debug Mode: {settings.debug_mode}")

6.2 การใช้ HashiCorp Vault สำหรับ Secret Management

ในสภาพแวดล้อม Production ขนาดใหญ่ การใช้ Vault ช่วยจัดการ Secret แบบ Dynamic และมี Audit Trail:

# vault_integration.py
import hvac
from pydantic import BaseModel

class VaultClient:
    """เชื่อมต่อกับ HashiCorp Vault เพื่อดึง Secret แบบ Dynamic"""
    
    def __init__(self, vault_url: str, vault_token: str):
        self.client = hvac.Client(url=vault_url, token=vault_token)
    
    def get_database_credentials(self, role_name: str) -> dict:
        """ดึง Database Credentials แบบ Dynamic (หมดอายุอัตโนมัติ)"""
        response = self.client.secrets.database.generate_credentials(
            name=role_name
        )
        return {
            "username": response["data"]["username"],
            "password": response["data"]["password"]
        }
    
    def rotate_secret_key(self):
        """หมุน Secret Key โดยอัตโนมัติ"""
        new_key = secrets.token_urlsafe(32)
        self.client.secrets.kv.v2.create_or_update_secret(
            path="fastapi/secret-key",
            secret={"value": new_key}
        )
        return new_key

7. การใช้ OpenTelemetry เพื่อตรวจจับ Security Anomalies

การตรวจสอบความปลอดภัยแบบ Real-time เป็นองค์ประกอบสำคัญของ Shift Left Security การใช้ OpenTelemetry ช่วยให้เราสามารถติดตามพฤติกรรมที่ผิดปกติของ API ได้

7.1 การติดตั้งและตั้งค่า OpenTelemetry สำหรับ FastAPI

# observability.py
from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
from opentelemetry.instrumentation.requests import RequestsInstrumentor
import time

# ตั้งค่า Tracer
tracer_provider = TracerProvider()
otlp_exporter = OTLPSpanExporter(
    endpoint="http://otel-collector:4318/v1/traces"
)
span_processor = BatchSpanProcessor(otlp_exporter)
tracer_provider.add_span_processor(span_processor)
trace.set_tracer_provider(tracer_provider)

# Instrument FastAPI
FastAPIInstrumentor().instrument()

# Instrument requests library
RequestsInstrumentor().instrument()

# ตัวอย่างการสร้าง Custom Span สำหรับ Security Events
from opentelemetry import trace
tracer = trace.get_tracer(__name__)

async def log_security_event(event_type: str, details: dict):
    """บันทึก Security Event เพื่อการวิเคราะห์"""
    with tracer.start_as_current_span("security-event") as span:
        span.set_attribute("event.type", event_type)
        span.set_attribute("event.timestamp", time.time())
        for key, value in details.items():
            span.set_attribute(f"event.{key}", str(value))
        
        # ตรวจสอบ Anomaly
        if event_type == "failed_login_attempt":
            span.set_attribute("event.severity", "high")
        
        return span

7.2 การสร้าง Alerting Rules สำหรับ Security Events

ตัวอย่างการตั้งค่า Prometheus Alerting Rules สำหรับ FastAPI Security:

# prometheus-alerts.yml
groups:
  - name: fastapi-security-alerts
    rules:
      - alert: HighFailedLoginRate
        expr: rate(fastapi_http_request_duration_seconds_count{method="POST",path="/login",status="401"}[5m]) > 10
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "อัตราการ Login ล้มเหลวสูงผิดปกติ"
          description: "มี Failed Login มากกว่า 10 ครั้งใน 5 นาที"

      - alert: SQLInjectionAttempt
        expr: fastapi_security_event_total{event_type="sql_injection_detected"} > 0
        for: 30s
        labels:
          severity: critical
        annotations:
          summary: "ตรวจพบความพยายาม SQL Injection"
          description: "พบ SQL Injection Attempt จาก IP {{ $labels.client_ip }}"

      - alert: ExcessiveAPICalls
        expr: rate(fastapi_http_request_duration_seconds_count[1m]) > 1000
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "API Calls จำนวนมากผิดปกติ"
          description: "มากกว่า 1000 requests/นาที อาจเป็นการโจมตีแบบ DoS"

8. การทดสอบความปลอดภัยแบบ Contract-First Testing

การใช้ OpenAPI Specification (Swagger) ที่ FastAPI สร้างให้อัตโนมัติเป็นจุดเริ่มต้นที่ดีในการทำ Contract Testing ซึ่งช่วยให้เราตรวจสอบความปลอดภัยของ API Contract ได้ก่อนการพัฒนา

8.1 การใช้ Schemathesis สำหรับ Fuzz Testing ของ API

# schemathesis_test.py
import schemathesis
from schemathesis import DataGenerationMethod

# โหลด API Schema จาก FastAPI
schema = schemathesis.from_path("openapi.json")

@schema.parametrize()
def test_api_security(case):
    """ทดสอบ API ด้วยข้อมูลสุ่มเพื่อหาช่องโหว่"""
    response = case.call()
    # ตรวจสอบว่าไม่มีการเปิดเผยข้อมูลที่ sensitive
    assert response.status_code not in [500, 502, 503], f"พบ Internal Server Error: {response.text}"
    
    # ตรวจสอบ response time (ป้องกัน DoS)
    assert response.elapsed.total_seconds() < 5, "Response time เกิน 5 วินาที"
    
    # ตรวจสอบว่าไม่มี sensitive data ใน response
    sensitive_patterns = ["secret", "password", "token", "api_key"]
    for pattern in sensitive_patterns:
        if pattern in response.text.lower():
            # ถ้าเป็น error response ที่คาดหวังให้ผ่าน
            if response.status_code in [400, 401, 403]:
                continue
            assert False, f"พบข้อมูล sensitive ใน response: {pattern}"

# การรันด้วย pytest
# pytest schemathesis_test.py --hypothesis-seed=42

8.2 การใช้ Dredd สำหรับ API Contract Testing

Dredd เป็นเครื่องมือที่ใช้ API Blueprint หรือ OpenAPI Specification ในการทดสอบ API ตามสัญญาที่กำหนด:

# dredd.yml
dry-run: null
hookfiles: ./dredd_hooks.py
language: python
server: uvicorn main:app --host 0.0.0.0 --port 8000
server-wait: 3
init: false
custom:
  - auth_token: "Bearer test_token_123"
names: false
only: []
reporter: []
output: []
header: []
sorted: false
user: null
inline-errors: false
details: false
method: []
color: true
level: info
timestamp: false
silent: false
path: []
hooks-worker-timeout: 5000
sandbox: false
github: null
url: "http://localhost:8000"

# dredd_hooks.py
import dredd_hooks as hooks
import requests

@hooks.before_each
def add_auth_header(transaction):
    """เพิ่ม Authorization Header ก่อนการทดสอบทุกครั้ง"""
    if transaction['request']['headers']:
        transaction['request']['headers']['Authorization'] = 'Bearer test_token_123'
    else:
        transaction['request']['headers'] = {'Authorization': 'Bearer test_token_123'}

@hooks.after("/users > POST > 201 > application/json")
def validate_user_creation(transaction):
    """ตรวจสอบว่าการสร้างผู้ใช้มี password strength check"""
    response = transaction['real']
    if response['statusCode'] == '201':
        # ตรวจสอบว่า password ถูก hash แล้ว
        import json
        body = json.loads(response['body'])
        assert 'password' not in body, "Password ถูกเปิดเผยใน response!"
        assert 'hashed_password' in body, "Password ควรถูก hash ก่อนเก็บ"

9. การจัดการ CORS และ Content Security Policy (CSP)

การกำหนดค่า CORS และ CSP ที่ถูกต้องเป็นแนวป้องกันชั้นแรกสำหรับ API ของคุณ FastAPI มีการจัดการ CORS ที่ง่ายดายผ่าน CORSMiddleware

9.1 การตั้งค่า CORS อย่างปลอดภัย

# cors_setup.py
from fastapi.middleware.cors import CORSMiddleware
from typing import List

def setup_secure_cors(app):
    """ตั้งค่า CORS ตามหลักการ Least Privilege"""
    
    # ใน Development อาจใช้ wildcard แต่ใน Production ต้องระบุให้ชัดเจน
    origins: List[str] = [
        "https://your-frontend-domain.com",
        "https://admin.your-domain.com",
        # ไม่ควรใช้ "http://localhost:3000" ใน Production
    ]
    
    app.add_middleware(
        CORSMiddleware,
        allow_origins=origins,
        allow_credentials=True,  # ต้องเป็น True ถ้าต้องการส่ง Cookie
        allow_methods=["GET", "POST", "PUT", "DELETE", "PATCH"],
        allow_headers=[
            "Authorization",
            "Content-Type",
            "X-Requested-With",
            "X-API-Key"
        ],
        expose_headers=[
            "X-Total-Count",
            "X-RateLimit-Remaining"
        ],
        max_age=600,  # CORS Preflight Cache 10 นาที
    )
    
    # เพิ่ม Security Headers
    @app.middleware("http")
    async def add_security_headers(request, call_next):
        response = await call_next(request)
        response.headers["X-Content-Type-Options"] = "nosniff"
        response.headers["X-Frame-Options"] = "DENY"
        response.headers["X-XSS-Protection"] = "1; mode=block"
        response.headers["Strict-Transport-Security"] = "max-age=31536000; includeSubDomains"
        response.headers["Content-Security-Policy"] = "default-src 'self'"
        return response

9.2 การทดสอบ CORS Configuration

# test_cors.py
import pytest
from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

class TestCORS:
    
    def test_cors_headers_present(self):
        """ตรวจสอบว่า CORS Headers ถูกส่งกลับ"""
        response = client.options(
            "/users",
            headers={
                "Origin": "https://your-frontend-domain.com",
                "Access-Control-Request-Method": "GET"
            }
        )
        assert response.headers.get("access-control-allow-origin") == "https://your-frontend-domain.com"
        assert "GET" in response.headers.get("access-control-allow-methods", "")
    
    def test_cors_reject_unknown_origin(self):
        """ตรวจสอบว่า Origin ที่ไม่ได้รับอนุญาตถูกปฏิเสธ"""
        response = client.options(
            "/users",
            headers={
                "Origin": "https://malicious-site.com",
                "Access-Control-Request-Method": "GET"
            }
        )
        assert "access-control-allow-origin" not in response.headers
    
    def test_security_headers_present(self):
        """ตรวจสอบ Security Headers ในการตอบกลับทุกครั้ง"""
        response = client.get("/users")
        assert response.headers.get("x-content-type-options") == "nosniff"
        assert response.headers.get("x-frame-options") == "DENY"
        assert "strict-transport-security" in response.headers

10. Best Practices และ Real-World Use Cases

10.1 กรณีศึกษา: การป้องกัน API ของ FinTech Startup

บริษัท FinTech แห่งหนึ่งใช้ FastAPI สำหรับระบบ Payment Gateway พวกเขาประสบปัญหาการโจมตีแบบ Brute Force และ API Abuse หลังจากการนำ Shift Left Security มาใช้:

• ปัญหาเดิม: ไม่มี Rate Limiting, JWT Secret ถูก hardcode ในโค้ด, ไม่มีการตรวจสอบ Input injection
• แนวทางแก้ไข:
  • ใช้ Redis-based Rate Limiter แบบ Token Bucket
  • ย้าย Secret Keys ไปยัง AWS Secrets Manager
  • ใช้ Pydantic Validators เพื่อ sanitize ทุก input
  • ตั้งค่า Semgrep Rules เพื่อตรวจจับการ hardcode Secret
• ผลลัพธ์: ลดจำนวน security incidents ได้ 95% ภายใน 3 เดือน

10.2 กรณีศึกษา: API สำหรับ Healthcare Application

แอปพลิเคชันด้านสุขภาพที่ต้องปฏิบัติตาม HIPAA Compliance ได้นำ Shift Left Security มาใช้กับ FastAPI:

• ความท้าทาย: ต้องเข้ารหัสข้อมูลผู้ป่วยทุกระดับ (Encryption at Rest และ Transit)
• แนวทางแก้ไข:
  • ใช้ Field Encryption ใน Pydantic Models
  • ตั้งค่า Audit Logging ทุกการเข้าถึงข้อมูลผู้ป่วย
  • ใช้ OpenTelemetry เพื่อตรวจจับการเข้าถึงที่ผิดปกติ
  • ทำ Contract Testing ทุกครั้งก่อน deploy
• ผลลัพธ์: ผ่าน HIPAA Audit ครั้งแรกโดยไม่มี non-compliance

10.3 ข้อควรปฏิบัติ (Best Practices) สำหรับ FastAPI Shift Left Security

1. เริ่มต้นด้วย Security by Design: ออกแบบ API โดยคำนึงถึงความปลอดภัยตั้งแต่แรก ใช้ Pydantic Models เพื่อกำหนดขอบเขตของข้อมูล
2. ใช้ Layered Security: อย่าพึ่งพาเพียงวิธีการป้องกันเดียว ใช้ทั้ง Input Validation, Authentication, Authorization, Rate Limiting ร่วมกัน
3. ทำ Security Testing อัตโนมัติ: ผสาน SAST, DAST, SCA เข้ากับ CI/CD Pipeline ตั้งแต่ Pull Request Stage
4. จัดการ Secrets อย่างมืออาชีพ: ใช้ Vault, AWS Secrets Manager หรือ Azure Key Vault อย่าเก็บ Secrets ไว้ใน Git
5. ติดตามและแจ้งเตือนแบบ Real-time: ใช้ OpenTelemetry + Prometheus + Grafana เพื่อตรวจจับ Anomaly
6. อัปเดต Dependencies อย่างสม่ำเสมอ: ใช้ Dependabot หรือ Renovate เพื่อรับการแจ้งเตือนเมื่อมีช่องโหว่

   บทความที่เกี่ยวข้อง

   • DNS Server สำหรับองค์กร: เลือก Pi-hole, Windows DNS หรือ Unbound ดี
   • Python Click CLI Cache Strategy Redis — คู่มือฉบับสมบูรณ์ 2026 | SiamCafe Blog
   • Backup Strategy 3-2-1-1-0 Rule สำหรับ IT Admin 2026
   Siam2R.com — Portfolio งาน IT · XM Signal — Free Forex EA Download