Edge Computing คืออะไร? สอนสร้าง Edge Application ด้วย Cloudflare Workers 2026

ในยุคที่ผู้ใช้คาดหวังว่าเว็บไซต์จะโหลดเร็วภายในไม่กี่มิลลิวินาที การส่ง request ข้ามทวีปไปยัง origin server แล้วรอ response กลับมาเริ่มไม่เพียงพออีกต่อไป Edge Computing คือคำตอบที่ย้ายการประมวลผลไปอยู่ใกล้ผู้ใช้มากที่สุด ณ จุดเดียวกับ CDN ทำให้ latency ลดลงอย่างมหาศาล

บทความนี้จะอธิบาย Edge Computing ตั้งแต่แนวคิดพื้นฐาน เจาะลึก Cloudflare Workers ซึ่งเป็น platform ที่ได้รับความนิยมสูงสุดในปี 2026 ครอบคลุมทุก product ตั้งแต่ KV, Durable Objects, D1, R2 จนถึงการสร้าง full application ที่ edge พร้อมเปรียบเทียบกับ Vercel Edge Functions, AWS Lambda@Edge และ Deno Deploy อย่างละเอียด

Edge Computing คืออะไร?

Edge Computing คือแนวคิดที่ย้ายการประมวลผลจาก centralized server (data center ที่อยู่ไกล) ไปยังจุดที่อยู่ใกล้ผู้ใช้มากที่สุด ซึ่งก็คือ edge node ของ CDN network ที่กระจายอยู่ทั่วโลก

แนวคิดหลัก

ลองนึกภาพว่าคุณมี API server อยู่ที่ US-East (Virginia) แต่ผู้ใช้อยู่ที่กรุงเทพ ทุก request ต้องเดินทางไปกลับข้ามมหาสมุทรแปซิฟิก ใช้เวลาอย่างน้อย 200-300ms เฉพาะค่า network round trip ไม่นับรวม processing time แต่ถ้าคุณ deploy code ไว้ที่ edge node ในสิงคโปร์หรือกรุงเทพเลย latency จะเหลือแค่ 5-20ms

Edge vs Cloud vs On-Premise

Cloudflare Workers — V8 Isolates ไม่ใช่ Containers

สิ่งที่ทำให้ Cloudflare Workers ต่างจาก serverless platform อื่นคือเทคโนโลยีที่ใช้ ในขณะที่ AWS Lambda ใช้ container (Firecracker microVM) ซึ่งมี cold start 100-500ms Cloudflare Workers ใช้ V8 Isolates ซึ่งเป็น JavaScript engine ตัวเดียวกับ Chrome browser ทำให้

• Cold start แทบไม่มี: เริ่มทำงานภายใน 0-5ms เทียบกับ Lambda ที่ 100-500ms
• Memory footprint ต่ำมาก: แต่ละ isolate ใช้ memory น้อยมาก ทำให้รันได้หลายพัน isolate พร้อมกัน
• Security: แต่ละ request ทำงานใน isolate ที่แยกจากกัน ไม่สามารถเข้าถึงข้อมูลของ request อื่นได้
• Global deployment: Deploy ครั้งเดียว ทำงานใน 300+ locations ทั่วโลกทันที

Workers Runtime — Service Workers API

Cloudflare Workers ใช้ API ที่คล้ายกับ Service Workers ใน browser ทำให้นักพัฒนาที่เคยเขียน JavaScript/TypeScript สามารถเริ่มได้ทันที

// Basic Worker — ตอบ Hello World
export default {
  async fetch(request, env, ctx) {
    return new Response("สวัสดีจาก Edge!", {
      headers: { "content-type": "text/plain; charset=utf-8" },
    });
  },
};

// Worker กับ URL routing
export default {
  async fetch(request, env, ctx) {
    const url = new URL(request.url);

    switch (url.pathname) {
      case "/":
        return new Response("Home");
      case "/api/health":
        return Response.json({ status: "ok", edge: request.cf?.colo });
      case "/api/geo":
        return Response.json({
          country: request.cf?.country,
          city: request.cf?.city,
          timezone: request.cf?.timezone,
          colo: request.cf?.colo,
        });
      default:
        return new Response("Not Found", { status: 404 });
    }
  },
};

Cloudflare Storage Solutions

KV (Key-Value Storage)

KV เป็น eventually consistent key-value store ที่กระจายอยู่ทั่วโลก เหมาะสำหรับข้อมูลที่อ่านบ่อยแต่เขียนไม่บ่อย เช่น configuration, feature flags, cached data

// wrangler.toml
// [[kv_namespaces]]
// binding = "MY_KV"
// id = "xxxxxxxxxxxxx"

export default {
  async fetch(request, env) {
    const url = new URL(request.url);

    if (request.method === "GET") {
      // อ่านค่าจาก KV
      const value = await env.MY_KV.get("user:123");
      if (!value) return new Response("Not Found", { status: 404 });
      return Response.json(JSON.parse(value));
    }

    if (request.method === "PUT") {
      // เขียนค่าลง KV (TTL 1 ชั่วโมง)
      const body = await request.json();
      await env.MY_KV.put("user:123", JSON.stringify(body), {
        expirationTtl: 3600,
      });
      return Response.json({ status: "saved" });
    }
  },
};

Durable Objects — Consistency ที่ Edge

Durable Objects แก้ปัญหาที่ KV ทำไม่ได้ คือ strong consistency แต่ละ Durable Object เป็น singleton ที่มี state ของตัวเอง เหมาะสำหรับ real-time collaboration, rate limiting, WebSocket rooms

// Durable Object class
export class ChatRoom {
  constructor(state, env) {
    this.state = state;
    this.sessions = [];
  }

  async fetch(request) {
    // WebSocket upgrade
    if (request.headers.get("Upgrade") === "websocket") {
      const pair = new WebSocketPair();
      const [client, server] = Object.values(pair);

      server.accept();
      this.sessions.push(server);

      server.addEventListener("message", (event) => {
        // Broadcast to all sessions
        for (const session of this.sessions) {
          if (session !== server) {
            session.send(event.data);
          }
        }
      });

      return new Response(null, { status: 101, webSocket: client });
    }

    return new Response("Expected WebSocket", { status: 400 });
  }
}

D1 — SQLite ที่ Edge

D1 คือ SQLite database ที่ทำงานบน edge network ของ Cloudflare ทำให้คุณมี relational database ที่ latency ต่ำมาก โดยไม่ต้อง provision server

// สร้าง D1 database
// wrangler d1 create my-db

// Migration
// wrangler d1 execute my-db --file=./schema.sql

// schema.sql
// CREATE TABLE users (
//   id INTEGER PRIMARY KEY AUTOINCREMENT,
//   name TEXT NOT NULL,
//   email TEXT UNIQUE NOT NULL,
//   created_at DATETIME DEFAULT CURRENT_TIMESTAMP
// );

export default {
  async fetch(request, env) {
    const url = new URL(request.url);

    if (url.pathname === "/api/users" && request.method === "GET") {
      const { results } = await env.DB.prepare(
        "SELECT * FROM users ORDER BY created_at DESC LIMIT 50"
      ).all();
      return Response.json(results);
    }

    if (url.pathname === "/api/users" && request.method === "POST") {
      const { name, email } = await request.json();
      const result = await env.DB.prepare(
        "INSERT INTO users (name, email) VALUES (?, ?)"
      ).bind(name, email).run();
      return Response.json({ id: result.meta.last_row_id }, { status: 201 });
    }

    return new Response("Not Found", { status: 404 });
  },
};

R2 — S3-Compatible Object Storage

R2 เป็น object storage ที่เข้ากันได้กับ S3 API แต่ไม่มีค่า egress (ค่าโอนข้อมูลออก) ทำให้ประหยัดมากสำหรับ application ที่ serve static files หรือ user uploads

export default {
  async fetch(request, env) {
    const url = new URL(request.url);
    const key = url.pathname.slice(1); // ตัด / ออก

    if (request.method === "PUT") {
      await env.MY_BUCKET.put(key, request.body, {
        httpMetadata: { contentType: request.headers.get("content-type") },
      });
      return Response.json({ key, status: "uploaded" });
    }

    if (request.method === "GET") {
      const object = await env.MY_BUCKET.get(key);
      if (!object) return new Response("Not Found", { status: 404 });
      return new Response(object.body, {
        headers: { "content-type": object.httpMetadata?.contentType || "application/octet-stream" },
      });
    }
  },
};

Queues และ AI Workers

Queues ช่วยให้คุณส่งงานจาก Worker หนึ่งไปยังอีก Worker หนึ่งแบบ asynchronous เหมาะสำหรับงานที่ไม่ต้องตอบ user ทันที เช่น ส่ง email, process image, update analytics

// Producer Worker
export default {
  async fetch(request, env) {
    await env.MY_QUEUE.send({
      type: "email",
      to: "user@example.com",
      subject: "Welcome!",
    });
    return Response.json({ status: "queued" });
  },
};

// Consumer Worker
export default {
  async queue(batch, env) {
    for (const message of batch.messages) {
      console.log("Processing:", message.body);
      // process each message
      message.ack();
    }
  },
};

AI Workers (Workers AI) ให้คุณรัน AI model ที่ edge ได้โดยตรง รองรับทั้ง text generation, image generation, embeddings, speech-to-text โดยใช้ GPU ที่ Cloudflare มี

export default {
  async fetch(request, env) {
    const { prompt } = await request.json();
    const response = await env.AI.run("@cf/meta/llama-3.1-8b-instruct", {
      messages: [{ role: "user", content: prompt }],
    });
    return Response.json(response);
  },
};

Wrangler CLI — เครื่องมือจัดการ Workers

# ติดตั้ง
npm install -g wrangler

# Login
wrangler login

# สร้างโปรเจกต์ใหม่
wrangler init my-worker
cd my-worker

# Development (local)
wrangler dev

# Deploy
wrangler deploy

# ดู Logs
wrangler tail

# จัดการ KV
wrangler kv namespace create MY_KV
wrangler kv key put --binding MY_KV "key" "value"

# จัดการ D1
wrangler d1 create my-db
wrangler d1 execute my-db --command "SELECT * FROM users"

# จัดการ R2
wrangler r2 bucket create my-bucket

Workers กับ Hono Framework

Hono เป็น web framework ที่ออกแบบมาสำหรับ edge computing โดยเฉพาะ เร็ว เบา และทำงานได้ทุก runtime (Cloudflare Workers, Deno, Bun, Node.js) การใช้ Hono กับ Workers ทำให้เขียน API ได้เร็วและสะอาดมากขึ้น

import { Hono } from "hono";
import { cors } from "hono/cors";
import { jwt } from "hono/jwt";
import { logger } from "hono/logger";

const app = new Hono();

// Middleware
app.use("*", logger());
app.use("/api/*", cors());
app.use("/api/protected/*", jwt({ secret: "my-secret" }));

// Routes
app.get("/", (c) => c.text("Hono on Cloudflare Workers!"));

app.get("/api/users", async (c) => {
  const { results } = await c.env.DB.prepare("SELECT * FROM users").all();
  return c.json(results);
});

app.post("/api/users", async (c) => {
  const { name, email } = await c.req.json();
  const result = await c.env.DB.prepare(
    "INSERT INTO users (name, email) VALUES (?, ?)"
  ).bind(name, email).run();
  return c.json({ id: result.meta.last_row_id }, 201);
});

app.get("/api/users/:id", async (c) => {
  const id = c.req.param("id");
  const user = await c.env.DB.prepare("SELECT * FROM users WHERE id = ?")
    .bind(id).first();
  if (!user) return c.json({ error: "Not found" }, 404);
  return c.json(user);
});

app.delete("/api/users/:id", async (c) => {
  const id = c.req.param("id");
  await c.env.DB.prepare("DELETE FROM users WHERE id = ?").bind(id).run();
  return c.json({ status: "deleted" });
});

export default app;

Workers กับ Remix — Full-Stack ที่ Edge

Cloudflare Pages รองรับ Remix ทำให้สร้าง full-stack application ที่ทำงานทั้ง server-side rendering และ API ที่ edge ได้ทั้งหมด

# สร้างโปรเจกต์ Remix บน Cloudflare
npx create-remix@latest --template remix-run/remix/templates/cloudflare

# โครงสร้าง
my-remix-app/
├── app/
│   ├── routes/
│   │   ├── _index.tsx
│   │   └── api.users.tsx
│   └── root.tsx
├── functions/
├── public/
└── wrangler.toml

// app/routes/api.users.tsx
import type { LoaderFunctionArgs } from "@remix-run/cloudflare";

export async function loader({ context }: LoaderFunctionArgs) {
  const db = context.cloudflare.env.DB;
  const { results } = await db.prepare("SELECT * FROM users").all();
  return Response.json(results);
}

Edge Middleware Patterns

A/B Testing ที่ Edge

export default {
  async fetch(request, env) {
    const url = new URL(request.url);

    // กำหนด variant จาก cookie หรือ random
    let variant = getCookie(request, "ab-variant");
    if (!variant) {
      variant = Math.random() < 0.5 ? "A" : "B";
    }

    // Rewrite URL ตาม variant
    if (variant === "B") {
      url.pathname = "/new-landing" + url.pathname;
    }

    const response = await fetch(url.toString(), request);
    const newResponse = new Response(response.body, response);
    newResponse.headers.set("Set-Cookie", `ab-variant=${variant}; Path=/; Max-Age=86400`);
    return newResponse;
  },
};

Rate Limiting ที่ Edge

export default {
  async fetch(request, env) {
    const ip = request.headers.get("CF-Connecting-IP");
    const key = `rate:${ip}`;

    // ใช้ KV หรือ Durable Objects สำหรับ counter
    const current = parseInt(await env.RATE_KV.get(key) || "0");

    if (current >= 100) { // 100 requests per minute
      return new Response("Too Many Requests", { status: 429 });
    }

    await env.RATE_KV.put(key, String(current + 1), { expirationTtl: 60 });

    return fetch(request); // forward to origin
  },
};

Authentication ที่ Edge

export default {
  async fetch(request, env) {
    const authHeader = request.headers.get("Authorization");
    if (!authHeader?.startsWith("Bearer ")) {
      return new Response("Unauthorized", { status: 401 });
    }

    const token = authHeader.slice(7);
    try {
      const payload = await verifyJWT(token, env.JWT_SECRET);
      // เพิ่ม user info ใน header แล้ว forward
      const newRequest = new Request(request);
      newRequest.headers.set("X-User-ID", payload.sub);
      return fetch(newRequest);
    } catch {
      return new Response("Invalid Token", { status: 401 });
    }
  },
};

Image Transformation ที่ Edge

export default {
  async fetch(request, env) {
    const url = new URL(request.url);

    // /images/photo.jpg?w=400&h=300&fit=cover
    if (url.pathname.startsWith("/images/")) {
      const width = url.searchParams.get("w") || "800";
      const height = url.searchParams.get("h") || "600";
      const fit = url.searchParams.get("fit") || "cover";

      return fetch(request, {
        cf: {
          image: {
            width: parseInt(width),
            height: parseInt(height),
            fit: fit,
            quality: 80,
            format: "webp",
          },
        },
      });
    }

    return fetch(request);
  },
};

เปรียบเทียบ Edge Platforms 2026

Pricing เปรียบเทียบ

Edge Computing Use Cases ที่ใช้งานจริง

1. Personalization ที่ Edge

ปรับเปลี่ยนเนื้อหาตาม geolocation, device, หรือ user preferences โดยไม่ต้อง round trip ไป origin เหมาะสำหรับเว็บ e-commerce ที่ต้องแสดงราคา สกุลเงิน และ shipping options ตามประเทศ

2. Auth ที่ Edge

ตรวจสอบ JWT token หรือ API key ที่ edge ก่อนที่ request จะถึง origin ช่วยลด load ของ backend server และ block request ที่ไม่ถูกต้องได้ทันที นักพัฒนาที่ทำงานกับระบบการเงินออนไลน์จะได้ประโยชน์จาก pattern นี้มาก

3. A/B Testing

ตัดสินใจที่ edge ว่าจะแสดง variant ไหนให้ user เห็น ทำได้เร็วกว่าการ redirect ผ่าน origin และไม่กระทบ performance

4. Rate Limiting

จำกัดจำนวน request ต่อ IP หรือ API key ที่ edge ป้องกัน DDoS และ abuse ก่อนที่จะกระทบ backend

5. Image/Video Transformation

Resize, crop, convert format ของรูปภาพที่ edge ส่ง optimized image ให้ user ตาม device และ network conditions

6. Geo-routing และ Localization

Route request ไปยัง origin server ที่ใกล้ที่สุด หรือแสดงเนื้อหาภาษาที่ถูกต้องโดยอัตโนมัติ ระบบที่ต้องให้บริการผู้ใช้หลายประเทศ เช่น แพลตฟอร์มบริการออนไลน์จะได้ประโยชน์อย่างมาก

Limitations — ข้อจำกัดที่ต้องรู้

CPU Time

Workers Free plan จำกัดที่ 10ms CPU time ต่อ request ส่วน Paid plan ได้ 30 seconds ฟังดูน้อยแต่เนื่องจากไม่นับ I/O wait time (เช่น fetch, database query) จึงเพียงพอสำหรับงานส่วนใหญ่ แต่ไม่เหมาะกับ CPU-intensive tasks เช่น image processing จำนวนมากหรือ complex computation

Memory

Workers มี memory limit ที่ 128MB ซึ่งเพียงพอสำหรับ API ทั่วไป แต่ไม่เหมาะกับงานที่ต้องใช้ memory มาก เช่น processing ไฟล์ขนาดใหญ่

Runtime Compatibility

Workers ไม่ใช่ Node.js เต็มรูปแบบ ไม่รองรับ Node.js APIs บางตัว เช่น fs, child_process, net npm packages ที่พึ่งพา Node.js-specific APIs จะใช้ไม่ได้ แม้จะมี compatibility layer เพิ่มขึ้นเรื่อยๆ ก็ตาม

Database Limitations

D1 เป็น SQLite ดังนั้นมีข้อจำกัดเรื่อง concurrent writes KV เป็น eventually consistent ไม่เหมาะกับข้อมูลที่ต้อง consistent ทันที ต้องเลือกใช้ Durable Objects ถ้าต้องการ strong consistency

สร้าง Full Application ที่ Edge

มาลองสร้าง application จริงที่ทำงานทั้งหมดที่ edge ตั้งแต่ frontend จนถึง database

// wrangler.toml
name = "my-edge-app"
main = "src/index.ts"
compatibility_date = "2026-01-01"

[[d1_databases]]
binding = "DB"
database_name = "my-app-db"
database_id = "xxx"

[[kv_namespaces]]
binding = "CACHE"
id = "yyy"

[[r2_buckets]]
binding = "UPLOADS"
bucket_name = "my-uploads"

// src/index.ts — Full edge application with Hono
import { Hono } from "hono";
import { cors } from "hono/cors";
import { cache } from "hono/cache";
import { serveStatic } from "hono/cloudflare-workers";

type Bindings = {
  DB: D1Database;
  CACHE: KVNamespace;
  UPLOADS: R2Bucket;
};

const app = new Hono<{ Bindings: Bindings }>();

// Static files
app.use("/static/*", serveStatic({ root: "./" }));

// API with caching
app.get("/api/posts", async (c) => {
  // Check KV cache first
  const cached = await c.env.CACHE.get("posts:all");
  if (cached) return c.json(JSON.parse(cached));

  // Query D1
  const { results } = await c.env.DB.prepare(
    "SELECT * FROM posts ORDER BY created_at DESC LIMIT 20"
  ).all();

  // Cache for 5 minutes
  await c.env.CACHE.put("posts:all", JSON.stringify(results), {
    expirationTtl: 300,
  });

  return c.json(results);
});

// File upload to R2
app.post("/api/upload", async (c) => {
  const formData = await c.req.formData();
  const file = formData.get("file");

  if (!file || !(file instanceof File)) {
    return c.json({ error: "No file" }, 400);
  }

  const key = `uploads/${Date.now()}-${file.name}`;
  await c.env.UPLOADS.put(key, file.stream(), {
    httpMetadata: { contentType: file.type },
  });

  return c.json({ key, url: `/files/${key}` }, 201);
});

// Serve files from R2
app.get("/files/*", async (c) => {
  const key = c.req.path.slice(7); // remove /files/
  const object = await c.env.UPLOADS.get(key);
  if (!object) return c.json({ error: "Not found" }, 404);
  return new Response(object.body, {
    headers: { "content-type": object.httpMetadata?.contentType || "application/octet-stream" },
  });
});

export default app;

Cloudflare Pages — Static + Edge Functions

Cloudflare Pages เป็น platform สำหรับ deploy frontend framework (React, Vue, Svelte, Astro) พร้อม edge functions ที่ทำงานใน Workers runtime ทำให้ได้ full-stack application ที่ deploy ง่ายมาก

# Deploy static site + functions
npx wrangler pages deploy ./dist

# โครงสร้าง
my-site/
├── src/                 # Frontend code
├── functions/           # Edge functions (auto-mapped to routes)
│   └── api/
│       └── users.ts     # → /api/users
├── public/              # Static assets
└── wrangler.toml

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

Smart Caching Strategy

// Stale-While-Revalidate pattern ที่ edge
async function fetchWithSWR(request, env) {
  const cacheKey = new URL(request.url).pathname;
  const cached = await env.CACHE.get(cacheKey, { type: "json" });

  if (cached) {
    // Return cached immediately, revalidate in background
    const ctx = { waitUntil: (p) => p }; // execution context
    ctx.waitUntil(revalidate(cacheKey, env));
    return Response.json(cached);
  }

  // No cache, fetch from origin
  const fresh = await fetchFromOrigin(request);
  await env.CACHE.put(cacheKey, JSON.stringify(fresh), { expirationTtl: 600 });
  return Response.json(fresh);
}

Feature Flags ที่ Edge

// อ่าน feature flags จาก KV แล้วตัดสินใจที่ edge
async function getFeatureFlags(env, userId) {
  const flags = await env.FLAGS_KV.get("features", { type: "json" });
  return {
    newUI: flags?.newUI?.enabled && isInRollout(userId, flags.newUI.percentage),
    darkMode: flags?.darkMode?.enabled,
    betaAPI: flags?.betaAPI?.users?.includes(userId),
  };
}

แนวโน้มของ Edge Computing ในอนาคต

Edge Computing กำลังเติบโตอย่างรวดเร็วและจะเปลี่ยนวิธีที่เราสร้าง web application ไปอย่างสิ้นเชิง เทรนด์ที่น่าจับตาในปี 2026 และต่อไป ได้แก่

• AI at Edge: การรัน AI model ที่ edge จะกลายเป็นเรื่องปกติ ลด latency สำหรับ AI-powered features
• Edge Databases: database ที่ออกแบบมาสำหรับ edge เช่น D1, Turso, Neon จะเสถียรมากขึ้น
• WebAssembly at Edge: การรัน Wasm modules ที่ edge จะเปิดทางให้ใช้ภาษาอื่นนอกจาก JavaScript เช่น Rust สำหรับ backend ที่สามารถ compile ไป Wasm แล้วรันที่ edge ได้
• Edge-first Frameworks: framework ใหม่ๆ จะออกแบบมาสำหรับ edge เป็นหลัก ไม่ใช่ adapter

การเรียนรู้ edge computing ตั้งแต่ตอนนี้จะเป็นข้อได้เปรียบในอนาคต สำหรับนักพัฒนาไทยที่ต้องการติดตามเทคโนโลยีใหม่ๆ การอ่านแหล่งข้อมูลเทคโนโลยีเป็นประจำจะช่วยให้ไม่พลาดเทรนด์สำคัญ

สรุป

Edge Computing ไม่ใช่เทรนด์ชั่วคราว แต่เป็นวิวัฒนาการของ web infrastructure ที่จะเปลี่ยนวิธีที่เราสร้างและ deploy application ไปตลอดกาล Cloudflare Workers เป็น platform ที่ครบเครื่องที่สุดในปี 2026 ด้วย ecosystem ที่ประกอบด้วย KV, Durable Objects, D1, R2, Queues และ AI Workers ทำให้สร้าง full application ที่ edge ได้โดยไม่ต้องมี traditional server เลย

ข้อแนะนำสำหรับผู้เริ่มต้น ให้เริ่มจากการสร้าง Worker ง่ายๆ ที่ respond กับ request แล้วค่อยเพิ่ม D1 สำหรับ database และ KV สำหรับ caching ใช้ Hono เป็น framework เพราะเขียนง่ายและ type-safe จากนั้นค่อยขยายไปใช้ R2 สำหรับ file storage และ Durable Objects สำหรับ real-time features

สิ่งสำคัญคือต้องเข้าใจข้อจำกัดของ edge computing เช่น CPU time limit, memory limit และ runtime compatibility จะได้เลือกใช้ได้ถูกต้องกับ use case ของคุณ Edge computing เหมาะมากสำหรับ latency-sensitive applications แต่สำหรับ heavy computation ยังคงต้องใช้ traditional cloud server อยู่ ความเข้าใจทั้งสองโลกจะทำให้คุณเป็นนักพัฒนาที่ครบเครื่องมากขึ้น