Bảo mật khi dùng AI: không để lộ key, dữ liệu và code

Bảo mật khi dùng AI lập trình: đừng dán key, dữ liệu người dùng hay code công ty vào khung chat. Có bộ lọc che bí mật, cách chặn từ gốc và việc làm khi lỡ lộ.

Bảo mật khi dùng AI bắt đầu từ một câu hỏi trước mỗi lần dán: đoạn này có bí mật nào không? Ba thứ cần giữ là khóa và mật khẩu, dữ liệu của người khác, và code không thuộc về bạn. Lần dán gần nhất của bạn có sạch không? Cùng kiểm tra nhé.

Đoạn log này có gì đáng sợ?

Ở bài trước, mình dùng AI để review code mà vẫn tự kiểm từng nhận xét. Bài đó kết thúc ở một thói quen nhỏ có thể gây hại lớn: khi vội, người ta dán nguyên một đoạn log hay một file cấu hình vào khung chat mà quên rằng trong đó có thứ không nên rời khỏi máy.

Mình dựng lại một tình huống để bạn thấy. Bot Telegram của app sổ chi tiêu báo lỗi, và bạn muốn nhờ AI xem giúp. Đoạn log bên dưới là đoạn mình dựng để minh họa, mọi khóa, mật khẩu, tên và số điện thoại trong đó đều là giả. Hãy thử đọc nó như một người sắp bấm "dán":

Đoạn log định dán cho AI (dữ liệu giả)
[2026-11-13 21:04:11] ERROR sendMessage thất bại
FetchError: request to https://api.telegram.org/bot123456789:AAHxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx/sendMessage failed, reason: connect ETIMEDOUT
    at ClientRequest.<anonymous> (node_modules/node-fetch/lib/index.js:1491:11)
Cấu hình đang chạy: BOT_TOKEN=123456789:AAHxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx DATABASE_URL=postgres://moc_admin:Matkhau-Gia-12345@db.example.com:5432/sochi
Người dùng: Nguyễn Văn An (0901 000 001, an.nguyen@example.com) gửi "ăn trưa 45k"
Commit đang chạy: 3f2a9c1 (2026-11-13), đơn 1041

Trong sáu dòng đó có ba thứ không nên đi đâu cả. Token của bot xuất hiện hai lần, một lần trong địa chỉ yêu cầu và một lần trong dòng cấu hình. Lý do nó nằm trong địa chỉ là Telegram Bot API quy định mọi lời gọi có dạng https://api.telegram.org/bot<token>/<tên phương thức>, và nhiều thư viện HTTP in cả địa chỉ vào thông báo lỗi.

Thứ hai là chuỗi kết nối cơ sở dữ liệu, có cả tên đăng nhập và mật khẩu. Thứ ba là tên, số điện thoại và email của một người dùng. Dòng cuối thì vô hại: mã commit, ngày và mã đơn.

Điều đáng nghĩ là không ai cố ý làm lộ gì. Dòng cấu hình nằm sẵn trong log vì bot in ra khi khởi động, và người dán chỉ định lấy "cả cái lỗi cho đủ ngữ cảnh". Chính câu "cho đủ ngữ cảnh" là chỗ hay hỏng.

Ba thứ không nên đưa cho AI, và vì sao

Thứ nhất là khóa và mật khẩu: API key, token, chuỗi kết nối cơ sở dữ liệu, khóa service-role. Một khi nó nằm trong khung chat, bạn không còn kiểm soát nó nữa. Nó đi qua máy chủ của bên thứ ba, có thể nằm trong lịch sử cuộc trò chuyện, và có thể được AI chép lại vào đoạn code nó gợi ý. AI đôi khi còn gợi ý ghi thẳng key vào code "cho chạy thử", rồi bạn quên xóa. Theo mình việc đó còn nguy hiểm hơn việc dán, vì lúc đó key đi thẳng vào Git.

Thứ hai là dữ liệu của người khác: tên, số điện thoại, email, lịch sử chi tiêu của người dùng thật. Đây không còn là chuyện của riêng bạn, vì họ chưa đồng ý để dữ liệu của họ tới một công cụ mà họ không biết. Khi cần AI giúp debug, hãy thay bằng dữ liệu giả có cùng hình dạng (một người tên "A", số 0900000000).

Thứ ba là code và tài liệu không thuộc về bạn: code của công ty, của khách hàng, hay thứ nằm dưới thỏa thuận bảo mật. Mỗi công cụ AI và mỗi gói dịch vụ có chính sách riêng về việc lưu và dùng dữ liệu bạn gửi, và gói cá nhân thường khác gói doanh nghiệp. Mình không nói thay được cho từng nhà cung cấp, nên việc cần làm là đọc điều khoản dữ liệu của đúng gói bạn dùng, và hỏi công ty xem có danh sách công cụ AI được duyệt không trước khi dán code vào bất kỳ công cụ nào.

Che bí mật trước khi dán

Cách mình làm là một bộ lọc nhỏ chạy trên đoạn văn bản trước khi bạn dán. Nó tìm những thứ có hình dạng quen thuộc và thay bằng một nhãn như [ẨN:bot-token]. AI vẫn thấy cấu trúc của đoạn log, nhưng không thấy giá trị. Bạn cần Node.js 22.18 trở lên, vì từ bản đó Node chạy thẳng file .ts, và không cần cài thêm gì. Cấu trúc thư mục:

Cấu trúc thư mục
loc-bi-mat/
  package.json
  loc-truoc-khi-dan.ts
  quet-thu-muc.ts
  src/bi-mat.ts
  src/mau-log.ts
  src/bi-mat.test.ts
package.json
{
  "name": "so-chi-tieu-ai-10",
  "private": true,
  "type": "module",
  "scripts": { "test": "node --test src" }
}

File dưới chứa các giá trị giả. Mình ghép chúng từ nhiều mảnh lúc chạy, chứ không viết nguyên chuỗi, vì công cụ quét bí mật của GitHub sẽ báo nếu thấy nguyên một chuỗi giống token thật trong kho code, kể cả khi nó là giả:

src/mau-log.ts
// Giá trị GIẢ để thử bộ lọc. Ghép từ nhiều mảnh lúc chạy, để file này không chứa nguyên một chuỗi giống khóa thật
// (công cụ quét bí mật của GitHub sẽ báo nếu có).
export const BOT_TOKEN_GIA = `123456789${":"}AAH${"x".repeat(32)}`;
export const MAT_KHAU_DB_GIA = `Matkhau${"-"}Gia${"-"}12345`;

// Một đoạn log LỖI BOT được dựng lại để minh họa. Thư viện gọi HTTP hay in cả địa chỉ yêu cầu vào thông báo lỗi,
// mà địa chỉ của Telegram Bot API chứa token.
export const LOG_MAU = `[2026-11-13 21:04:11] ERROR sendMessage thất bại
FetchError: request to https://api.telegram.org/bot${BOT_TOKEN_GIA}/sendMessage failed, reason: connect ETIMEDOUT
    at ClientRequest.<anonymous> (node_modules/node-fetch/lib/index.js:1491:11)
Cấu hình đang chạy: BOT_TOKEN=${BOT_TOKEN_GIA} DATABASE_URL=postgres://moc_admin:${MAT_KHAU_DB_GIA}@db.example.com:5432/sochi
Người dùng: Nguyễn Văn An (0901 000 001, an.nguyen@example.com) gửi "ăn trưa 45k"
Commit đang chạy: 3f2a9c1 (2026-11-13), đơn 1041`;

Giờ là phần chính: bảy quy tắc, mỗi quy tắc là một regex cho một loại bí mật. Hàm anBiMat chạy lần lượt từng quy tắc, thay chỗ khớp bằng nhãn, và ghi lại dòng nào, loại gì. Nó chỉ ghi bốn ký tự đầu của giá trị, đủ để bạn nhận ra đó là cái nào mà không in lại cả bí mật:

src/bi-mat.ts
// Tìm và che những thứ không nên dán vào khung chat của AI: khóa, mật khẩu và thông tin cá nhân.
// Đây là LƯỚI LỌC cho những hình dạng đã biết, không phải lá chắn: bí mật có hình dạng lạ sẽ lọt qua.
export type Loai = "url-co-mat-khau" | "bot-token" | "khoa-aws" | "jwt" | "mat-khau-gan" | "email" | "so-dien-thoai";
export type PhatHien = { loai: Loai; dong: number; xemTruoc: string };

// Giá trị mẫu như "<token>", "your_key", "changeme" (hay nằm trong .env.example), hoặc chỗ đã che rồi, không phải bí mật thật.
const GIA_TRI_MAU = /^(<.*>|your[_-].*|changeme|x{3,}|\*{3,}|env\(.*|\[ẨN:.*)$/i;

// Thứ tự quan trọng: quy tắc cụ thể (bot-token, URL) chạy trước quy tắc chung ("token=...").
const CAC_QUY: { loai: Loai; mau: RegExp }[] = [
  { loai: "url-co-mat-khau", mau: /\b[a-z][a-z0-9+.-]*:\/\/[^\s:@/]+:[^\s@/]+@[^\s/]+/gi },
  { loai: "bot-token", mau: /(?<!\d)\d{8,10}:[A-Za-z0-9_-]{35}(?![A-Za-z0-9_-])/g },
  { loai: "khoa-aws", mau: /\bAKIA[0-9A-Z]{16}\b/g },
  { loai: "jwt", mau: /\beyJ[\w-]{8,}\.eyJ[\w-]{8,}\.[\w-]{8,}/g },
  { loai: "mat-khau-gan", mau: /\b\w*(?:api[_-]?key|[_-]key|secret|token|password|mat_khau)\w*\s*[:=]\s*["']?([^\s"',;]{8,})/gi },
  { loai: "email", mau: /\b[\w.+-]+@[\w-]+(?:\.[\w-]+)+\b/g },
  { loai: "so-dien-thoai", mau: /(?<!\d)(?:\+84|0)(?:[\s.]?\d){9}(?!\d)/g },
];

export function anBiMat(vanBan: string): { sach: string; phatHien: PhatHien[] } {
  const phatHien: PhatHien[] = [];
  let sach = vanBan;
  for (const { loai, mau } of CAC_QUY) {
    const truoc = sach;
    sach = truoc.replace(mau, (khop: string, ...doiSo: unknown[]) => {
      const viTri = doiSo[doiSo.length - 2] as number; // tham số kế cuối của callback replace là vị trí khớp
      const giaTri = loai === "mat-khau-gan" ? (doiSo[0] as string) : khop;
      if (GIA_TRI_MAU.test(giaTri)) return khop;
      phatHien.push({ loai, dong: truoc.slice(0, viTri).split("\n").length, xemTruoc: `${giaTri.slice(0, 4)}…` });
      return khop.replace(giaTri, `[ẨN:${loai}]`);
    });
  }
  return { sach, phatHien: phatHien.sort((a, b) => a.dong - b.dong) };
}

Có vài quyết định đáng giải thích. Thứ tự các quy tắc quan trọng: quy tắc cụ thể (token bot, URL có mật khẩu) chạy trước quy tắc chung tên_biến=giá_trị, nếu không thì dòng BOT_TOKEN=... bị che hai lần. Token bot được nhận ra bằng hình dạng thường thấy của nó (8 đến 10 chữ số, dấu hai chấm, 35 ký tự), và mình dùng (?<!\d) thay vì \b ở đầu vì trong địa chỉ Telegram, token dính liền chữ bot nên không có ranh giới từ. Biến GIA_TRI_MAU bỏ qua những giá trị như your_token_here hay changeme, vì chúng hay nằm trong file .env.example, và nếu không bỏ qua thì bộ lọc báo động vì cả những file vô hại.

Chạy bộ lọc trên log mẫu:

loc-truoc-khi-dan.ts
// Che bí mật trong một đoạn văn bản trước khi dán cho AI. Chạy: node loc-truoc-khi-dan.ts [file]. Không có file thì dùng log mẫu.
import { readFileSync } from "node:fs";

import { anBiMat } from "./src/bi-mat.ts";
import { LOG_MAU } from "./src/mau-log.ts";

const vanBan = process.argv[2] ? readFileSync(process.argv[2], "utf8") : LOG_MAU;
const { sach, phatHien } = anBiMat(vanBan);
console.log(`--- Văn bản sau khi che\n${sach}\n--- Đã che ${phatHien.length} chỗ`);
for (const p of phatHien) console.log(`dòng ${p.dong}: ${p.loai} (bắt đầu bằng ${p.xemTruoc})`);
Che log mẫu
node loc-truoc-khi-dan.ts
Kết quả
--- Văn bản sau khi che
[2026-11-13 21:04:11] ERROR sendMessage thất bại
FetchError: request to https://api.telegram.org/bot[ẨN:bot-token]/sendMessage failed, reason: connect ETIMEDOUT
    at ClientRequest.<anonymous> (node_modules/node-fetch/lib/index.js:1491:11)
Cấu hình đang chạy: BOT_TOKEN=[ẨN:bot-token] DATABASE_URL=[ẨN:url-co-mat-khau]/sochi
Người dùng: Nguyễn Văn An ([ẨN:so-dien-thoai], [ẨN:email]) gửi "ăn trưa 45k"
Commit đang chạy: 3f2a9c1 (2026-11-13), đơn 1041
--- Đã che 5 chỗ
dòng 2: bot-token (bắt đầu bằng 1234…)
dòng 4: url-co-mat-khau (bắt đầu bằng post…)
dòng 4: bot-token (bắt đầu bằng 1234…)
dòng 5: email (bắt đầu bằng an.n…)
dòng 5: so-dien-thoai (bắt đầu bằng 0901…)

Hãy đối chiếu với đoạn log gốc. Cả hai token, chuỗi kết nối, email và số điện thoại đều bị che, còn mã commit 3f2a9c1, ngày, mã đơn 1041 và "45k" còn nguyên, vì chúng không phải bí mật và AI cần chúng để hiểu lỗi. Nhưng bạn thấy có hai thứ chưa bị che: tên "Nguyễn Văn An" và địa chỉ máy chủ db.example.com. Bộ lọc chỉ nhận hình dạng, và tên người không có hình dạng cố định. Với những thứ đó, mắt bạn vẫn là lớp lọc cuối cùng.

Quét thư mục và chặn từ gốc

Che từng đoạn trước khi dán là việc thủ công, mà người ta hay quên đúng lúc vội. Vì vậy mình thêm hai lớp nữa chạy không cần nhớ. Lớp đầu là quét cả thư mục xem còn bí mật nằm trong file nào không, và kiểm tra .env đã được .gitignore loại trừ chưa. Script tự dựng một dự án mẫu trong thư mục tạm (với một lỗi cố ý: quên dòng .env trong .gitignore) để bạn chạy được ngay:

quet-thu-muc.ts
// Quét một thư mục tìm bí mật còn nằm trong file, và kiểm tra .env đã được .gitignore loại trừ chưa.
// Chạy: node quet-thu-muc.ts <thư mục>, hoặc node quet-thu-muc.ts --demo (tự dựng một dự án mẫu trong thư mục tạm).
import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join, relative } from "node:path";

import { anBiMat } from "./src/bi-mat.ts";
import { BOT_TOKEN_GIA } from "./src/mau-log.ts";

const BO_QUA = new Set(["node_modules", ".git", ".next"]);
const laFileEnv = (ten: string) => /^\.env(\..+)?$/.test(ten) && ten !== ".env.example";

function* duyet(thuMuc: string): Generator<string> {
  for (const ten of readdirSync(thuMuc)) {
    if (BO_QUA.has(ten)) continue;
    const duongDan = join(thuMuc, ten);
    if (statSync(duongDan).isDirectory()) yield* duyet(duongDan);
    else yield duongDan;
  }
}

function dungDuAnMau(): string {
  const goc = mkdtempSync(join(tmpdir(), "du-an-mau-"));
  mkdirSync(join(goc, "src"));
  writeFileSync(join(goc, ".env"), `BOT_TOKEN=${BOT_TOKEN_GIA}\n`);
  writeFileSync(join(goc, ".env.example"), "BOT_TOKEN=your_token_here\n");
  writeFileSync(join(goc, ".gitignore"), "node_modules/\n"); // quên dòng .env: lỗi hay gặp
  writeFileSync(join(goc, "src", "chay-bot.ts"), `// Liên hệ: an.nguyen@example.com\nconst token = "${BOT_TOKEN_GIA}"; // dán tạm cho chạy thử\n`);
  return goc;
}

const thuMuc = process.argv[2] === "--demo" ? dungDuAnMau() : process.argv[2];
if (!thuMuc) throw new Error("Cách dùng: node quet-thu-muc.ts <thư mục> | --demo");

let soChoLo = 0;
for (const duongDan of duyet(thuMuc)) {
  const ten = duongDan.split(/[\\/]/).pop()!;
  if (laFileEnv(ten)) continue; // file .env được phép chứa bí mật; chỉ cần đừng để nó vào Git
  for (const p of anBiMat(readFileSync(duongDan, "utf8")).phatHien) {
    soChoLo++;
    console.log(`${relative(thuMuc, duongDan)}:${p.dong}  ${p.loai} (bắt đầu bằng ${p.xemTruoc})`);
  }
}
const gitignore = existsSync(join(thuMuc, ".gitignore")) ? readFileSync(join(thuMuc, ".gitignore"), "utf8") : "";
if (existsSync(join(thuMuc, ".env")) && !/^\.env\b/m.test(gitignore)) {
  soChoLo++;
  console.log("CẢNH BÁO: có file .env nhưng .gitignore không loại trừ nó, nên git add . sẽ đưa token vào kho");
}
console.log(soChoLo === 0 ? "Không thấy gì đáng ngờ (nhưng đây chỉ là lưới lọc)." : `Có ${soChoLo} chỗ cần xử lý.`);
Quét dự án mẫu
node quet-thu-muc.ts --demo
Kết quả
src\chay-bot.ts:1  email (bắt đầu bằng an.n…)
src\chay-bot.ts:2  bot-token (bắt đầu bằng 1234…)
CẢNH BÁO: có file .env nhưng .gitignore không loại trừ nó, nên git add . sẽ đưa token vào kho
Có 3 chỗ cần xử lý.

Ba chỗ đó đúng là ba điều mình cố ý đặt vào: một email trong comment, một token viết thẳng vào chay-bot.ts ("dán tạm cho chạy thử"), và file .env không được loại trừ. Ở máy Linux hay macOS đường dẫn sẽ có dấu / thay cho \. File .env.example chứa your_token_here không bị báo, và file .env không bị quét nội dung, vì nó được phép chứa bí mật, chỉ cần đừng vào Git.

Dự án blog Tech Notes này cũng làm điều tương tự bằng lệnh npm run verify:governance. Script đó chạy lên mọi file mà Git sẽ commit và báo lỗi nếu có file .env thật hay có dòng khớp biểu thức này (mình chép nguyên văn từ code của nó):

Trích từ scripts/verify-governance.mjs của blog Tech Notes
const secretPattern = /(?:api[_-]?key|secret|token|password)\s*[:=]\s*["'](?!env\()[^"'\s]{12,}["']/i;

Phần (?!env\() là một ngoại lệ có lý do: file supabase/config.toml có những giá trị dạng env(NAME), tức là tham chiếu tới biến môi trường chứ không phải bí mật, và không có ngoại lệ đó thì kiểm tra báo lỗi nhầm. Nhưng khi mình thử biểu thức này với dòng SUPABASE_SERVICE_ROLE_KEY="..." (với giá trị giả), nó không bắt được, vì tên biến không chứa api_key, secret, token hay password. Bộ lọc của mình ở trên cũng bỏ sót đúng chỗ đó ở lần viết đầu, và chỉ nhờ một test mình mới thấy; bản bạn thấy ở trên đã thêm [_-]key vào danh sách tên. Bài học: dù viết bộ lọc nào, hãy thử với tên biến thật của dự án mình.

Lớp thứ hai là để công cụ AI không đọc được file bí mật ngay từ đầu. Với Claude Code, tài liệu cài đặt có mục permissions với danh sách deny, và ví dụ trong đó chặn đọc file .env. Trong file .claude/settings.json của dự án, dòng đó trông như sau:

.claude/settings.json
{
  "permissions": {
    "deny": ["Read(./.env)", "Read(./.env.*)"]
  }
}

Mình nên nói rõ giới hạn: lúc tìm hiểu mình thấy một số báo lỗi do người dùng gửi lên GitHub nói rằng luật chặn này không phải lúc nào cũng được áp dụng (ví dụ khi đường dẫn tuyệt đối, hoặc file JSON có lỗi cú pháp nên luật bị bỏ qua), và mình chưa kiểm chứng điều đó. Vì vậy mình coi nó là một lớp trong nhiều lớp, không phải lớp duy nhất. Bạn nên thử bằng cách yêu cầu công cụ đọc file .env rồi xem nó có từ chối không. Lớp cuối là chính GitHub: tài liệu về push protection nói rằng khi bạn đẩy code có chứa một loại bí mật mà họ nhận ra, GitHub sẽ chặn lần đẩy đó.

Lỡ lộ rồi thì làm gì?

Giả sử token bot đã nằm trong khung chat, hoặc đã vào Git. Việc đầu tiên không phải là xóa dấu vết mà là làm cho cái token đó vô dụng. Thứ tự dưới đây quan trọng:

  1. Thu hồi token ngay. Với bot Telegram, theo các hướng dẫn mình đọc, bạn mở @BotFather, chọn /mybots, chọn bot, vào mục API Token rồi bấm Revoke current token. Mình không có bot thật để thử trong bài này nên bạn hãy làm theo hướng dẫn hiện tại của Telegram.
  2. Tạo token mới và cập nhật nơi đang dùng nó (biến môi trường trên máy chủ, trên Vercel, trong CI). Cất nó vào đúng chỗ chứa bí mật, không vào code.
  3. Xem lịch sử sử dụng xem có hoạt động lạ trong khoảng thời gian token bị lộ không.
  4. Chỉ sau đó mới dọn lịch sử Git nếu bí mật đã bị commit.

Thu hồi phải đi trước, vì xóa dòng đó khỏi Git là chưa đủ: bản sao cũ vẫn nằm trong lịch sử, trong các bản clone và fork, và trong bất kỳ nơi nào chuỗi đó đã được sao chép. Chỉ khi token bị thu hồi thì những bản sao ấy mới hết giá trị. GitHub có một trang riêng về rủi ro khi bí mật bị lộ nếu bạn muốn đọc thêm.

Test cho bộ lọc, và những gì nó không làm được

Mình viết bảy test cho anBiMat (nằm ở repo demo): log mẫu cho đúng năm chỗ phát hiện và không còn giá trị gốc nào sau khi che, những thứ bình thường (mã commit, ngày, mã đơn, số tiền, số điện thoại thiếu hay thừa chữ số) không bị che nhầm, giá trị mẫu trong .env.example không bị báo, ba kiểu viết số điện thoại, khóa AWS mẫu và JWT, và việc SUPABASE_SERVICE_ROLE_KEY được che sau khi vá. Test cuối cùng ghi lại một giới hạn đã biết: một chuỗi bí mật hình dạng lạ, không có tên gợi ý, lọt qua.

Chạy test (trong repo demo)
node --test src/bi-mat.test.ts
Kết quả
# tests 7
# pass 7
# fail 0

Hãy hiểu đúng bộ lọc này. Nó giúp khi bạn vội, không giúp khi bạn cố ý hay khi bí mật có hình dạng lạ. Nó không biết "Nguyễn Văn An" là một người thật, và không biết đoạn code bạn sắp dán thuộc về công ty. Thứ tốt nhất vẫn là thói quen: không đưa bí mật vào những nơi nó dễ bị sao chép, tức là để khóa trong biến môi trường chứ không viết vào file code, và luôn nghĩ về chuyện đoạn này sẽ đi đâu trước khi dán.

Muốn chính app có tính năng AI thì sao?

Đến giờ AI chỉ là trợ lý của mình khi viết code. Nhưng app sổ chi tiêu có thể tự dùng AI: người dùng nhắn "ăn trưa 45k", và bot tự phân loại khoản chi. Khi đó dữ liệu của người dùng thật sẽ đi tới một dịch vụ AI mỗi lần họ nhắn, và mọi điều ở trên hóa thành câu hỏi về app của bạn chứ không chỉ về cách bạn làm việc. Việc đó là của các bài viết sau.

Bạn theo dõi cả hành trình ở Làm side project cùng AI. Nếu muốn nhớ lại cách đưa ngữ cảnh đúng cho AI khi debug, bài debug với AI có phần giải thích, và các câu hỏi về cách dùng AI khi lập trình nằm trong ngân hàng câu hỏi phỏng vấn.

Nhận bài tiếp theo qua email.

Một email mỗi tuần, chỉ khi có điều đáng đọc. Không spam.