Serverless คืออะไร AWS Lambda vs Cloud Functions

บทนำ: Serverless คืออะไร ทำไมถึงต้องรู้จัก?

พื้นฐานความรู้เกี่ยวกับ Serverless Computing

Function as a Service (FaaS): หัวใจหลักของ Serverless

Event-Driven Architecture: จุดเริ่มต้นของการทำงาน

ข้อดีและข้อเสียของ Serverless ที่ต้องรู้

🎬 YouTube @icafefx

วิธีติดตั้งและใช้งาน AWS Lambda และ Cloud Functions

ตารางเปรียบเทียบ AWS Lambda และ Google Cloud Functions

ตัวอย่างการสร้างฟังก์ชันบน AWS Lambda ด้วย Python

def lambda_handler(event, context):
    return {
        'statusCode': 200,
        'body': 'Hello from Lambda!'
    }

ตัวอย่างการสร้างฟังก์ชันบน Google Cloud Functions ด้วย Node.js

gcloud functions deploy hello-world \
--runtime nodejs16 \
--trigger-http \
--allow-unauthenticated

exports.helloWorld = (req, res) => {
  res.send('Hello from Cloud Functions!');
};

"Serverless computing ไม่ใช่ silver bullet ที่จะแก้ปัญหาทุกอย่างได้ แต่ถ้าเราเข้าใจข้อดีข้อเสีย และเลือกใช้ให้เหมาะสม มันจะเป็นเครื่องมือที่ทรงพลังในการพัฒนาซอฟต์แวร์อย่างแน่นอน"

เทคนิคขั้นสูง / Configuration

การจัดการ Dependencies อย่างมีประสิทธิภาพ

การจัดการ dependencies หรือพวก library ต่างๆ ที่เราใช้ใน function ของเราถือว่าเป็นเรื่องสำคัญมากๆ เลยนะ โดยเฉพาะอย่างยิ่งในโลกของ serverless ที่ขนาดของ deployment package มีผลต่อ cold start time หรือเวลาที่ใช้ในการเริ่ม function เป็นครั้งแรกหลังจากที่ไม่ได้ถูกเรียกใช้งานนานๆ ใครเคยเจอปัญหา cold start ช้าๆ บ้างยกมือขึ้น!

เทคนิคที่ผมอยากแนะนำก็คือการใช้ Lambda Layers ใน AWS Lambda หรือ Function Layers ใน Google Cloud Functions ซึ่งมันคือการที่เราแยก dependencies ออกจากตัว code ของ function หลัก แล้วเอาไปเก็บไว้ใน layer แทน วิธีนี้จะช่วยลดขนาดของ deployment package ของ function ลงได้อย่างมาก เพราะ dependencies จะถูกโหลดมาแค่ครั้งเดียวตอนที่ layer ถูกสร้างขึ้นมา และสามารถนำไปใช้กับหลายๆ function ได้ด้วย ลองคิดดูนะว่าถ้าเรามี 10 function ที่ใช้ library ตัวเดียวกัน ถ้าเราใส่ library นั้นไว้ในทุก function ขนาดของ package ก็จะใหญ่ขึ้น 10 เท่า แต่ถ้าเราใช้ layer ขนาดก็จะเท่าเดิม!

นอกจากนี้ การใช้ package manager อย่าง npm หรือ pip ก็เป็นสิ่งสำคัญ ควรระบุ version ของ dependencies ให้ชัดเจน เพื่อป้องกันปัญหา dependency conflict ที่อาจเกิดขึ้นได้ในอนาคต และควรใช้ tools ที่ช่วย optimize ขนาดของ package เช่น webpack สำหรับ JavaScript หรือ virtualenv สำหรับ Python เพื่อลดขนาดของ dependencies ที่ไม่จำเป็นออกไป ผมเคยเซ็ตอัพโปรเจกต์ serverless โดยที่ไม่ได้ optimize dependencies เลย ผลก็คือ cold start time นานมาก แถม deployment ก็ช้าอีกต่างหาก พอมา optimize แล้วทุกอย่างดีขึ้นเยอะเลย

# ตัวอย่างการกำหนด Lambda Layer ใน AWS SAM template
Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      FunctionName: MyAwesomeFunction
      Handler: index.handler
      Runtime: nodejs16.x
      CodeUri: ./src
      Layers:
        - !Ref MyLayer

  MyLayer:
    Type: AWS::Serverless::LayerVersion
    Properties:
      LayerName: MyDependencyLayer
      ContentUri: ./layers/dependencies
      CompatibleRuntimes:
        - nodejs16.x

การตั้งค่า Environment Variables และ Secrets Management

Environment variables คือตัวแปรที่เราใช้ในการกำหนดค่าต่างๆ ให้กับ function ของเรา เช่น database connection string, API keys หรือ configuration อื่นๆ ที่อาจมีการเปลี่ยนแปลงไปตาม environment (เช่น development, staging, production) การใช้ environment variables จะช่วยให้เราไม่ต้อง hardcode ค่าเหล่านี้ลงไปใน code โดยตรง ซึ่งเป็น best practice ที่ควรทำตามอย่างยิ่ง

แต่สิ่งที่สำคัญกว่านั้นก็คือการจัดการ secrets หรือข้อมูลสำคัญที่ต้องเก็บรักษาเป็นความลับ เช่น password หรือ private key การเก็บ secrets ไว้ใน environment variables โดยตรงอาจไม่ปลอดภัยเท่าที่ควร เพราะอาจถูกเข้าถึงได้ง่าย ดังนั้นเราควรใช้ tools ที่ช่วยในการจัดการ secrets อย่าง AWS Secrets Manager หรือ Google Cloud Secret Manager ซึ่งจะช่วยให้เราสามารถเก็บ secrets ได้อย่างปลอดภัยและสามารถเข้าถึงได้จาก function ของเราโดยไม่ต้องเปิดเผยค่าจริงๆ ออกมา

ผมแนะนำว่าอย่าประมาทเรื่อง security นะครับ! สมัยก่อนผมก็เคยพลาดเก็บ API key ไว้ใน environment variable โดยตรง แล้วโดนคนอื่นเอาไปใช้ซะงั้น เสียหายเยอะเลย หลังจากนั้นมาก็เลยระวังเรื่องนี้เป็นพิเศษ

{
  "FunctionName": "MyFunction",
  "Environment": {
    "Variables": {
      "DATABASE_URL": "jdbc:mysql://...",
      "API_KEY": "xxxxxxxxxxxxxxxx"
    }
  }
}

การ Monitor และ Logging อย่างละเอียด

การ monitor และ logging ถือเป็นหัวใจสำคัญของการทำ serverless เลยก็ว่าได้ เพราะเราไม่สามารถเข้าไป debug function ที่กำลังทำงานอยู่บน server ได้โดยตรงเหมือนกับที่เราทำใน environment แบบเดิมๆ ดังนั้นเราจึงต้องพึ่งพา logs และ metrics ต่างๆ เพื่อช่วยในการ identify และแก้ไขปัญหาที่อาจเกิดขึ้น

AWS Lambda มี CloudWatch Logs ที่สามารถเก็บ logs ที่ function ของเรา generate ออกมาได้ ส่วน Google Cloud Functions ก็มี Cloud Logging ที่ทำหน้าที่คล้ายกัน เราสามารถใช้ tools เหล่านี้ในการ query และ analyze logs เพื่อหา errors, warnings หรือ performance bottlenecks ต่างๆ ได้ นอกจากนี้ เรายังสามารถใช้ metrics ต่างๆ เช่น invocation count, error rate หรือ duration เพื่อ monitor health และ performance ของ function ของเราได้อีกด้วย

ผมแนะนำให้ใส่ logs ให้ละเอียดที่สุดเท่าที่จะทำได้นะครับ โดยเฉพาะอย่างยิ่งในส่วนที่เกี่ยวข้องกับ business logic หรือ decision making process ต่างๆ เพราะมันจะช่วยให้เราเข้าใจว่า function ของเราทำงานอย่างไร และเกิดอะไรขึ้นเมื่อมีปัญหาเกิดขึ้น

import logging

logger = logging.getLogger()
logger.setLevel(logging.INFO)

def lambda_handler(event, context):
    logger.info("Function started")
    try:
        # Do something important
        result = do_something(event)
        logger.info(f"Result: {result}")
        return {
            'statusCode': 200,
            'body': 'Success!'
        }
    except Exception as e:
        logger.error(f"Error: {e}")
        return {
            'statusCode': 500,
            'body': 'Error!'
        }
    finally:
        logger.info("Function finished")

เปรียบเทียบ

ตารางเปรียบเทียบคุณสมบัติ

ตารางเปรียบเทียบ Benchmark (ตัวอย่าง)

ตาราง benchmark ด้านล่างนี้เป็นเพียงตัวอย่างและอาจมีการเปลี่ยนแปลงไปตาม workload และ configuration ที่แตกต่างกัน การทำ benchmark ด้วย workload จริงของตัวเองจึงเป็นสิ่งที่สำคัญที่สุด

ข้อควรระวัง Troubleshooting

คำเตือน: Serverless ไม่ใช่ Silver Bullet! ถึงแม้ว่า serverless จะมีข้อดีมากมาย แต่ก็ไม่ได้เหมาะกับทุก workload เสมอไป ควรพิจารณาข้อดีข้อเสียให้รอบคอบก่อนตัดสินใจนำไปใช้

รายการข้อควรระวังและสิ่งที่ต้องระวังในการพัฒนา serverless application:

• Cold Starts: อย่างที่บอกไปแล้วว่า cold starts เป็นปัญหาที่ต้องเจอแน่นอน ควร optimize ขนาดของ package, dependencies และเลือก runtime ที่เหมาะสมเพื่อลด cold start time ให้เหลือน้อยที่สุด
• Statelessness: Function ทุกตัวควรเป็น stateless นั่นหมายความว่าไม่ควรเก็บ state หรือข้อมูลใดๆ ไว้ใน function เอง ควรใช้ external storage เช่น database หรือ cache แทน
• Concurrency Limits: AWS Lambda และ Google Cloud Functions มี concurrency limits ที่จำกัดจำนวน function ที่สามารถทำงานพร้อมกันได้ ถ้า function ของเราถูกเรียกใช้งานพร้อมกันเยอะๆ อาจทำให้เกิด throttling หรือ request ถูกปฏิเสธได้
• Timeouts: Function แต่ละตัวมี execution time limit ที่จำกัด ถ้า function ของเราใช้เวลานานเกินไปก็จะถูก terminate ทำให้ request fail ได้
• Debugging: การ debug serverless application อาจเป็นเรื่องท้าทาย เพราะเราไม่สามารถเข้าไป debug function ที่กำลังทำงานอยู่บน server ได้โดยตรง ควรใช้ logging และ monitoring tools ให้เป็นประโยชน์
• Security: Security เป็นเรื่องที่ต้องให้ความสำคัญเป็นพิเศษ ควรระมัดระวังเรื่อง IAM permissions, secrets management และ vulnerability ต่างๆ ที่อาจเกิดขึ้นได้
• Vendor Lock-in: การใช้ serverless อาจทำให้เราติดอยู่กับ vendor รายใดรายหนึ่งได้ ควรออกแบบ application ให้มีความยืดหยุ่นและสามารถย้ายไปใช้ platform อื่นได้ง่าย

ตัวอย่างจากประสบการณ์ 20 ปี

จากประสบการณ์ 20 ปีที่คลุกคลีอยู่ในวงการ IT ผมได้มีโอกาสลองใช้ serverless technology ในหลากหลายสถานการณ์ ขอยกตัวอย่างสถานการณ์ที่ผมเคยเจอมาเล่าให้ฟังนะครับ

สถานการณ์ที่ 1: Real-time Image Processing ผมเคยเซ็ตอัพระบบ real-time image processing โดยใช้ AWS Lambda เพื่อ resize และ optimize รูปภาพที่ถูกอัพโหลดขึ้น S3 bucket เมื่อมีรูปภาพใหม่ถูกอัพโหลดขึ้น S3 bucket trigger จะถูกส่งไปยัง Lambda function ซึ่งจะทำการ resize และ optimize รูปภาพนั้นๆ แล้วบันทึกลง S3 bucket อีก bucket หนึ่ง ระบบนี้ช่วยลด load ของ web server และทำให้การแสดงผลรูปภาพบนเว็บไซต์เร็วขึ้นอย่างมาก

สถานการณ์ที่ 2: Chatbot Development ผมเคยพัฒนา chatbot โดยใช้ Google Cloud Functions ร่วมกับ Dialogflow chatbot framework เมื่อผู้ใช้ส่งข้อความเข้ามา chatbot จะส่งข้อความนั้นไปยัง Cloud Function ซึ่งจะทำการประมวลผลและตอบกลับผู้ใช้ ระบบนี้ช่วยให้เราสามารถสร้าง chatbot ที่มีความซับซ้อนได้โดยไม่ต้องกังวลเรื่อง infrastructure

สถานการณ์ที่ 3: Event-Driven Data Processing ผมเคยสร้างระบบ event-driven data processing โดยใช้ AWS Lambda และ Kinesis เมื่อมี event ใหม่เกิดขึ้น (เช่น user login, order creation) event นั้นจะถูกส่งไปยัง Kinesis stream แล้ว Lambda function จะ consume event จาก stream และทำการประมวลผลข้อมูลนั้นๆ ระบบนี้ช่วยให้เราสามารถประมวลผลข้อมูลจำนวนมากได้อย่างรวดเร็วและมีประสิทธิภาพ

จากประสบการณ์ของผม Serverless ถือว่าเป็น technology ที่มีประโยชน์มากๆ แต่ก็ต้องระวังเรื่องต่างๆ ที่กล่าวมาข้างต้นด้วย ถ้าเราเข้าใจข้อดีข้อเสียและรู้วิธีใช้งานอย่างถูกต้อง Serverless จะช่วยให้เราสร้าง application ที่มีความ scalable, cost-effective และ maintainable ได้อย่างแน่นอน

เครื่องมือแนะนำสำหรับการพัฒนา Serverless

Serverless Framework

service: my-serverless-app

provider:
  name: aws
  runtime: nodejs16.x
  region: ap-southeast-1
  iamRoleStatements:
    - Effect: Allow
      Action:
        - dynamodb:GetItem
        - dynamodb:PutItem
      Resource: "arn:aws:dynamodb:ap-southeast-1:YOUR_ACCOUNT_ID:table/MyTable"

functions:
  myFunction:
    handler: handler.myFunction
    events:
      - http:
          path: /hello
          method: get

AWS SAM (Serverless Application Model)

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: handler.myFunction
      Runtime: nodejs16.x
      CodeUri: ./src
      Events:
        HelloWorld:
          Type: Api
          Properties:
            Path: /hello
            Method: GET

Terraform

resource "aws_lambda_function" "example" {
  function_name = "my-lambda-function"
  filename      = "lambda_function_payload.zip"
  handler       = "handler.myFunction"
  runtime       = "nodejs16.x"
  role          = aws_iam_role.lambda_role.arn

  source_code_hash = filebase64sha256("lambda_function_payload.zip")
}

resource "aws_iam_role" "lambda_role" {
  name = "lambda-execution-role"

  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Action = "sts:AssumeRole"
        Principal = {
          Service = "lambda.amazonaws.com"
        }
        Effect = "Allow"
        Sid    = ""
      },
    ]
  })
}

Case Study: ประสบการณ์จริงกับการใช้ Serverless

FAQ: คำถามที่พบบ่อยเกี่ยวกับ Serverless

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

Cold start คืออะไร และจะแก้ไขได้อย่างไร?

Security ใน Serverless ต้องดูแลอะไรเป็นพิเศษบ้าง?

Monitoring และ debugging ใน Serverless ทำอย่างไร?

Serverless จะเข้ามาแทนที่ container หรือ VMs ได้ทั้งหมดไหม?

ข้อจำกัดของ Serverless คืออะไร?

สรุป

Serverless คืออะไร AWS Lambda vs Cloud Functions

AWS Lambda

Google Cloud Functions

AWS Lambda vs Cloud Functions: เปรียบเทียบ

Tips จากประสบการณ์ 20 ปี

1. เลือกภาษาโปรแกรมที่ถนัด

2. เข้าใจเรื่อง Cold Start Time

3. Monitor และ Logging อย่างสม่ำเสมอ

4. Security ต้องมาเป็นอันดับหนึ่ง

5. Design ให้ Function ทำงานเล็กๆ

6. Test ก่อน Deploy ทุกครั้ง

7. Infrastructure as Code (IaC) ช่วยชีวิต

8. Cost Optimization อย่างต่อเนื่อง

FAQ เพิ่ม 4 ข้อ

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

AWS Lambda Layers คืออะไร?

aws lambda publish-layer-version --layer-name my-layer --zip-file fileb://my-layer.zip --compatible-runtimes python3.9

Cloud Functions Trigger Types มีอะไรบ้าง?

ถ้าอยาก Migrate จาก Monolith เป็น Serverless ควรเริ่มตรงไหน?