Azure Functions Code Review Best Practice — คู่มือฉบับสมบูรณ์ 2026 | SiamCafe Blog

บทนำ: ทำไม Code Review สำหรับ Azure Functions ถึงสำคัญในปี 2026

ในยุคที่การพัฒนาแอปพลิเคชันแบบ Serverless กลายเป็นมาตรฐานใหม่ Azure Functions ได้กลายเป็นเครื่องมือหลักของนักพัฒนาทั่วโลก โดยเฉพาะในภูมิภาคเอเชียตะวันออกเฉียงใต้ที่ธุรกิจต้องการความรวดเร็วและ scalability สูง การเขียน Azure Functions อาจดูเหมือนง่าย แต่การทำ Code Review อย่างถูกต้องกลับเป็นสิ่งที่หลายองค์กรมองข้าม

บทความนี้จะพาคุณดำดิ่งสู่แนวปฏิบัติที่ดีที่สุดสำหรับการตรวจสอบโค้ด Azure Functions ในปี 2026 ซึ่งครอบคลุมตั้งแต่การจัดการ Cold Start, การออกแบบ Dependency Injection, การจัดการ Connection Pool, ไปจนถึงการทำ Monitoring และ Observability ที่มีประสิทธิภาพ

SiamCafe Blog ขอนำเสนอคู่มือฉบับสมบูรณ์ที่รวบรวมประสบการณ์จริงจากโปรเจกต์ขนาดใหญ่ในประเทศไทย ไม่ว่าจะเป็นระบบธนาคาร, E-Commerce, หรือระบบ IoT ที่ต้องรองรับผู้ใช้งานนับล้าน

1. พื้นฐานการออกแบบ Azure Functions ที่ควรรู้ก่อน Code Review

1.1 ทำความเข้าใจ Execution Model

ก่อนจะเริ่ม Code Review สิ่งสำคัญที่สุดคือการเข้าใจว่า Azure Functions ทำงานอย่างไร โดยเฉพาะใน Consumption Plan และ Premium Plan ซึ่งมีพฤติกรรมแตกต่างจาก Web Application ทั่วไป

• Stateless โดยธรรมชาติ: ฟังก์ชันแต่ละครั้งจะทำงานแยกกัน ไม่ควรเก็บ state ไว้ใน memory
• Cold Start Problem: เมื่อฟังก์ชันไม่ได้ถูกเรียกใช้เป็นเวลานาน ระบบจะต้องโหลด runtime ใหม่ ซึ่งใช้เวลา 1-10 วินาที
• Concurrency Limits: แต่ละ instance สามารถรองรับหลาย request พร้อมกันได้ แต่มีขีดจำกัด

1.2 การเลือก Trigger และ Binding ที่เหมาะสม

หนึ่งในข้อผิดพลาดที่พบบ่อยในการ Code Review คือการใช้ Trigger หรือ Binding ไม่เหมาะสมกับ workload

2. การจัดการ Dependency Injection และ Configuration

2.1 หลักการ DI ที่ถูกต้องสำหรับ Azure Functions

ในปี 2026 การใช้ Dependency Injection ใน Azure Functions เป็นเรื่องปกติ แต่สิ่งที่มักพลาดคือการจัดการ Lifetime ของ Service

// ตัวอย่าง DI ที่ไม่ถูกต้อง - สร้าง HttpClient ทุกครั้งที่เรียกใช้
public class BadFunctionExample
{
    [FunctionName("ProcessOrder")]
    public async Task<IActionResult> Run(
        [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req)
    {
        using var client = new HttpClient(); // ❌ ไม่ควรสร้าง HttpClient ซ้ำๆ
        var response = await client.GetAsync("https://api.example.com");
        return new OkObjectResult(response);
    }
}

// ตัวอย่าง DI ที่ถูกต้อง - ใช้ HttpClientFactory และ DI
public class GoodFunctionExample
{
    private readonly IHttpClientFactory _httpClientFactory;
    private readonly IOrderService _orderService;
    
    public GoodFunctionExample(
        IHttpClientFactory httpClientFactory,
        IOrderService orderService) // ✅ ใช้ DI ผ่าน Constructor
    {
        _httpClientFactory = httpClientFactory;
        _orderService = orderService;
    }
    
    [FunctionName("ProcessOrder")]
    public async Task<IActionResult> Run(
        [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req)
    {
        var client = _httpClientFactory.CreateClient("OrderApi");
        var order = await _orderService.ProcessOrderAsync(req.Body);
        return new OkObjectResult(order);
    }
}

2.2 การจัดการ Configuration และ Environment Variables

ข้อผิดพลาดที่พบบ่อยอีกประการคือการ Hardcode ค่า Configuration หรือการไม่ใช้ Managed Identity

2.3 การใช้ Options Pattern

ควรใช้ IOptions<T> ในการจัดการ Configuration เพื่อให้สามารถทดสอบและเปลี่ยนแปลงค่าได้ง่าย

// ตัวอย่างการใช้ Options Pattern
public class StorageOptions
{
    public const string SectionName = "Storage";
    
    public string ConnectionString { get; set; } = string.Empty;
    public int RetryCount { get; set; } = 3;
    public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(30);
}

// ใน Startup.cs หรือ Program.cs
builder.Services.Configure<StorageOptions>(
    builder.Configuration.GetSection(StorageOptions.SectionName));
    
// ใน Function Class
public class FileProcessorFunction
{
    private readonly StorageOptions _options;
    
    public FileProcessorFunction(IOptions<StorageOptions> options)
    {
        _options = options.Value;
    }
    
    [FunctionName("ProcessFile")]
    public async Task Run(
        [BlobTrigger("uploads/{name}", Connection = "StorageConnection")] Stream myBlob,
        string name)
    {
        // ใช้ _options.RetryCount, _options.Timeout
    }
}

3. การจัดการ Performance และ Cold Start

3.1 กลยุทธ์ลด Cold Start

Cold Start เป็นปัญหาที่ท้าทายที่สุดของ Azure Functions โดยเฉพาะใน Consumption Plan ต่อไปนี้คือแนวปฏิบัติที่ควรตรวจสอบใน Code Review

1. ใช้ Premium Plan หรือ Dedicated Plan สำหรับ workload ที่ต้องการ latency ต่ำ
2. เปิด Always Ready Instances ใน Premium Plan เพื่อให้มี instance พร้อมเสมอ
3. ลด Dependency ในการ Startup – หลีกเลี่ยงการโหลด library ขนาดใหญ่ที่ไม่จำเป็น
4. ใช้ Static Constructor สำหรับการ initialize ครั้งเดียว
5. ใช้ Lazy Initialization สำหรับ service ที่ไม่จำเป็นต้องใช้ทันที

3.2 การจัดการ Connection Pool

หนึ่งในสาเหตุหลักของ Performance Issue คือการจัดการ Connection ไม่ถูกต้อง

4. การจัดการ Error Handling และ Logging

4.1 Error Handling ที่ดีควรเป็นอย่างไร

Code Review ที่ดีต้องตรวจสอบว่า Function มีการจัดการ Exception อย่างเหมาะสม ไม่ใช่แค่ try-catch ทั่วไป

// ตัวอย่าง Error Handling ที่ถูกต้อง
[FunctionName("ProcessPayment")]
public async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req,
    ILogger log)
{
    try
    {
        var paymentRequest = await req.ReadFromJsonAsync<PaymentRequest>();
        
        // Validation
        if (paymentRequest == null || !paymentRequest.IsValid())
        {
            return new BadRequestObjectResult(new { error = "Invalid payment request" });
        }
        
        var result = await _paymentService.ProcessAsync(paymentRequest);
        
        // Structured logging
        log.LogInformation(
            "Payment processed successfully. OrderId: {OrderId}, Amount: {Amount}",
            result.OrderId,
            paymentRequest.Amount);
            
        return new OkObjectResult(result);
    }
    catch (ValidationException ex)
    {
        log.LogWarning(ex, "Validation failed for payment request");
        return new BadRequestObjectResult(new { error = ex.Message });
    }
    catch (PaymentServiceException ex)
    {
        log.LogError(ex, "Payment service error for OrderId: {OrderId}", ex.OrderId);
        
        // ส่งไปยัง Dead-letter Queue หรือ Retry Queue
        await _deadLetterQueue.SendAsync(new FailedPaymentMessage
        {
            OrderId = ex.OrderId,
            ErrorMessage = ex.Message,
            Timestamp = DateTime.UtcNow
        });
        
        return new StatusCodeResult(503);
    }
    catch (Exception ex)
    {
        log.LogCritical(ex, "Unexpected error processing payment");
        return new StatusCodeResult(500);
    }
}

4.2 การใช้ Application Insights อย่างมีประสิทธิภาพ

การทำ Code Review ควรรวมถึงการตรวจสอบ Telemetry และ Monitoring ด้วย

• Custom Events: บันทึก business events ที่สำคัญ เช่น OrderCreated, PaymentFailed
• Metrics: วัด performance metrics เช่น latency, throughput
• Dependency Tracking: ติดตามการเรียกใช้ service ภายนอกทั้งหมด
• Distributed Tracing: ใช้ Correlation ID เพื่อติดตาม request ข้าม service

5. Security Best Practices สำหรับ Azure Functions

5.1 การจัดการ Authentication และ Authorization

ในปี 2026 ความปลอดภัยเป็นสิ่งที่ไม่สามารถมองข้ามได้ โดยเฉพาะเมื่อ Azure Functions ถูกใช้เป็น API Gateway

1. ใช้ Managed Identity แทน Connection String หรือ API Key
2. Enable Easy Auth (App Service Authentication) สำหรับ HTTP Trigger
3. ใช้ RBAC ในการควบคุมสิทธิ์การเข้าถึง resource อื่นๆ
4. Validate Token ทุกครั้ง – อย่าเชื่อถือ token ที่ส่งมาโดยไม่ตรวจสอบ

5.2 การจัดการ Secrets

ข้อผิดพลาดที่พบบ่อยที่สุดในการ Code Review คือการเก็บ Secrets ไว้ในโค้ด

• ใช้ Key Vault References ใน App Settings แทน Connection String โดยตรง
• ไม่เก็บ Secrets ใน Source Control – ใช้ user secrets สำหรับ local development
• ใช้ Azure Key Vault สำหรับ production secrets
• Rotate Secrets เป็นประจำ – ตั้งค่า auto-rotation ถ้าเป็นไปได้

6. Real-World Use Cases จากโปรเจกต์จริงในประเทศไทย

6.1 กรณีศึกษา: ระบบชำระเงินของธนาคารชั้นนำ

ธนาคารแห่งหนึ่งในประเทศไทยใช้ Azure Functions สำหรับระบบ Real-time Payment Processing ซึ่งต้องรองรับ transaction มากกว่า 10,000 รายการต่อวินาที

ปัญหาที่พบในการ Code Review:

• การใช้ HttpClient แบบใหม่ทุกครั้ง ทำให้เกิด Socket Exhaustion
• ไม่มีการตั้งค่า Timeout ทำให้ function ค้างนานเกินไป
• ไม่มีการใช้ Retry Policy สำหรับการเรียก Database

แนวทางแก้ไข:

• เปลี่ยนมาใช้ HttpClientFactory และเพิ่ม Pool Size
• ตั้งค่า Timeout ที่เหมาะสม (15 วินาทีสำหรับ internal, 30 วินาทีสำหรับ external)
• ใช้ Polly Policy สำหรับ Retry และ Circuit Breaker

6.2 กรณีศึกษา: ระบบ IoT สำหรับ Smart Farming

สตาร์ทอัพด้านเกษตรกรรมใช้ Azure Functions สำหรับประมวลผลข้อมูลจากเซ็นเซอร์นับหมื่นตัว

ปัญหาที่พบ:

• Cold Start ทำให้ข้อมูลสูญหายในช่วงเวลาที่ sensor ส่งข้อมูล
• การจัดการ Event Hub Checkpoint ไม่ถูกต้อง ทำให้ข้อมูลถูกประมวลผลซ้ำ

แนวทางแก้ไข:

• เปลี่ยนจาก Consumption Plan เป็น Premium Plan พร้อม Always Ready Instances
• ใช้ Blob Storage Checkpointing แทน In-Memory
• เพิ่ม Dead-letter Queue สำหรับข้อมูลที่ประมวลผลไม่สำเร็จ

7. Testing และ CI/CD สำหรับ Azure Functions

7.1 Unit Testing ที่ดี

Code Review ควรตรวจสอบว่ามีการเขียน Unit Test ที่ครอบคลุม business logic และ edge cases

• Test Static Methods: ฟังก์ชันที่ไม่มีการ dependency ภายนอก
• Mock External Dependencies: ใช้ Moq หรือ NSubstitute สำหรับ HttpClient, Database
• Test Cold Start Scenario: ทดสอบว่า function ทำงานได้เมื่อ instance ถูกสร้างใหม่
• Test Timeout และ Retry: จำลองสถานการณ์ที่ service ภายนอกช้าหรือล้มเหลว

7.2 Integration Testing

การทดสอบแบบ Integration ควรครอบคลุมการทำงานร่วมกับ Azure Services จริง

// ตัวอย่าง Integration Test โดยใช้ Azurite (Storage Emulator)
[Fact]
public async Task ProcessOrder_WhenQueueHasMessage_ShouldProcessSuccessfully()
{
    // Arrange
    var queueClient = new QueueClient("UseDevelopmentStorage=true", "orders");
    await queueClient.CreateIfNotExistsAsync();
    await queueClient.SendMessageAsync(JsonSerializer.Serialize(new Order
    {
        OrderId = "ORD-001",
        Amount = 1000
    }));
    
    // Act
    var function = new OrderProcessorFunction(_mockService.Object);
    await function.Run(queueClient, "orders", _log.Object);
    
    // Assert
    // ตรวจสอบว่า message ถูกลบจาก queue
    var messageCount = (await queueClient.PeekMessagesAsync()).Value.Count();
    Assert.Equal(0, messageCount);
}

8. Monitoring และ Observability

8.1 สิ่งที่ควร Monitor

ในการ Code Review ควรตรวจสอบว่ามีการตั้งค่า Monitoring ที่ครอบคลุมทุกมิติ

8.2 การตั้ง Alert ที่เหมาะสม

การมี Monitoring โดยไม่มี Alert ที่ดีก็เหมือนการมีกล้องวงจรปิดแต่ไม่มีคนดู

• Critical Alerts: ส่ง SMS หรือ Phone Call ทันทีเมื่อ Error Rate > 5%
• Warning Alerts: ส่ง Email เมื่อ Queue Length > 1,000 หรือ Cold Start Rate > 10%
• Info Alerts: บันทึกลง Log เมื่อมีการ deploy ใหม่หรือ configuration เปลี่ยนแปลง

9. การจัดการ Versioning และ Backward Compatibility

9.1 API Versioning สำหรับ HTTP Trigger

เมื่อ Azure Functions ถูกใช้เป็น API ควรมีกลยุทธ์การ versioning ที่ชัดเจน

// ตัวอย่าง API Versioning โดยใช้ URL Path
[FunctionName("GetOrderV1")]
public async Task<IActionResult> GetOrderV1(
    [HttpTrigger(AuthorizationLevel.Function, "get", Route = "v1/orders/{orderId}")] 
    HttpRequest req,
    string orderId)
{
    // Version 1 implementation
    var order = await _orderService.GetOrderV1Async(orderId);
    return new OkObjectResult(order);
}

[FunctionName("GetOrderV2")]
public async Task<IActionResult> GetOrderV2(
    [HttpTrigger(AuthorizationLevel.Function, "get", Route = "v2/orders/{orderId}")] 
    HttpRequest req,
    string orderId)
{
    // Version 2 implementation with additional fields
    var order = await _orderService.GetOrderV2Async(orderId);
    return new OkObjectResult(order);
}

9.2 การจัดการ Breaking Changes

เมื่อต้องเปลี่ยนแปลง behavior ของ function ควรมีแผนการ migration ที่ชัดเจน

• Deprecation Header: เพิ่ม Warning Header ใน response เพื่อแจ้ง client
• Feature Flag: ใช้ Feature Flags เพื่อเปิด-ปิดฟีเจอร์ใหม่โดยไม่ต้อง deploy ใหม่
• Shadow Testing: รันทั้งเวอร์ชันเก่าและใหม่พร้อมกันเพื่อเปรียบเทียบผลลัพธ์

10. Cost Optimization

10.1 การเลือก Plan ที่เหมาะสม

หนึ่งในประเด็นที่ควรตรวจสอบใน Code Review คือการเลือก Pricing Tier ที่เหมาะสม

10.2 เทคนิคประหยัดค่าใช้จ่าย

• ใช้ Consumption Plan สำหรับ Event-Driven Workload: ถ้า function ถูกเรียกไม่บ่อย
• ตั้ง Timeout ที่เหมาะสม: อย่าให้ function รันนานเกินความจำเป็น
• ใช้ Batch Processing: รวมหลายๆ request เข้าด้วยกันเพื่อลดจำนวน execution
• ใช้ Reserved Instances: สำหรับ Dedicated Plan ที่ใช้งานตลอด 24 ชม.

Summary

การทำ Code Review สำหรับ Azure Functions ในปี 2026 ไม่ใช่แค่การตรวจสอบ syntax หรือ coding standard แต่เป็นการตรวจสอบ holistic approach ที่ครอบคลุมทุกมิติ ตั้งแต่การออกแบบสถาปัตยกรรม, การจัดการ performance, ความปลอดภัย, ไปจนถึง cost optimization

หัวใจสำคัญที่ควรจดจำคือ Azure Functions เป็น platform ที่ทรงพลังแต่ก็มีข้อจำกัด การเข้าใจ execution model, cold start behavior, และการจัดการ resource อย่างถูกต้องจะช่วยให้คุณสร้างระบบที่ทั้งเร็ว ปลอดภัย และประหยัดค่าใช้จ่าย

SiamCafe Blog หวังว่าคู่มือฉบับสมบูรณ์นี้จะเป็นประโยชน์สำหรับนักพัฒนาไทยทุกท่าน ไม่ว่าคุณจะเพิ่งเริ่มต้นกับ Azure Functions หรือเป็น developer มากประสบการณ์ การนำ best practices เหล่านี้ไปปรับใช้จะช่วยยกระดับคุณภาพโค้ดของคุณอย่างแน่นอน

หากมีข้อสงสัยหรือต้องการแบ่งปันประสบการณ์ สามารถคอมเมนต์ด้านล่างหรือติดต่อเราผ่านช่องทาง Social Media ของ SiamCafe ได้เลยครับ พบกันใหม่ในบทความหน้าครับ