บทนำ: API REST vs GraphQL สงคราม Web Services ปี 2026

พื้นฐานความรู้เกี่ยวกับ REST และ GraphQL

REST: สถาปัตยกรรมที่เรียบง่ายและเป็นที่นิยม

GraphQL: ภาษา Query สำหรับ API

เปรียบเทียบ REST และ GraphQL ในเชิงลึก

🎬 YouTube @icafefx

วิธีติดตั้งและใช้งาน REST และ GraphQL

ตารางเปรียบเทียบ Library และ Tools

REST API ด้วย ExpressJS

    mkdir rest-api
    cd rest-api
    npm init -y
    

    npm install express body-parser --save
    

    const express = require('express');
    const bodyParser = require('body-parser');
    const app = express();
    const port = 3000;

    app.use(bodyParser.json());

    app.get('/users/:id', (req, res) => {
      const userId = req.params.id;
      const user = { id: userId, name: 'John Doe', email: 'john.doe@example.com' };
      res.json(user);
    });

    app.listen(port, () => {
      console.log(`REST API Server listening at http://localhost:${port}`);
    });
    

    node server.js
    

GraphQL API ด้วย Apollo Server

    npm install apollo-server express graphql --save
    

    // schema.js
    const { gql } = require('apollo-server');

    const typeDefs = gql`
      type User {
        id: ID!
        name: String
        email: String
      }

      type Query {
        user(id: ID!): User
      }
    `;

    module.exports = typeDefs;
    

    // resolvers.js
    const resolvers = {
      Query: {
        user: (parent, args, context) => {
          const userId = args.id;
          return { id: userId, name: 'John Doe', email: 'john.doe@example.com' };
        },
      },
    };

    module.exports = resolvers;
    

    const { ApolloServer } = require('apollo-server-express');
    const express = require('express');
    const typeDefs = require('./schema');
    const resolvers = require('./resolvers');

    const app = express();

    const server = new ApolloServer({
      typeDefs,
      resolvers,
    });

    server.applyMiddleware({ app });

    app.listen({ port: 4000 }, () =>
      console.log(`GraphQL Server ready at http://localhost:4000${server.graphqlPath}`)
    );
    

    node server.js
    

"REST และ GraphQL ต่างก็มีข้อดีข้อเสียของตัวเอง การเลือกใช้งานขึ้นอยู่กับความต้องการของโปรเจกต์ ถ้าโปรเจกต์ต้องการความเรียบง่ายและเป็นไปตาม Standard HTTP Protocol REST อาจเป็นตัวเลือกที่ดี แต่ถ้าโปรเจกต์ต้องการความยืดหยุ่นและประสิทธิภาพสูง GraphQL อาจเป็นตัวเลือกที่เหมาะสมกว่า"

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

การทำ Caching ใน REST API

Caching เป็นเทคนิคสำคัญในการเพิ่มประสิทธิภาพของ REST API ครับ การทำ caching ที่ถูกต้องจะช่วยลดภาระของ server และทำให้ API ตอบสนองได้เร็วขึ้นอย่างเห็นได้ชัด วิธีการ caching ที่นิยมใช้กันมีหลายแบบ เช่น Client-side caching, Server-side caching และ Content Delivery Network (CDN) ลองมาดูรายละเอียดกัน

Client-side caching คือการให้ browser หรือ application ที่เรียก API เก็บ response ไว้ในเครื่องของตัวเอง ทำให้ไม่ต้อง request ไปที่ server ทุกครั้งที่มีการเรียกข้อมูลเดิม วิธีนี้เหมาะสำหรับข้อมูลที่ไม่ค่อยมีการเปลี่ยนแปลงบ่อยนัก เช่น รูปภาพ, CSS หรือ JavaScript file เราสามารถกำหนด cache policy ได้โดยใช้ HTTP headers เช่น Cache-Control, Expires หรือ ETag

Server-side caching คือการเก็บ response ของ API ไว้ใน server เอง เมื่อมี request เข้ามา server จะตรวจสอบก่อนว่ามีข้อมูลอยู่ใน cache หรือไม่ ถ้ามีก็จะส่งข้อมูลจาก cache กลับไปเลย โดยไม่ต้องไป query database หรือคำนวณใหม่ วิธีนี้ช่วยลด load ของ database และ CPU ได้อย่างมาก ตัวอย่าง server-side caching tools ที่นิยมใช้กันก็มี Redis, Memcached หรือ Varnish

CDN เป็นระบบ distributed server ที่กระจายอยู่ทั่วโลก ทำหน้าที่เก็บ cache ของ content ต่างๆ เมื่อผู้ใช้ request content จาก CDN, CDN server ที่อยู่ใกล้ผู้ใช้ที่สุดจะส่ง content กลับไปให้ ทำให้ latency ลดลงอย่างมาก CDN เหมาะสำหรับ content ที่มีการเรียกใช้งานจากผู้ใช้จำนวนมากทั่วโลก เช่น รูปภาพ, วิดีโอ หรือไฟล์ดาวน์โหลดขนาดใหญ่

# ตัวอย่าง configuration สำหรับ caching ด้วย Nginx
proxy_cache_path /tmp/nginx_cache levels=1:2 keys_zone=my_cache:10m max_size=10g inactive=60m use_temp_path=off;

server {
    location /api/ {
        proxy_pass http://backend_server;
        proxy_cache my_cache;
        proxy_cache_valid 200 304 1h; # cache responses ที่มี status code 200 หรือ 304 เป็นเวลา 1 ชั่วโมง
        proxy_cache_valid any 10m; # cache responses อื่นๆ เป็นเวลา 10 นาที
        proxy_cache_use_stale error timeout invalid_header updating;
        add_header X-Cache-Status $upstream_cache_status;
    }
}

การทำ Batching และ Data Loader ใน GraphQL

GraphQL แก้ปัญหา over-fetching และ under-fetching ได้ แต่ก็อาจเจอปัญหา N+1 problem ได้เช่นกัน ซึ่งเกิดจากการ query ข้อมูลที่สัมพันธ์กันหลายครั้ง ทำให้ database ทำงานหนัก การแก้ปัญหานี้สามารถทำได้โดยใช้ Batching และ Data Loader

Batching คือการรวม request หลายๆ request ที่ต้องการข้อมูลจาก database ชุดเดียวกัน ให้เป็น request เดียว แล้วส่งไป query database ทีเดียว วิธีนี้ช่วยลดจำนวน round trip ไปยัง database ได้อย่างมาก ตัวอย่างเช่น ถ้าเราต้องการดึงข้อมูล users หลายคนพร้อมกัน เราสามารถรวม query users ทั้งหมดเป็น query เดียว แล้วส่งไปที่ database

Data Loader เป็น library ที่ช่วยให้การทำ Batching เป็นเรื่องง่ายขึ้น Data Loader จะเก็บรวบรวม request ที่เข้ามา แล้วส่งไป query database เป็น batch เมื่อได้ข้อมูลกลับมา Data Loader ก็จะทำการ map ข้อมูลให้กับ request แต่ละอัน ทำให้เราไม่ต้องเขียน logic สำหรับ Batching เอง Data Loader เป็นเครื่องมือที่มีประโยชน์มากในการ optimize GraphQL API

ลองดูตัวอย่างการใช้ Data Loader ใน JavaScript (Node.js) กันครับ

const DataLoader = require('dataloader');

const userLoader = new DataLoader(async (userIds) => {
  const users = await db.query('SELECT * FROM users WHERE id IN (?)', [userIds]);
  // เรียงลำดับ users ให้ตรงกับลำดับ userIds ที่ request เข้ามา
  const userMap = {};
  users.forEach(user => {
    userMap[user.id] = user;
  });
  return userIds.map(id => userMap[id]);
});

// ใน resolver ของ GraphQL
const resolvers = {
  Query: {
    user: async (parent, { id }) => {
      return userLoader.load(id);
    },
  },
  Post: {
    author: async (parent) => {
      return userLoader.load(parent.authorId);
    },
  },
};

จากตัวอย่างนี้ userLoader จะทำหน้าที่ Batching request สำหรับ users ทั้งหมด เมื่อมีการเรียก user หรือ author resolver, Data Loader จะทำการ load user จาก database เป็น batch ทำให้ลดจำนวน query ไปยัง database ได้อย่างมาก

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

Authentication และ Authorization เป็นเรื่องสำคัญมากในการพัฒนา API ไม่ว่าจะเป็น REST หรือ GraphQL เราต้องมั่นใจว่าผู้ใช้ที่เข้ามาใช้งาน API เป็นใคร และมีสิทธิ์ทำอะไรได้บ้าง

Authentication คือการยืนยันตัวตนของผู้ใช้ ว่าเป็นใคร เช่น การใช้ username/password, API key หรือ OAuth ใน REST API เราสามารถใช้ HTTP headers เช่น Authorization ในการส่ง token เพื่อยืนยันตัวตน ใน GraphQL เราสามารถใช้ context ในการส่งข้อมูล authentication ไปยัง resolvers ต่างๆ

Authorization คือการตรวจสอบว่าผู้ใช้มีสิทธิ์ทำอะไรได้บ้าง หลังจากที่ยืนยันตัวตนแล้ว เราต้องตรวจสอบว่าผู้ใช้มีสิทธิ์เข้าถึง resource หรือ mutation ที่ต้องการหรือไม่ ใน REST API เราสามารถใช้ middleware ในการตรวจสอบสิทธิ์ ใน GraphQL เราสามารถใช้ directive หรือ resolver ในการตรวจสอบสิทธิ์

ตัวอย่างการใช้ JWT (JSON Web Token) ในการทำ Authentication ใน Node.js

const jwt = require('jsonwebtoken');
const secretKey = 'my-secret-key';

// สร้าง JWT token
const token = jwt.sign({ userId: 123 }, secretKey, { expiresIn: '1h' });

// ตรวจสอบ JWT token
try {
  const decoded = jwt.verify(token, secretKey);
  console.log('User ID:', decoded.userId);
} catch (error) {
  console.error('Invalid token:', error.message);
}

เปรียบเทียบ

ตารางด้านบนสรุปความแตกต่างระหว่าง REST และ GraphQL ในด้านต่างๆ นะครับ REST API นั้นเข้าใจง่ายและใช้งานง่าย แต่ก็มีข้อจำกัดในเรื่องของ over-fetching และ under-fetching ส่วน GraphQL แก้ปัญหาเหล่านี้ได้ แต่ก็มีความซับซ้อนมากกว่า

ตารางนี้เป็นการเปรียบเทียบ benchmark ระหว่าง REST และ GraphQL ในสถานการณ์จริงนะครับ ตัวเลขเหล่านี้เป็นค่าประมาณ และอาจแตกต่างกันไปขึ้นอยู่กับปัจจัยต่างๆ เช่น ขนาดของข้อมูล, ความซับซ้อนของ query, infrastructure และ optimization techniques อย่างไรก็ตาม โดยทั่วไปแล้ว GraphQL มักจะมี performance ที่ดีกว่า REST ในหลายๆ ด้าน

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

คำเตือน: การใช้ GraphQL โดยไม่ระมัดระวังอาจนำไปสู่ปัญหาด้าน performance และ security ได้ เช่น Query complexity attacks หรือ N+1 problem ดังนั้นควรศึกษาและทำความเข้าใจ GraphQL อย่างละเอียดก่อนนำไปใช้งานจริง

• Query Complexity: GraphQL อนุญาตให้ client กำหนด query ได้อย่างอิสระ ซึ่งอาจนำไปสู่ query ที่ซับซ้อนและใช้ resource มากเกินไป เราควรจำกัด query complexity โดยใช้ techniques เช่น Query cost analysis หรือ Depth limiting
• N+1 Problem: เกิดจากการ query ข้อมูลที่สัมพันธ์กันหลายครั้ง ทำให้ database ทำงานหนัก แก้ไขได้โดยใช้ Batching และ Data Loader
• Security Vulnerabilities: GraphQL ก็เหมือนกับ API อื่นๆ ที่อาจมีช่องโหว่ด้าน security เช่น Injection attacks หรือ Authentication bypass ควรใช้ security best practices เช่น Input validation, Output encoding และ Authentication/Authorization ที่แข็งแกร่ง
• Monitoring and Logging: ควรมีระบบ monitoring และ logging ที่ดี เพื่อตรวจสอบ performance และ error ของ GraphQL API ทำให้เราสามารถแก้ไขปัญหาได้อย่างรวดเร็ว
• Schema Design: การออกแบบ schema ที่ดีเป็นสิ่งสำคัญมากในการพัฒนา GraphQL API ควรออกแบบ schema ให้สอดคล้องกับ business requirements และ optimize สำหรับ performance
• Versioning: แม้ว่า GraphQL จะช่วยลดความจำเป็นในการทำ versioning แต่ก็อาจจำเป็นต้องทำ versioning ในบางกรณี เช่น เมื่อมีการเปลี่ยนแปลง schema ที่สำคัญ หรือมีการเพิ่ม features ใหม่ๆ ที่ไม่ compatible กับ client รุ่นเก่า

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

จากประสบการณ์ 20 ปีในการพัฒนา web service ผมได้เห็นทั้งข้อดีและข้อเสียของ REST และ GraphQL ครับ สมัยก่อนตอนที่ REST เป็นที่นิยม ผมก็เคยเจอปัญหา over-fetching และ under-fetching บ่อยมาก ทำให้ต้องเขียน code เพิ่มเติมเพื่อจัดการกับข้อมูลที่ไม่จำเป็น หรือต้องทำ multiple requests เพื่อดึงข้อมูลที่ต้องการ

พอ GraphQL เริ่มเป็นที่นิยม ผมก็ลองเอามาใช้ใน project ใหม่ๆ พบว่า GraphQL ช่วยแก้ปัญหา over-fetching และ under-fetching ได้จริง ทำให้ client สามารถดึงข้อมูลที่ต้องการได้อย่างแม่นยำ และลดจำนวน requests ได้อย่างมาก แต่ก็ต้องระวังเรื่อง Query complexity และ N+1 problem ด้วย

ผมเคยเซ็ต GraphQL API ตอนปี 2020 ให้กับ e-commerce platform แห่งหนึ่ง ตอนนั้นเราใช้ Data Loader ในการแก้ปัญหา N+1 problem และใช้ Query cost analysis ในการจำกัด query complexity ผลลัพธ์ที่ได้คือ API ตอบสนองได้เร็วขึ้น และลด load ของ database ได้อย่างเห็นได้ชัด

อีก project หนึ่งผมเคยเจอเคสที่ client ต้องการข้อมูลที่ซับซ้อนมาก ซึ่งต้อง join ข้อมูลจากหลาย tables ใน database ตอนแรกเราใช้ REST API ในการดึงข้อมูล แต่พบว่า performance ไม่ดีเท่าที่ควร เพราะต้องทำ multiple requests และ join ข้อมูลใน application layer หลังจากนั้นเราก็เปลี่ยนมาใช้ GraphQL และเขียน resolver ที่ optimized สำหรับ query นั้นๆ ผลลัพธ์ที่ได้คือ API ตอบสนองได้เร็วขึ้นอย่างมาก และ client ก็สามารถดึงข้อมูลที่ต้องการได้ใน request เดียว

ดังนั้นการเลือกใช้ REST หรือ GraphQL ขึ้นอยู่กับ use case และ requirements ของแต่ละ project ครับ ถ้า project ไม่ซับซ้อนมาก และต้องการความง่ายในการพัฒนา REST ก็ยังเป็นตัวเลือกที่ดี แต่ถ้า project ซับซ้อน และต้องการ performance ที่ดี GraphQL อาจเป็นตัวเลือกที่เหมาะสมกว่า

สิ่งสำคัญคือต้องศึกษาและทำความเข้าใจทั้ง REST และ GraphQL อย่างละเอียด ก่อนตัดสินใจเลือกใช้เทคโนโลยีใดเทคโนโลยีหนึ่ง และต้องระมัดระวังข้อควรระวังต่างๆ ที่อาจเกิดขึ้น เพื่อให้การพัฒนา API เป็นไปอย่างราบรื่นและมีประสิทธิภาพ

เครื่องมือแนะนำ

เครื่องมือสำหรับ REST API

# ตัวอย่างการส่ง GET request ไปยัง REST API ด้วย Postman
    GET https://api.example.com/users/123
    

# ตัวอย่าง OpenAPI specification
    openapi: 3.0.0
    info:
      title: User API
      version: v1
    paths:
      /users/{userId}:
        get:
          summary: Get user by ID
          parameters:
            - in: path
              name: userId
              required: true
              schema:
                type: integer
          responses:
            '200':
              description: Successful operation
              content:
                application/json:
                  schema:
                    type: object
                    properties:
                      id:
                        type: integer
                      name:
                        type: string
    

# ตัวอย่างการส่ง POST request ไปยัง REST API ด้วย Insomnia
    POST https://api.example.com/users
    Content-Type: application/json

    {
      "name": "John Doe",
      "email": "john.doe@example.com"
    }
    

เครื่องมือสำหรับ GraphQL API

# ตัวอย่าง GraphQL query
    query {
      user(id: 123) {
        id
        name
        email
      }
    }
    

# ตัวอย่างการใช้ Apollo Client ใน React
    import { useQuery, gql } from '@apollo/client';

    const GET_USER = gql`
      query GetUser($id: ID!) {
        user(id: $id) {
          id
          name
          email
        }
      }
    `;

    function UserProfile({ userId }) {
      const { loading, error, data } = useQuery(GET_USER, {
        variables: { id: userId },
      });

      if (loading) return 
Loading...
;
      if (error) return 
Error :
;

      return (
        

          
{data.user.name}
          
{data.user.email}
        
      );
    }
    

# ตัวอย่าง GraphQL schema ใน GraphQL Editor
    type User {
      id: ID!
      name: String!
      email: String!
    }

    type Query {
      user(id: ID!): User
    }
    

Case Study ประสบการณ์จริง

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

GraphQL ปลอดภัยกว่า REST จริงหรือ?

REST API สามารถทำ caching ได้ดีกว่า GraphQL จริงไหม?

GraphQL เหมาะกับระบบที่มี complexity สูงจริงหรือ?

GraphQL จะมาแทนที่ REST ในอนาคตหรือไม่?

ต้องมีความรู้พื้นฐานอะไรบ้างก่อนเริ่มใช้ GraphQL?

GraphQL ยากกว่า REST จริงหรือ?

สรุป