Công Cụ (Tools)Xong

Cloudflare Workers – Chạy code serverless trên edge

Nhật Ký Chuyển Hóa
31/07/2026
0 Comments

Cloudflare Workers cho phép bạn chạy JavaScript (hoặc TypeScript, Rust, C/C++ qua WebAssembly) trực tiếp trên edge network của Cloudflare. Code được deploy và thực thi trên hơn 300 điểm hiện diện (PoPs) khắp thế giới, không cần server riêng, không cần lo scale.

Cloudflare Workers

Mình đi thẳng vào những phần quan trọng nhất: cách Workers hoạt động, bảng giá, deploy với Wrangler, vài ví dụ thực tế, rồi tới KV, R2, Pages và workflow deploy.

Workers là gì?

Cloudflare Workers là nền tảng serverless cho phép bạn viết và chạy JavaScript trực tiếp trên edge network của Cloudflare. Thay vì request phải đi về origin server rồi mới trả kết quả, Workers xử lý ngay tại PoP gần user nhất.

Về kỹ thuật, Workers chạy trên V8 isolates (cùng engine với Chrome và Node.js), không phải container hay VM. Cold start chỉ khoảng 0-5ms, nhanh hơn nhiều so với Lambda hay Cloud Functions (thường vài trăm ms).

Vài đặc điểm đáng chú ý:

  • 300+ PoPs toàn cầu, code chạy gần user, latency thấp
  • 0ms cold start, V8 isolates khởi động gần như tức thì
  • Web Standards API, dùng Fetch API, Request/Response, Streams quen thuộc
  • Tự động scale, không cần lo provisioning
  • Chạy trước origin, Workers đứng giữa client và origin server, có thể modify request/response

Nôm na là bạn đặt một “middleware” chạy trên toàn bộ CDN network của Cloudflare. Mọi request đi qua domain của bạn đều có thể được Workers can thiệp, xử lý, rồi forward về origin hoặc trả response luôn mà không cần origin.

Bảng giá

Workers có 2 gói chính:

Free plan:

  • 100,000 requests/ngày (không phải /tháng)
  • 10ms CPU time mỗi request
  • Tối đa 3MB script size
  • Tối đa 100 Workers

Paid plan ($5/tháng, Workers Paid):

  • 10 triệu requests/tháng (bao gồm trong $5, vượt thì $0.30/triệu request)
  • 30 triệu CPU milliseconds/tháng (mặc định 30 giây, tối đa 5 phút mỗi request)
  • Tối đa 10MB script size
  • Tối đa 500 Workers
  • Mở khóa Workers KV, Durable Objects, Cron Triggers, và nhiều tính năng nâng cao

ℹ️ Với 100K requests/ngày miễn phí, đa số use case nhỏ và vừa không tốn đồng nào. Site dưới 3 triệu pageviews/tháng thì Free plan là đủ.

Tổng quan giao diện Cloudflare Workers

Trước khi vào CLI, mình giới thiệu qua giao diện quản lý Workers trên Cloudflare Dashboard. Bạn vào dashboard, nhìn sidebar bên trái sẽ thấy mục Workers & Pages.

Click vào đó, bạn sẽ thấy danh sách tất cả Workers và Pages projects đang có. Mỗi Worker hiển thị tên, thời gian deploy gần nhất, và trạng thái. Phía trên có nút Create để tạo Worker mới ngay trên dashboard.

Click vào từng Worker, bạn sẽ thấy tab Metrics với biểu đồ requests, CPU time, errors theo thời gian. Tab Logs hiển thị real-time logs khi Worker chạy, rất tiện để debug.

Tạo Worker qua Dashboard vs Wrangler CLI

Có 2 cách tạo Worker: qua Dashboard hoặc qua Wrangler CLI.

Dashboard phù hợp khi bạn muốn thử nhanh một script đơn giản. Click Create → chọn template hoặc viết code trực tiếp → deploy luôn. Không cần cài gì trên máy.

Wrangler CLI phù hợp hơn cho project thật: có version control, local dev server, multiple environments, CI/CD integration. Đa số dev sẽ dùng Wrangler cho production projects.

Quick Edit trên Dashboard

Một tính năng hay là Quick Edit. Trong trang chi tiết Worker, click nút Edit Code sẽ mở editor ngay trên trình duyệt. Bạn sửa code, test ngay bên panel phải, rồi click Deploy. Rất tiện cho các thay đổi nhỏ, không cần mở terminal.

💡 Quick Edit tiện cho sửa nhanh, nhưng nếu project phức tạp (nhiều file, bindings, env variables) thì nên dùng Wrangler CLI để quản lý code chuẩn chỉnh hơn.

Tạo Worker đầu tiên với Wrangler CLI

Wrangler là CLI chính thức của Cloudflare để phát triển, test và deploy Workers. Cài Wrangler trước:

# Cài Wrangler global
npm install -g wrangler
# Kiểm tra version
wrangler --version

Đăng nhập vào tài khoản Cloudflare:

wrangler login

Lệnh này sẽ mở trình duyệt để bạn xác thực. Sau khi login thành công, tạo project Worker mới:

# Tạo project mới
wrangler init my-first-worker
# Output:
# ✨ Created my-first-worker/wrangler.toml
# ✨ Created my-first-worker/src/index.ts
# ✨ Created my-first-worker/package.json
# ✨ Created my-first-worker/tsconfig.json

Cấu trúc project sẽ như sau:

my-first-worker/
├── src/
│   └── index.ts       # Code chính của Worker
├── wrangler.toml      # Config (tên, route, bindings...)
├── package.json
└── tsconfig.json

File wrangler.toml là config chính:

name = "my-first-worker"
main = "src/index.ts"
compatibility_date = "2024-12-01"
# Gắn Worker vào domain cụ thể (tùy chọn)
# routes = [
#   { pattern = "example.com/*", zone_name = "example.com" }
# ]

Mở file src/index.ts và viết Worker đầu tiên:

export default {
  async fetch(request) {
    return new Response("Hello from Cloudflare Workers! 🚀", {
      headers: { "Content-Type": "text/plain" },
    });
  },
};

Chạy local để test:

wrangler dev
# Output:
# ⎔ Starting local server...
# [wrangler:inf] Ready on https://tech.nhatkychuyenhoa.link:8787
# ╭─────────────────────────────────────────╮
# │  [b] open a browser, [d] open devtools  │
# │  [l] turn off local mode, [q] quit      │
# ╰─────────────────────────────────────────╯

Mở https://tech.nhatkychuyenhoa.link:8787 sẽ thấy response. Khi sẵn sàng, deploy lên production:

wrangler deploy
# Output:
# ⛅️ wrangler 3.x.x
# Total Upload: 0.50 KiB / gzip: 0.30 KiB
# Uploaded my-first-worker (1.20 sec)
# Published my-first-worker (0.30 sec)
#   https://my-first-worker.your-subdomain.workers.dev

Vậy là Worker đã live trên toàn bộ 300+ PoPs. Ai ở Việt Nam truy cập sẽ được serve từ PoP ở Singapore hoặc Hồ Chí Minh, ai ở Mỹ sẽ được serve từ PoP gần nhất bên đó.

Ví dụ thực tế

Redirect theo điều kiện

Redirect user dựa trên quốc gia, device, hoặc bất kỳ điều kiện nào từ request. Ví dụ redirect user từ Việt Nam sang phiên bản tiếng Việt:

export default {
  async fetch(request) {
    const url = new URL(request.url);
    const country = request.cf?.country; // Cloudflare tự detect country
// Redirect user VN sang phiên bản tiếng Việt
    if (country === "VN" && !url.pathname.startsWith("/vi/")) {
      return Response.redirect(`https://example.com/vi${url.pathname}`, 302);
    }
// Redirect www sang non-www
    if (url.hostname === "www.example.com") {
      url.hostname = "example.com";
      return Response.redirect(url.toString(), 301);
    }
// Còn lại thì forward về origin
    return fetch(request);
  },
};

Object request.cf chứa nhiều thông tin mà Cloudflare tự detect: country, city, timezone, ASN, device type, bot score… Bạn dùng được những thông tin này để routing logic mà không cần service bên thứ ba.

A/B Testing trên edge

Thay vì dùng JavaScript phía client (gây layout shift) hoặc tool A/B testing nặng, bạn có thể split traffic ngay trên edge:

export default {
  async fetch(request) {
    const url = new URL(request.url);
// Chỉ A/B test trang landing page
    if (url.pathname !== "/landing") {
      return fetch(request);
    }
// Kiểm tra cookie đã có variant chưa
    const cookie = request.headers.get("Cookie") || "";
    let variant;
if (cookie.includes("ab-variant=A")) {
      variant = "A";
    } else if (cookie.includes("ab-variant=B")) {
      variant = "B";
    } else {
      // User mới: random 50/50
      variant = Math.random() < 0.5 ? "A" : "B";
    }
// Fetch version tương ứng từ origin
    const targetUrl = variant === "A"
      ? "https://example.com/landing-a"
      : "https://example.com/landing-b";
const response = await fetch(targetUrl, {
      headers: request.headers,
    });
// Clone response để modify headers
    const newResponse = new Response(response.body, response);
// Set cookie để giữ variant cho user
    if (!cookie.includes("ab-variant=")) {
      newResponse.headers.append(
        "Set-Cookie",
        `ab-variant=${variant}; Path=/; Max-Age=86400; SameSite=Lax`
      );
    }
return newResponse;
  },
};

User lần đầu truy cập sẽ được random vào variant A hoặc B. Cookie giữ cho user luôn thấy cùng một version trong 24 giờ. Logic chạy trên edge nên không ảnh hưởng performance phía client.

Thêm Security Headers

Use case phổ biến: thêm security headers vào mọi response mà không cần sửa code trên origin server:

export default {
  async fetch(request) {
    // Lấy response từ origin
    const response = await fetch(request);
// Clone và thêm security headers
    const newResponse = new Response(response.body, response);
    const headers = newResponse.headers;
// Chống clickjacking
    headers.set("X-Frame-Options", "SAMEORIGIN");
// Chống XSS
    headers.set("X-Content-Type-Options", "nosniff");
    headers.set("X-XSS-Protection", "1; mode=block");
// HSTS - ép dùng HTTPS
    headers.set(
      "Strict-Transport-Security",
      "max-age=31536000; includeSubDomains; preload"
    );
// Referrer Policy
    headers.set("Referrer-Policy", "strict-origin-when-cross-origin");
// Permissions Policy - giới hạn browser features
    headers.set(
      "Permissions-Policy",
      "camera=(), microphone=(), geolocation=(self)"
    );
// Content Security Policy (tuỳ chỉnh theo site)
    headers.set(
      "Content-Security-Policy",
      "default-src 'self'; script-src 'self' 'unsafe-inline' cdn.example.com; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:;"
    );
// Xoá header không cần thiết
    headers.delete("X-Powered-By");
    headers.delete("Server");
return newResponse;
  },
};

ℹ️ Cách này tiện khi bạn quản lý nhiều site trên cùng một account Cloudflare. Thay vì config security headers trên từng server, một Worker áp dụng cho tất cả.

API Proxy

Workers phù hợp để làm API proxy: ẩn API key, thêm rate limiting, hoặc transform response trước khi trả về client.

export default {
  async fetch(request, env) {
    const url = new URL(request.url);
// Chỉ proxy path /api/*
    if (!url.pathname.startsWith("/api/")) {
      return fetch(request);
    }
// Rate limiting đơn giản dựa trên IP
    const clientIP = request.headers.get("CF-Connecting-IP");
// Xây dựng request tới API thật
    const apiPath = url.pathname.replace("/api/", "");
    const apiUrl = `https://api.backend-service.com/${apiPath}${url.search}`;
const apiResponse = await fetch(apiUrl, {
      method: request.method,
      headers: {
        // Thêm API key mà client không biết
        "Authorization": `Bearer ${env.API_SECRET_KEY}`,
        "Content-Type": "application/json",
      },
      body: request.method !== "GET" ? request.body : undefined,
    });
// Transform response
    const data = await apiResponse.json();
return new Response(JSON.stringify({
      success: true,
      data: data,
      // Thêm metadata
      served_from: request.cf?.colo, // PoP nào serve
    }), {
      headers: {
        "Content-Type": "application/json",
        "Access-Control-Allow-Origin": "https://example.com",
        "Cache-Control": "public, max-age=60",
      },
    });
  },
};

Biến env.API_SECRET_KEY được set qua Wrangler secret, không hardcode trong source:

# Set secret cho Worker
wrangler secret put API_SECRET_KEY
# Wrangler sẽ prompt bạn nhập giá trị
# ✨ Success! Uploaded secret API_SECRET_KEY

Workers KV, Key-Value Storage trên edge

Workers KV là hệ thống key-value store phân tán toàn cầu, tích hợp sẵn với Workers. Dữ liệu được replicate ra tất cả các PoP nên read latency rất thấp. KV phù hợp cho dữ liệu đọc nhiều, ghi ít (eventually consistent, ghi mất vài giây để replicate toàn cầu).

Tạo KV namespace:

# Tạo KV namespace
wrangler kv namespace create "MY_CACHE"
# Output:
# ✨ Success! Created namespace "my-first-worker-MY_CACHE"
# Add the following to your wrangler.toml:
# [[kv_namespaces]]
# binding = "MY_CACHE"
# id = "abc123def456"

Thêm binding vào wrangler.toml:

name = "my-first-worker"
main = "src/index.ts"
compatibility_date = "2024-12-01"
[[kv_namespaces]]
binding = "MY_CACHE"
id = "abc123def456"

Sử dụng KV trong Worker:

export default {
  async fetch(request, env) {
    const url = new URL(request.url);
// Ví dụ: URL shortener đơn giản
    if (url.pathname.startsWith("/s/")) {
      const shortCode = url.pathname.replace("/s/", "");
// Đọc từ KV
      const targetUrl = await env.MY_CACHE.get(shortCode);
if (targetUrl) {
        // Tăng click count
        const clicks = parseInt(await env.MY_CACHE.get(`clicks:${shortCode}`) || "0");
        await env.MY_CACHE.put(`clicks:${shortCode}`, String(clicks + 1));
return Response.redirect(targetUrl, 302);
      }
return new Response("Short link not found", { status: 404 });
    }
// API để tạo short link
    if (url.pathname === "/api/shorten" && request.method === "POST") {
      const { target, code } = await request.json();
// Lưu vào KV với TTL 30 ngày
      await env.MY_CACHE.put(code, target, {
        expirationTtl: 60 * 60 * 24 * 30,
      });
return new Response(JSON.stringify({
        short_url: `https://example.com/s/${code}`,
      }), {
        headers: { "Content-Type": "application/json" },
      });
    }
return new Response("Not found", { status: 404 });
  },
};

Pricing của KV:

  • Free: 100K reads/ngày, 1K writes/ngày, 1GB storage
  • Paid: 10M reads/tháng, 1M writes/tháng, 1GB storage (nằm trong gói $5)

KV phù hợp cho config flags, URL shortener, cache API responses, feature toggles, user preferences, ban lists… Dữ liệu nào đọc nhiều ghi ít đều hợp với KV.

R2, Object Storage không tính phí egress

R2 là dịch vụ object storage của Cloudflare, tương tự S3 nhưng khác ở chỗ: không tính phí egress (băng thông ra). Đây là pain point lớn nhất của S3 mà R2 xử lý gọn.

Pricing R2:

  • Storage: $0.015/GB/tháng
  • Class A operations (write): $4.50/triệu requests
  • Class B operations (read): $0.36/triệu requests
  • Egress: $0, hoàn toàn miễn phí
  • Free tier: 10GB storage, 10M reads/tháng, 1M writes/tháng

Tạo R2 bucket và bind vào Worker:

# Tạo R2 bucket
wrangler r2 bucket create my-storage
# Output:
# ✨ Created bucket "my-storage"

Thêm vào wrangler.toml:

[[r2_buckets]]
binding = "MY_BUCKET"
bucket_name = "my-storage"

Sử dụng R2 trong Worker:

export default {
  async fetch(request, env) {
    const url = new URL(request.url);
    const key = url.pathname.slice(1); // Bỏ / đầu tiên
switch (request.method) {
      // Upload file
      case "PUT": {
        await env.MY_BUCKET.put(key, request.body, {
          httpMetadata: {
            contentType: request.headers.get("Content-Type"),
          },
        });
        return new Response(`Uploaded ${key}`, { status: 200 });
      }
// Download file
      case "GET": {
        const object = await env.MY_BUCKET.get(key);
        if (!object) {
          return new Response("Not found", { status: 404 });
        }
const headers = new Headers();
        headers.set("Content-Type", object.httpMetadata?.contentType || "application/octet-stream");
        headers.set("Cache-Control", "public, max-age=86400");
        headers.set("ETag", object.httpEtag);
return new Response(object.body, { headers });
      }
// Delete file
      case "DELETE": {
        await env.MY_BUCKET.delete(key);
        return new Response(`Deleted ${key}`, { status: 200 });
      }
default:
        return new Response("Method not allowed", { status: 405 });
    }
  },
};

ℹ️ R2 hỗ trợ S3-compatible API, nghĩa là bạn dùng được AWS SDK, rclone, hoặc bất kỳ tool nào hỗ trợ S3 để tương tác với R2. Migrate từ S3 sang R2 khá đơn giản.

Upload file bằng curl để test:

# Upload
curl -X PUT "https://my-worker.example.com/images/photo.jpg" \
  -H "Content-Type: image/jpeg" \
  --data-binary @photo.jpg
# Download
curl "https://my-worker.example.com/images/photo.jpg" -o downloaded.jpg

Workers + Pages

Cloudflare Pages là nền tảng deploy static sites (và full-stack apps). Khi kết hợp với Workers, bạn có một stack hoàn chỉnh: Pages serve frontend, Workers xử lý backend logic.

Có 2 cách kết hợp:

Cách 1: Pages Functions (built-in)

Pages có sẵn tính năng Functions. Tạo thư mục functions/ trong project, mỗi file là một API endpoint:

my-pages-project/
├── public/           # Static files
│   └── index.html
├── functions/        # API endpoints (Workers)
│   ├── api/
│   │   ├── hello.js        # GET /api/hello
│   │   └── users/
│   │       └── [id].js     # GET /api/users/:id
│   └── _middleware.js       # Middleware cho tất cả routes
└── package.json

Ví dụ file functions/api/hello.js:

// functions/api/hello.js
export async function onRequestGet(context) {
  return new Response(JSON.stringify({
    message: "Hello from Pages Functions!",
    timestamp: new Date().toISOString(),
  }), {
    headers: { "Content-Type": "application/json" },
  });
}
// functions/api/users/[id].js
export async function onRequestGet(context) {
  const userId = context.params.id;
// Dùng KV hoặc D1 để query user
  const user = await context.env.USERS_KV.get(userId, "json");
if (!user) {
    return new Response("User not found", { status: 404 });
  }
return new Response(JSON.stringify(user), {
    headers: { "Content-Type": "application/json" },
  });
}

Cách 2: Worker route chạy trước Pages

Bạn có thể gắn một Worker riêng vào route của Pages site. Worker chạy trước, modify request trước khi Pages serve, hoặc modify response sau khi Pages trả kết quả:

// Worker chạy trước Pages site
export default {
  async fetch(request, env) {
    const url = new URL(request.url);
// Thêm auth check cho /admin/*
    if (url.pathname.startsWith("/admin/")) {
      const authHeader = request.headers.get("Authorization");
      if (!authHeader || !isValidToken(authHeader)) {
        return new Response("Unauthorized", { status: 401 });
      }
    }
// Forward tới Pages (origin)
    const response = await fetch(request);
// Inject analytics script vào HTML response
    if (response.headers.get("Content-Type")?.includes("text/html")) {
      const html = await response.text();
      const modifiedHtml = html.replace(
        "",
        ``
      );
      return new Response(modifiedHtml, {
        headers: response.headers,
      });
    }
return response;
  },
};

Deploy Workflow

Workflow deploy điển hình với Workers:

Local development

# Chạy local với hot reload
wrangler dev
# Chạy local với remote resources (KV, R2 thật)
wrangler dev --remote

Deploy lên production

# Deploy trực tiếp
wrangler deploy
# Deploy với custom environment (staging)
wrangler deploy --env staging

Bạn có thể define nhiều environments trong wrangler.toml:

name = "my-worker"
main = "src/index.ts"
compatibility_date = "2024-12-01"
# Production (default)
routes = [
  { pattern = "example.com/api/*", zone_name = "example.com" }
]
# Staging environment
[env.staging]
routes = [
  { pattern = "staging.example.com/api/*", zone_name = "example.com" }
]

CI/CD với GitHub Actions

Tích hợp deploy Workers vào CI/CD pipeline:

# .github/workflows/deploy.yml
name: Deploy Worker
on:
  push:
    branches: [main]
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
- name: Deploy to Cloudflare Workers
        uses: cloudflare/wrangler-action@v3
        with:
          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
          # command: deploy --env production

Tạo API token tại Cloudflare Dashboard > My Profile > API Tokens, chọn template “Edit Cloudflare Workers”, rồi lưu token vào GitHub Secrets.

Rollback

Workers hỗ trợ rollback nhanh qua CLI hoặc dashboard:

# Xem lịch sử deployments
wrangler deployments list
# Output:
# Deployment ID: abc-123
#   Created:    2024-12-01T10:00:00Z
#   Author:     you@example.com
#
# Deployment ID: def-456
#   Created:    2024-11-30T15:00:00Z
#   Author:     you@example.com
# Rollback về deployment cụ thể
wrangler rollback abc-123

Một số ý tưởng sử dụng Cloudflare Workers

Workers hợp với những bài toán xử lý request ngay trên edge. Dưới đây là vài kiểu dùng dễ gặp nhất:

Cache API responses trên edge

Một ví dụ dễ thấy là cache response API ngay trên edge:

export default {
  async fetch(request, env) {
    const url = new URL(request.url);
// Chỉ cache GET requests tới /api/*
    if (request.method !== "GET" || !url.pathname.startsWith("/api/")) {
      return fetch(request);
    }
// Dùng Cache API của Workers
    const cacheKey = new Request(url.toString(), request);
    const cache = caches.default;
// Kiểm tra cache
    let response = await cache.match(cacheKey);
    if (response) {
      // Cache hit, trả response luôn từ edge cache
      return response;
    }
// Cache miss, fetch lên origin
    response = await fetch(request);
// Chỉ cache response thành công
    if (response.ok) {
      const cachedResponse = new Response(response.body, response);
      cachedResponse.headers.set("Cache-Control", "public, max-age=300"); // 5 phút
      cachedResponse.headers.set("X-Cache-Status", "MISS");
// Lưu vào edge cache (non-blocking)
      event.waitUntil(cache.put(cacheKey, cachedResponse.clone()));
return cachedResponse;
    }
return response;
  },
};

Server chỉ bị hit 1 lần mỗi 5 phút cho mỗi API endpoint, còn lại được serve từ edge. Giảm tải server đáng kể.

Edge redirect (không cần NGINX rewrite)

Thay vì config redirect rules trong NGINX/Apache (và phải reload server), bạn quản lý redirects trên edge với KV:

export default {
  async fetch(request, env) {
    const url = new URL(request.url);
// Lookup redirect từ KV
    const redirect = await env.REDIRECTS.get(url.pathname, "json");
if (redirect) {
      return Response.redirect(redirect.target, redirect.status || 301);
    }
// Không có redirect thì forward về origin
    return fetch(request);
  },
};

Quản lý redirects qua KV bulk upload:

# Tạo file redirects.json
cat > redirects.json << 'EOF'
[
  {
    "key": "/old-page",
    "value": "{\"target\":\"https://example.com/new-page\",\"status\":301}"
  },
  {
    "key": "/promo",
    "value": "{\"target\":\"https://example.com/summer-sale\",\"status\":302}"
  }
]
EOF
# Bulk upload vào KV
wrangler kv bulk put redirects.json --namespace-id YOUR_NAMESPACE_ID

Thêm, sửa, xoá redirect mà không cần SSH vào server, không cần reload NGINX. Thay đổi có hiệu lực trong vài giây trên toàn cầu.

Header injection và request filtering

Dùng Workers để thêm/sửa headers hoặc filter requests trước khi chúng đến máy chủ:

export default {
  async fetch(request, env) {
    const url = new URL(request.url);
// Block các path nhạy cảm
    const blockedPaths = [
      "/wp-login.php",
      "/xmlrpc.php",
      "/.env",
      "/wp-admin/install.php",
    ];
    if (blockedPaths.some(path => url.pathname.includes(path))) {
      // Trả 403 ngay trên edge, không đẩy request về origin
      return new Response("Forbidden", { status: 403 });
    }
// Block bad bots
    const ua = request.headers.get("User-Agent") || "";
    const badBots = ["AhrefsBot", "SemrushBot", "MJ12bot"];
    if (badBots.some(bot => ua.includes(bot))) {
      return new Response("Blocked", { status: 403 });
    }
// Thêm custom headers cho origin
    const modifiedRequest = new Request(request);
    modifiedRequest.headers.set("X-Real-Country", request.cf?.country || "XX");
    modifiedRequest.headers.set("X-Real-City", request.cf?.city || "Unknown");
    modifiedRequest.headers.set("X-Bot-Score", String(request.cf?.botManagement?.score || 0));
return fetch(modifiedRequest);
  },
};

ℹ️ Làm chuyện này ở edge gọn hơn hẳn. Request rác bị chặn sớm, origin đỡ phải xử lý mấy path kiểu wp-login.php, xmlrpc.php hay .env.

Tổng kết

Cloudflare Workers hợp với nhiều bài toán nhỏ nhưng hay gặp: redirect, rewrite, thêm header, cache API, proxy request, xử lý logic gần người dùng. Free tier cũng đủ để bạn thử nghiêm túc rồi.

Phần còn lại là chuyện thực hành. Bạn có thể bắt đầu bằng một Worker nhỏ, rồi mở rộng dần khi quen tay.

  • Workers chạy JavaScript/TypeScript trên edge, cold start gần 0ms
  • Wrangler CLI để develop, test và deploy Workers
  • Workers KV là key-value store phân tán, phù hợp dữ liệu đọc nhiều
  • R2 là object storage zero egress, S3-compatible
  • Pages + Workers cho full-stack trên edge
  • Các use case quen thuộc gồm cache API, edge redirect, header injection và request filtering

Tags:

No Comment! Be the first one.

Leave a Reply

Your email address will not be published. Required fields are marked *