Cloud

Serverless Lambda Cloud Functions

📅 2026-02-09 | โดย อ.บอม กิตติทัศน์ เจริญพนาสิทธิ์ — SiamCafe.net Since 1997

Serverless Lambda Cloud Functions คืออะไร / ทำไมถึงสำคัญ

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

Serverless ไม่ได้แปลว่าไม่มี Server นะครับ (ชื่อมันอาจจะทำให้งงหน่อย) แต่หมายถึงว่าเราไม่ต้องไปดูแลจัดการ Server เองทั้งหมดไง! เราแค่เขียนโค้ดฟังก์ชันของเรา แล้วโยนขึ้นไปบน Cloud ให้ Cloud Provider อย่าง AWS, Google Cloud, Azure จัดการเรื่อง Server, Scaling, Security ให้หมดเลย

Lambda Function (ของ AWS), Cloud Functions (ของ Google Cloud), Azure Functions (ของ Microsoft Azure) พวกนี้แหละครับ คือตัวอย่างของ Serverless Function ที่เราสามารถเอาไปใช้งานได้ง่ายๆ เลย สมัยผมทำร้านเน็ต (SiamCafe.net) นี่อยากทำอะไรทีต้องมานั่ง config server เอง ปวดหัวสุดๆ เดี๋ยวนี้สบายกว่าเยอะ

ทำไมมันถึงสำคัญน่ะเหรอ? หลักๆ เลยคือมันช่วยลดภาระในการดูแล Server ไปได้เยอะมาก เราโฟกัสกับการเขียนโค้ดแก้ปัญหาได้อย่างเดียว ค่าใช้จ่ายก็ลดลงด้วย เพราะเราจ่ายเฉพาะตอนที่ฟังก์ชันเราทำงานเท่านั้น (Pay-as-you-go) ไม่ต้องจ่ายค่า Server ตลอด 24 ชั่วโมง

พื้นฐานที่ต้องรู้

Function as a Service (FaaS)

Serverless เนี่ย จริงๆ แล้วมันเป็นส่วนหนึ่งของ Cloud Computing Model ที่เรียกว่า Function as a Service (FaaS) ครับ FaaS คือการที่เราสามารถ Deploy และ Execute โค้ดของเราเป็น Function เล็กๆ โดยไม่ต้องกังวลเรื่อง Infrastructure เลย เปรียบเทียบง่ายๆ เหมือนเราเช่าห้องพักรายวัน แทนที่จะเช่าคอนโดทั้งเดือน

Event-Driven Architecture

Serverless Function ส่วนใหญ่มักจะทำงานแบบ Event-Driven ครับ หมายความว่ามันจะถูก Trigger (กระตุ้น) ให้ทำงานเมื่อมี Event บางอย่างเกิดขึ้น เช่น มีคนอัพโหลดรูปภาพขึ้น Cloud Storage, มีข้อมูลใหม่ถูกส่งเข้ามาใน Database หรือมีคนคลิกปุ่มบนเว็บไซต์

Stateless Functions

Serverless Function ส่วนใหญ่ควรจะเป็น Stateless ครับ หมายความว่ามันไม่ควรจะเก็บข้อมูลอะไรไว้ในตัวมันเอง (ยกเว้นข้อมูลที่จำเป็นสำหรับการทำงานในครั้งนั้นๆ) เพราะ Function อาจจะถูกเรียกใช้บน Server ตัวไหนก็ได้ ทำให้การเก็บ State ไว้ใน Function อาจจะทำให้เกิดปัญหาได้

วิธีใช้งาน / เริ่มต้นยังไง

เริ่มต้นใช้งาน Serverless Function ง่ายมากครับ ไม่ว่าจะเป็น AWS Lambda, Google Cloud Functions หรือ Azure Functions หลักการคล้ายๆ กัน คือ

1. สร้าง Account บน Cloud Provider ที่เราต้องการใช้
2. เลือก Service ที่เป็น Serverless Function (เช่น AWS Lambda)
3. เขียนโค้ด Function ของเรา (รองรับหลายภาษา เช่น Python, Node.js, Java)
4. Deploy โค้ดขึ้นไปบน Cloud
5. กำหนด Trigger ที่จะทำให้ Function ของเราทำงาน (เช่น HTTP Request, Event จาก Cloud Storage)
6. ทดสอบ Function ของเรา

แค่นี้เองครับ! ลองเข้าไปดูตัวอย่างการใช้งานบน SiamCafe Blog ได้เลย

ขั้นตอนปฏิบัติจริง

สร้าง Function ง่ายๆ ด้วย AWS Lambda (Python)

สมมติว่าเราอยากสร้าง Function ที่จะทักทายผู้ใช้ตามชื่อที่ส่งเข้ามา เราสามารถเขียนโค้ด Python แบบนี้ได้:

def lambda_handler(event, context):
  name = event['name']
  message = f"สวัสดีครับคุณ {name}!"
  return {
    'statusCode': 200,
    'body': message
  }

จากนั้นเราก็ Deploy โค้ดนี้ขึ้นไปบน AWS Lambda แล้วกำหนดให้มันทำงานเมื่อมี HTTP Request เข้ามา เมื่อมีคนส่ง Request ที่มีข้อมูล {'name': 'BOM'} เข้ามา Lambda Function ของเราก็จะตอบกลับด้วยข้อความ สวัสดีครับคุณ BOM!

ตั้งค่า Trigger ให้ Function ทำงานเมื่อมีไฟล์อัพโหลด (Google Cloud Functions)

ถ้าเราอยากให้ Function ของเราทำงานเมื่อมีไฟล์ถูกอัพโหลดขึ้น Google Cloud Storage เราสามารถตั้งค่า Trigger ให้ Cloud Functions ทำงานเมื่อมี Event google.storage.object.finalize เกิดขึ้นได้

import functions_framework

@functions_framework.cloud_event
def hello_gcs(cloud_event):
    """Triggered by a change to a Cloud Storage bucket.
    Args:
        cloud_event (dict): The Cloud Functions event payload.
    Returns:
        None; the output is written to Stackdriver Logging
    """
    data = cloud_event.data

    bucket = data["bucket"]
    name = data["name"]

    print(f"File: {name} in bucket: {bucket} uploaded.")

โค้ดนี้จะ Print ชื่อไฟล์และ Bucket ที่ไฟล์ถูกอัพโหลดขึ้นไป แค่นี้เราก็สามารถสร้าง Automation ง่ายๆ ได้แล้ว

ติดตาม Logging และ Monitoring

สิ่งสำคัญอีกอย่างคือการติดตาม Logging และ Monitoring ของ Function เราครับ Cloud Provider ส่วนใหญ่จะมี Tools ให้เราดู Log, Metric ต่างๆ เพื่อให้เราสามารถ Debug และ Optimize Function ของเราได้อย่างมีประสิทธิภาพ อย่าลืมเข้าไปดู SiamCafe Blog บ่อยๆ นะครับ มี Tips & Tricks อีกเยอะเลย

เปรียบเทียบกับทางเลือกอื่น

Serverless Function ไม่ใช่ทุกอย่างครับ มันก็มีข้อดีข้อเสียของมัน ถ้าเทียบกับทางเลือกอื่นๆ เช่น Virtual Machine (VM) หรือ Container (เช่น Docker) เราจะเห็นภาพชัดเจนขึ้น

คุณสมบัติ	Virtual Machine (VM)	Container (Docker)	Serverless Function
การจัดการ Server	ต้องจัดการเองทั้งหมด	ต้องจัดการ Container Runtime	ไม่ต้องจัดการ
Scaling	ต้อง Scale เอง	ต้อง Scale เอง	Auto Scaling
ค่าใช้จ่าย	จ่ายตลอดเวลา	จ่ายตลอดเวลา	Pay-as-you-go
เหมาะสำหรับ	Application ที่ต้องการ Resource เยอะๆ	Application ที่ต้องการ Flexibility สูง	Application ที่ทำงานเป็น Event-Driven

จากตารางจะเห็นว่า Serverless Function เหมาะสำหรับงานที่ต้องการความรวดเร็วในการพัฒนา, Auto Scaling และประหยัดค่าใช้จ่าย แต่ถ้า Application ของเราต้องการ Resource เยอะๆ หรือต้องการ Control Infrastructure เอง VM หรือ Container อาจจะเป็นทางเลือกที่ดีกว่า

🎬 วิดีโอแนะนำ

ดูวิดีโอเพิ่มเติมเกี่ยวกับServerless Lambda Cloud Functi:

Best Practices / เคล็ดลับจากประสบการณ์

เอาล่ะน้องๆ มาถึงตรงนี้ ผมว่าเราพอจะเห็นภาพรวมของ Lambda กับ Cloud Functions กันแล้วเนอะ ทีนี้มาดู Best Practices หรือเคล็ดลับที่ผมอยากแชร์จากประสบการณ์ตรงบ้างดีกว่า สมัยผมทำร้านเน็ตนี่เจออะไรมาเยอะ (หัวเราะ) เรื่องพวกนี้สำคัญนะ เพราะมันช่วยให้เราเขียนโค้ดได้ดีขึ้น ประหยัดทรัพยากร และแก้ปัญหาได้ง่ายขึ้นเยอะเลย

จำไว้เสมอว่า Serverless มันไม่ใช่ Silver Bullet นะ มันไม่ได้แก้ได้ทุกปัญหา ต้องเลือกใช้ให้ถูกงานด้วย

3-4 เทคนิคที่ใช้ได้จริง

1. Keep it Small, Keep it Simple

ข้อแรกเลยคือ พยายามทำให้ Function ของเรามัน "เล็ก" และ "ง่าย" ที่สุดเท่าที่จะเป็นไปได้ สมัยผมเขียน Perl (ใช่ครับ Perl! ตอนนั้นมันฮิต) ผมชอบเขียน Module ใหญ่ๆ ทำทุกอย่าง แต่พอมา Serverless นี่ไม่ใช่เลยนะ

Function ที่เล็กๆ มัน Debug ง่าย, Test ง่าย, Deploy ง่าย และที่สำคัญคือมัน Scale ได้ดีกว่าด้วย ลองคิดดูว่าถ้า Function ของเรามันต้องทำงาน 10 อย่างพร้อมกัน มันก็จะใช้เวลานานกว่า Function ที่ทำแค่ 1 อย่าง 10 ครั้ง ถูกไหม?

# Bad (ทำหลายอย่างใน function เดียว)
def my_function(event, context):
  data = process_data(event['data'])
  validated_data = validate_data(data)
  saved_data = save_data(validated_data)
  return saved_data

# Good (แยกเป็น function ย่อยๆ)
def process_data(data):
  # ...
  return processed_data

def validate_data(data):
  # ...
  return validated_data

def save_data(data):
  # ...
  return saved_data

def my_function(event, context):
  data = process_data(event['data'])
  validated_data = validate_data(data)
  saved_data = save_data(validated_data)
  return saved_data

2. Optimize Cold Starts

Cold Starts คือช่วงเวลาที่ Function ของเรามันต้อง "บูต" ขึ้นมาใหม่หลังจากที่ไม่ได้ถูกเรียกใช้มานาน ช่วงเวลานี้มันจะทำให้ Response Time ของเราช้าลง ซึ่ง User Experience ก็จะแย่ไปด้วย

วิธีแก้ก็มีหลายอย่าง เช่น Keep-Alive connections, ใช้ Container Images ที่เบาๆ, หรือ Pre-Warming (อันนี้ Cloud Provider ส่วนใหญ่มีให้)

สมัยผมทำร้านเน็ต ผมเคยเจอเคสที่ Server มัน Cold Start บ่อยๆ เพราะ RAM ไม่พอ วิธีแก้ตอนนั้นคือเพิ่ม RAM เข้าไป แต่วิธีแก้ปัญหา Cold Start ใน Serverless คือการ Optimize โค้ดเราให้มันทำงานได้เร็วขึ้นตั้งแต่แรก

3. Handle Errors Gracefully

เรื่อง Error Handling นี่สำคัญมากๆ ไม่ว่าเราจะเขียนโค้ดแบบไหนก็ตาม Serverless ก็เหมือนกัน เราต้องเตรียมพร้อมรับมือกับ Error ที่อาจจะเกิดขึ้นได้เสมอ

ลองคิดดูว่าถ้า Function ของเรามัน Fail กลางทาง แล้วข้อมูลมันหายไปครึ่งๆ กลางๆ จะเกิดอะไรขึ้น? เราต้องมีระบบ Retry, Logging, Alerting ที่ดี เพื่อให้เราสามารถ Debug และแก้ไขปัญหาได้ทันท่วงที

import logging

def my_function(event, context):
  try:
    # ทำงานอะไรบางอย่างที่อาจจะ error
    result = do_something(event['data'])
    return result
  except Exception as e:
    logging.error(f"Error: {e}")
    # ส่ง Error ไปที่ระบบ Logging หรือ Alerting
    raise # สำคัญ: ต้อง raise exception ขึ้นไป เพื่อให้ระบบรู้ว่ามี error

4. Monitor Everything

Serverless มันดีตรงที่เราไม่ต้องดูแล Server เอง แต่เราก็ยังต้อง Monitor Function ของเราอยู่ดี เราต้องรู้ว่า Function ของเรามันทำงานได้ดีแค่ไหน, มี Error เกิดขึ้นบ่อยแค่ไหน, ใช้ทรัพยากรเยอะแค่ไหน

Cloud Provider ส่วนใหญ่จะมี Tools ให้เรา Monitor อยู่แล้ว เช่น CloudWatch, Cloud Monitoring, หรือเราจะใช้ Third-Party Tools ก็ได้ SiamCafe Blog ก็มีบทความเกี่ยวกับ Monitoring อยู่ ลองไปอ่านดูนะ

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

Lambda กับ Cloud Functions อันไหนดีกว่ากัน?

อันนี้ตอบยากนะ มันขึ้นอยู่กับว่าเราใช้ Cloud Provider อะไรอยู่ ถ้าเราใช้ AWS ก็ใช้ Lambda ไป ถ้าใช้ Google Cloud ก็ใช้ Cloud Functions แต่โดยรวมแล้ว Concept มันคล้ายๆ กันแหละ

Serverless เหมาะกับงานแบบไหน?

เหมาะกับงานที่เป็น Event-Driven, งานที่ไม่ต้องการ Resources ตลอดเวลา, งานที่ Scale ได้ง่ายๆ เช่น API, Background Processing, Chatbot

Serverless แพงไหม?

ถ้าเรา Optimize โค้ดดีๆ มันจะถูกกว่าการรัน Server เอง แต่ถ้าเราเขียนโค้ดไม่ดี มันก็อาจจะแพงกว่าได้เหมือนกัน ต้อง Monitor การใช้งานให้ดีๆ

Security ของ Serverless เป็นยังไง?

Security เป็นเรื่องสำคัญมากๆ เราต้องดูแลเรื่อง Permissions, Authentication, Authorization ให้ดี ถ้าพลาดขึ้นมาโดน Hack ได้ง่ายๆ เลย iCafeForex ก็เคยโดน Hack สมัยก่อน เพราะ Security ไม่ดี (หัวเราะ)

สรุป

Serverless เป็น Technology ที่น่าสนใจมากๆ มันช่วยให้เราพัฒนา Application ได้เร็วขึ้น, ประหยัดทรัพยากรมากขึ้น, และ Scale ได้ง่ายขึ้น แต่เราก็ต้องเรียนรู้ Best Practices และเข้าใจข้อจำกัดของมันด้วย

หวังว่าบทความนี้จะเป็นประโยชน์กับน้องๆ นะ ถ้ามีคำถามอะไรเพิ่มเติม ถามมาได้เลย!