Nén ảnh trước khi upload: từ 8,7 MB xuống 440 KB cho blog

Nén ảnh trước khi upload cho blog Next.js: thu nhỏ còn 1600 px, đổi sang WebP, bỏ EXIF và GPS. Có số đo thật, bẫy ảnh dọc bị nằm ngang và code của blog.

Nén ảnh trước khi upload gồm ba việc: thu nhỏ kích thước về mức đủ cho trang, đổi sang định dạng gọn như WebP, và bỏ metadata như vị trí GPS. Việc thứ nhất giảm nhiều nhất. Bạn có muốn ảnh 8,7 MB chỉ còn khoảng 440 KB không? Cùng mình đo nhé!

Một bức ảnh nặng làm gì với kho lưu trữ miễn phí?

Ở bài trước, mình làm cho blog một ô soạn bài viết và xem trước được. Ô đó mới xử lý chữ, trong khi một bài viết thật có ảnh chụp màn hình, mà ảnh chụp thường nặng. Mình cần sửa một chi tiết ở bài trước: mình viết là nơi lưu trữ miễn phí có 500 MB. Theo trang giá của Supabase (mình xem ngày 12/11/2026), gói Free có 500 MB cho database và 1 GB cho file storage, tính riêng nhau. Ảnh nằm ở file storage, nên con số đúng là 1 GB.

Một GB nghe nhiều, nhưng với ảnh gốc thì nhanh hết. Với ảnh thử 8,7 MB mà mình dùng ở bài này, 1 GB chứa được khoảng 117 ảnh. Còn nếu mỗi ảnh chỉ nặng 440 KB thì chứa được hơn hai nghìn ảnh. Chưa kể người đọc dùng điện thoại phải tải 8,7 MB cho mỗi ảnh, một con số lớn với mạng di động.

Chuyện này không chỉ là lý thuyết với blog này. Trong lịch sử Git của dự án, commit a60e584 ngày 4/11/2026 ghi lại đúng vấn đề: ảnh tải lên được lưu nguyên kích thước, vài tấm ảnh chụp màn hình đã chiếm vài MB mỗi tấm. Commit đó thêm bước thu nhỏ ảnh ngay trong trình duyệt của tác giả trước khi gửi lên Supabase, và message của nó ghi một ảnh chụp màn hình PNG nặng 14 MB còn khoảng 340 KB. Con số đó là số ghi trong commit, mình không đo lại. Ở bài này mình đo trên một ảnh thử có thể tạo lại được, để bạn thấy phần nào của việc nén có tác dụng và phần nào không.

Chuẩn bị: một ảnh thử và các hàm đo

Bạn cần Node.js 22.18 trở lên (Node chạy thẳng file .ts từ bản đó). Tạo thư mục nen-anh với cấu trúc dưới đây, rồi chạy npm install:

Cấu trúc thư mục
nen-anh/
  package.json
  src/tao-anh-thu.ts
  src/anh.ts
  src/nen-anh.ts
  src/do-nen.ts
  src/thu-xoay.ts
  tmp/            (ảnh thử sẽ nằm ở đây)
package.json
{
  "name": "nen-anh",
  "private": true,
  "type": "module",
  "dependencies": { "exif-reader": "2.0.2", "sharp": "0.35.5" },
  "devDependencies": { "vitest": "5.1.0" }
}

sharp là thư viện xử lý ảnh cho Node.js, chạy rất nhanh vì nó dùng thư viện libvips viết bằng C bên dưới. exif-reader chỉ để mình đọc metadata cho dễ nhìn.

Script đầu tiên tạo một ảnh thử 6000x4000, giống ảnh điện thoại: có chi tiết ở nhiều cỡ (mảng màu lớn, vân, hạt mịn), và có metadata EXIF với tên máy lẫn vị trí GPS. Mình tạo ảnh bằng code, nên nó không phải ảnh chụp thật. Tỉ lệ nén trên ảnh của bạn sẽ khác, và thậm chí ảnh này mỗi lần tạo lại hơi lệch (khoảng 8,7 đến 8,8 MB) vì nó dùng nhiễu ngẫu nhiên:

src/tao-anh-thu.ts
// Tạo một ảnh thử lớn, giống ảnh chụp từ điện thoại: chi tiết ở nhiều cỡ (mảng màu lớn, vân, hạt), nhiễu cảm biến, kèm metadata
// EXIF có tên máy và vị trí GPS. Ảnh được tạo bằng code, không phải ảnh chụp thật, nên số liệu của bạn sẽ khác với ảnh của bạn.
// Chạy: node src/tao-anh-thu.ts <đường-dẫn-file.jpg>
import sharp from "sharp";

export const ANH_THU = { width: 6000, height: 4000 };

// Một lớp nhiễu ở "cỡ hạt" cho trước: tạo nhiễu nhỏ rồi phóng to. Hạt càng lớn thì mảng màu càng to.
async function lopNhieu(coHat: number, bienDo: number): Promise<Buffer> {
  const { width, height } = ANH_THU;
  return sharp({ create: { width: Math.ceil(width / coHat), height: Math.ceil(height / coHat), channels: 3, background: "#808080", noise: { type: "gaussian", mean: 128, sigma: bienDo } } })
    .resize(width, height, { kernel: "cubic" }).png().toBuffer();
}

export async function taoAnhThu(file: string): Promise<void> {
  const cacLop = await Promise.all([[400, 70], [120, 60], [40, 55], [12, 50], [4, 40], [1, 22]].map(([coHat, bienDo]) => lopNhieu(coHat, bienDo)));
  await sharp(cacLop[0])
    .composite(cacLop.slice(1).map((input) => ({ input, blend: "soft-light" as const })))
    .modulate({ saturation: 1.6 })
    .withExif({
      IFD0: { Make: "DemoCam", Model: "Moc-1", Software: "tao-anh-thu.ts" },
      IFD3: { GPSLatitudeRef: "N", GPSLatitude: "10/1 46/1 30/1", GPSLongitudeRef: "E", GPSLongitude: "106/1 42/1 0/1" },
    })
    .jpeg({ quality: 92 })
    .toFile(file);
}

if (import.meta.main) {
  const file = process.argv[2];
  if (!file) throw new Error("Cách dùng: node src/tao-anh-thu.ts <đường-dẫn-file.jpg>");
  await taoAnhThu(file);
  const info = await sharp(file).metadata();
  console.log(`Đã tạo ${file}: ${info.width}x${info.height}`);
}
Tạo ảnh thử
mkdir tmp
node src/tao-anh-thu.ts tmp/anh-thu.jpg
Kết quả
Đã tạo tmp/anh-thu.jpg: 6000x4000

Bốn cách nén, và con số thật

Trước khi viết code nén chính thức, mình muốn biết cách nào đáng làm. Script do-nen.ts lấy cùng một ảnh, nén bốn cách, rồi in kích thước, thời gian và xem metadata còn lại không. Nó dùng hàm fitWithin (thu nhỏ theo cạnh dài, không phóng to) và formatBytes trong src/anh.ts. Mình đưa cả file đó vào đây vì phần sau còn dùng:

src/anh.ts
// Các quyết định thuần (không đụng tới ảnh thật) của bước nén ảnh. Cùng logic với src/lib/image-optimize.ts của blog Tech Notes,
// ở đó việc vẽ ảnh chạy trong trình duyệt; ở đây ta dùng sharp trên Node để đo cho dễ.

// Rộng hơn cột bài viết (720 px) gấp đôi để ảnh còn nét trên màn hình retina.
export const MAX_IMAGE_WIDTH = 1600;

// Thu nhỏ cho cạnh dài nhất vừa `max`, giữ tỉ lệ. Không bao giờ phóng to.
export function fitWithin(width: number, height: number, max = MAX_IMAGE_WIDTH): { width: number; height: number } {
  const longest = Math.max(width, height);
  if (longest <= max) return { width, height };
  const scale = max / longest;
  return { width: Math.max(1, Math.round(width * scale)), height: Math.max(1, Math.round(height * scale)) };
}

// GIF có thể là ảnh động; nén lại sẽ làm nó đứng hình, nên để nguyên.
export function shouldOptimize(type: string): boolean {
  return ["image/jpeg", "image/png", "image/webp", "image/avif"].includes(type);
}

// Giữ bản gốc nếu nén xong mà không nhỏ hơn (ảnh vốn đã nhỏ và nén tốt).
// Riêng ảnh đã bị thu nhỏ kích thước thì phải dùng bản mới, kể cả khi nặng hơn, để kích thước lưu khớp với bài viết.
export function pickSmaller<T extends { size: number }>(original: T, optimized: T | null, resized: boolean): T {
  if (!optimized) return original;
  if (resized) return optimized;
  return optimized.size < original.size ? optimized : original;
}

export function formatBytes(bytes: number): string {
  if (bytes < 1024) return `${bytes} B`;
  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
  return `${(bytes / (1024 * 1024)).toLocaleString("vi-VN", { maximumFractionDigits: 1 })} MB`;
}
src/do-nen.ts
// Đo: cùng một ảnh, nén theo các cách khác nhau thì còn bao nhiêu? Chạy: node src/do-nen.ts <file-ảnh.jpg>
import { readFile } from "node:fs/promises";
import exifReader from "exif-reader";
import sharp from "sharp";

import { fitWithin, formatBytes } from "./anh.ts";

const file = process.argv[2];
if (!file) throw new Error("Cách dùng: node src/do-nen.ts <file-ảnh.jpg>");
const goc = await readFile(file);
const meta = await sharp(goc).metadata();
const exif = meta.exif ? exifReader(meta.exif) : undefined;
console.log(`Ảnh gốc: ${meta.width}x${meta.height}, ${formatBytes(goc.length)}, máy: ${exif?.Image?.Make} ${exif?.Image?.Model}, GPS: ${exif?.GPSInfo ? "có" : "không"}`);

const { width, height } = fitWithin(meta.width!, meta.height!);
const cachNen: [string, () => Promise<Buffer>][] = [
  ["JPEG q82, giữ kích thước gốc", () => sharp(goc).jpeg({ quality: 82 }).toBuffer()],
  [`JPEG q82, thu nhỏ còn ${width}x${height}`, () => sharp(goc).resize(width, height).jpeg({ quality: 82 }).toBuffer()],
  [`WebP q82, thu nhỏ còn ${width}x${height}`, () => sharp(goc).resize(width, height).webp({ quality: 82 }).toBuffer()],
  [`AVIF q50, thu nhỏ còn ${width}x${height}`, () => sharp(goc).resize(width, height).avif({ quality: 50 }).toBuffer()],
];
for (const [ten, chay] of cachNen) {
  const batDau = performance.now();
  const ra = await chay();
  const thongTin = await sharp(ra).metadata();
  console.log(`${ten}: ${formatBytes(ra.length)} (${Math.round(performance.now() - batDau)} ms, còn EXIF: ${thongTin.exif ? "có" : "không"})`);
}
Đo bốn cách nén
node src/do-nen.ts tmp/anh-thu.jpg
Kết quả (số của bạn sẽ lệch nhẹ)
Ảnh gốc: 6000x4000, 8,7 MB, máy: DemoCam Moc-1, GPS: có
JPEG q82, giữ kích thước gốc: 4,3 MB (155 ms, còn EXIF: không)
JPEG q82, thu nhỏ còn 1600x1067: 440 KB (102 ms, còn EXIF: không)
WebP q82, thu nhỏ còn 1600x1067: 446 KB (241 ms, còn EXIF: không)
AVIF q50, thu nhỏ còn 1600x1067: 216 KB (934 ms, còn EXIF: không)

Mình có mấy nhận xét sau khi nhìn bốn dòng này. Cách thứ nhất, chỉ nén lại JPEG mà giữ nguyên 6000x4000, đưa ảnh từ 8,7 MB xuống 4,3 MB, tức giảm một nửa, nhưng vẫn quá nặng cho một ảnh trong bài. Cách thứ hai, thu nhỏ về 1600 px, mới là bước làm giảm mạnh: từ 4,3 MB xuống 440 KB, khoảng mười lần. Lý do dễ hiểu: số điểm ảnh giảm từ 24 triệu xuống khoảng 1,7 triệu, tức ít hơn mười bốn lần. Cột bài viết của blog rộng 720 px, và mình chọn 1600 px để ảnh còn nét trên màn hình retina (mật độ điểm ảnh gấp đôi), nên người đọc không phân biệt được ảnh 1600 px với ảnh 6000 px.

Điều làm mình hơi bất ngờ là WebP gần như không nhỏ hơn JPEG trên ảnh này (446 KB so với 440 KB). WebP thường được nói là nhỏ hơn JPEG, và với ảnh chụp thật thì có thể đúng. Nhưng ảnh thử của mình là ảnh nhân tạo, nên đừng suy ra rằng WebP luôn hơn JPEG từ đây. Điều mình chắc là con số của bạn phải đo trên ảnh của bạn. AVIF cho kết quả nhỏ nhất (216 KB), nhưng mất 934 ms, gấp gần bốn lần WebP. Với một thao tác lúc tác giả tải ảnh lên thì một giây không sao, còn nếu chạy hàng loạt trên máy chủ thì đó là chi phí đáng kể.

Cuối cùng, cả bốn dòng đều ghi "còn EXIF: không". Đó là điều mình sẽ giải thích ngay.

Metadata và hai cái bẫy

Dòng đầu tiên của kết quả trên cho thấy ảnh gốc mang theo tên máy và vị trí GPS. Ảnh chụp từ điện thoại thường mang cả vị trí nơi chụp, và nếu bạn đăng thẳng lên blog công khai thì ai tải ảnh về cũng đọc được nó. Khi nén bằng sharp, theo mặc định metadata không được giữ lại, nên cả bốn bản nén đều sạch. Với bước nén của blog, trình duyệt vẽ lại ảnh lên canvas nên kết quả cũng không còn EXIF. Mình xem đây là một lợi ích phụ đáng giá không kém việc giảm dung lượng.

Nhưng chính việc bỏ metadata tạo ra cái bẫy thứ nhất. EXIF không chỉ có tên máy và GPS, nó còn có thẻ Orientation. Điện thoại thường lưu ảnh chụp dọc thành pixel nằm ngang, kèm thẻ "xoay 90° khi hiển thị". Nếu bạn bỏ EXIF mà chưa xoay pixel, ảnh sẽ hiện nằm ngang. Script dưới đây tạo một ảnh như vậy rồi cho thấy hai cách xử lý, và dùng hàm nenAnh mà mình sẽ đưa ngay sau:

src/thu-xoay.ts
// Ảnh chụp dọc từ điện thoại thường được lưu thành pixel nằm ngang kèm thẻ EXIF Orientation = 6 ("xoay 90° khi hiển thị").
// Nếu bỏ EXIF mà không xoay pixel trước, ảnh sẽ nằm ngang. Chạy: node src/thu-xoay.ts
import sharp from "sharp";

import { nenAnh } from "./nen-anh.ts";

const anhDoc = await sharp({ create: { width: 3000, height: 2000, channels: 3, background: "#c0392b" } })
  .jpeg().withMetadata({ orientation: 6 }).toBuffer();

const meta = await sharp(anhDoc).metadata();
console.log(`Ảnh gốc: pixel ${meta.width}x${meta.height}, Orientation ${meta.orientation} (trình xem ảnh sẽ hiển thị ${meta.height}x${meta.width})`);

const sai = await sharp(anhDoc).resize({ width: 1600, height: 1600, fit: "inside" }).webp().toBuffer({ resolveWithObject: true });
console.log(`Bỏ EXIF, không xoay: ${sai.info.width}x${sai.info.height}, không còn Orientation nên ảnh hiển thị nằm ngang`);

const dung = await nenAnh(anhDoc);
console.log(`nenAnh (xoay trước): ${dung.width}x${dung.height}`);
Thử ảnh chụp dọc
node src/thu-xoay.ts
Kết quả
Ảnh gốc: pixel 3000x2000, Orientation 6 (trình xem ảnh sẽ hiển thị 2000x3000)
Bỏ EXIF, không xoay: 1600x1067, không còn Orientation nên ảnh hiển thị nằm ngang
nenAnh (xoay trước): 1067x1600

Dòng thứ hai và thứ ba là chỗ cần nhìn: cùng một ảnh, cách bỏ EXIF thẳng tay cho ra ảnh 1600x1067 (nằm ngang, sai), còn nenAnh cho ra 1067x1600 (dọc, đúng). Đây là hàm nenAnh, nơi mọi thứ được ghép lại:

src/nen-anh.ts
// Nén một ảnh: xoay đúng chiều theo EXIF, thu nhỏ tối đa 1600 px, đổi sang WebP. Metadata (máy, GPS) không được giữ lại.
import sharp from "sharp";

import { fitWithin, MAX_IMAGE_WIDTH, pickSmaller } from "./anh.ts";

export type KetQua = { buffer: Buffer; type: string; width: number; height: number; size: number };

export async function nenAnh(input: Buffer, max = MAX_IMAGE_WIDTH): Promise<KetQua> {
  // rotate() không đối số: xoay pixel theo thẻ Orientation của EXIF. Phải làm trước khi bỏ EXIF, nếu không ảnh chụp dọc sẽ nằm ngang.
  const upright = await sharp(input).rotate().toBuffer({ resolveWithObject: true });
  const { width, height } = fitWithin(upright.info.width, upright.info.height, max);
  const resized = width !== upright.info.width;
  const webp = await sharp(upright.data).resize(width, height).webp({ quality: 82 }).toBuffer({ resolveWithObject: true });
  const optimized: KetQua = { buffer: webp.data, type: "image/webp", width, height, size: webp.data.length };
  const dinhDang = (await sharp(input).metadata()).format;
  const original: KetQua = { buffer: input, type: `image/${dinhDang}`, width: upright.info.width, height: upright.info.height, size: input.length };
  return pickSmaller(original, optimized, resized);
}

Hàm này làm bốn bước: xoay pixel theo EXIF (rotate() không đối số), tính kích thước mới bằng fitWithin, đổi sang WebP chất lượng 82, rồi dùng pickSmaller để chọn. Cái bẫy thứ hai nằm ở bước cuối. Với một ảnh vốn đã nhỏ và nén tốt, ví dụ ảnh 40x40 điểm, nén lại có thể ra file lớn hơn, và chọn bản đó là làm ngược mục đích. Vì vậy pickSmaller giữ bản gốc nếu bản nén không nhỏ hơn. Có một ngoại lệ mà mình thêm có chủ đích: nếu ảnh đã bị thu nhỏ kích thước thì phải dùng bản mới, kể cả nặng hơn, vì kích thước ghi trong bài viết phải khớp với file thật.

GIF là trường hợp thứ ba. Một file GIF có thể là ảnh động, và nén lại như ảnh tĩnh sẽ làm nó đứng hình. Hàm shouldOptimize chỉ cho JPEG, PNG, WebP và AVIF đi qua bước nén, còn GIF được tải lên nguyên vẹn.

Test để khóa các quyết định

Các quyết định ở trên đều có thể sai âm thầm: không có lỗi nào hiện ra, chỉ là ảnh nặng hơn hay nằm ngang hơn. Vì vậy mình viết test cho từng cái. Đây là test cho nenAnh (file test cho các hàm thuần trong anh.ts có thêm các trường hợp biên như ảnh nhỏ hơn giới hạn không bị phóng to):

src/nen-anh.test.ts
import sharp from "sharp";
import { expect, test } from "vitest";

import { nenAnh } from "./nen-anh.ts";

const anh = (width: number, height: number, orientation?: number) =>
  sharp({ create: { width, height, channels: 3, background: "#3366cc" } }).jpeg().withMetadata(orientation ? { orientation } : {}).toBuffer();

test("ảnh lớn được thu nhỏ còn 1600 px và đổi sang WebP", async () => {
  const ketQua = await nenAnh(await anh(4000, 3000));
  expect(ketQua).toMatchObject({ type: "image/webp", width: 1600, height: 1200 });
});

test("ảnh chụp dọc (Orientation 6) được xoay đúng chiều trước khi bỏ EXIF", async () => {
  const ketQua = await nenAnh(await anh(3000, 2000, 6));
  expect(ketQua.width).toBe(1067);
  expect(ketQua.height).toBe(1600);
  expect((await sharp(ketQua.buffer).metadata()).orientation).toBeUndefined();
});

test("ảnh nhỏ mà nén xong không nhỏ hơn thì giữ bản gốc", async () => {
  const goc = await sharp({ create: { width: 40, height: 40, channels: 3, background: "#fff" } }).webp({ quality: 1, effort: 6 }).toBuffer();
  const ketQua = await nenAnh(goc);
  expect(ketQua.buffer).toBe(goc);
});
Chạy test
npx vitest run src/nen-anh.test.ts
Kết quả
 Test Files  1 passed (1)
      Tests  3 passed (3)

Trong repo demo mình còn có thêm một file anh.test.ts với chín test cho các hàm thuần (thu nhỏ theo cạnh dài, không phóng to, ảnh dẹt không bị làm tròn về 0, bốn trường hợp của pickSmaller, GIF và formatBytes). Chạy cả hai file thì được 12 test xanh. Bạn có thể tự viết lại chúng từ các quy tắc trong anh.ts, vì mỗi hàm đều nhỏ.

Vậy blog này nén ở đâu: trình duyệt hay máy chủ?

Ở bài này mình chạy sharp trên Node cho dễ đo, nhưng blog Tech Notes nén ngay trong trình duyệt của tác giả, trước khi ảnh đi ra mạng. Lý do là mình muốn tải ít byte nhất khi tác giả upload, và không muốn chạy một hàm xử lý ảnh trên máy chủ chỉ để gọt một ảnh mà tác giả sẽ không bao giờ tải lại. Đây là đoạn trích hàm vẽ lại ảnh trong src/components/admin/editor/upload-image.ts của blog (mình giữ nguyên chú thích tiếng Anh của file gốc):

src/components/admin/editor/upload-image.ts (trích)
async function encode(bitmap: ImageBitmap, width: number, height: number): Promise<Blob | null> {
  // Redrawing also drops EXIF metadata (camera, GPS location) from phone photos.
  if (typeof OffscreenCanvas !== "undefined") {
    const canvas = new OffscreenCanvas(width, height);
    const context = canvas.getContext("2d");
    if (!context) return null;
    context.drawImage(bitmap, 0, 0, width, height);
    try {
      const blob = await canvas.convertToBlob({ type: OPTIMIZED_TYPE, quality: WEBP_QUALITY });
      return blob.type === OPTIMIZED_TYPE ? blob : null;
    } catch {
      return null;
    }
  }
  // (nhánh dự phòng dùng canvas thường và toBlob, cùng cách làm)
}

Hai điều đáng để ý. Thứ nhất, drawImage vẽ lên canvas nên metadata tự mất, đúng như chú thích. Thứ hai, dòng blob.type === OPTIMIZED_TYPE ? blob : null phòng trường hợp trình duyệt không mã hóa được WebP và âm thầm trả về một định dạng khác. Khi đó hàm trả null, và pickSmaller giữ ảnh gốc, nên trình soạn bài không bao giờ lưu một ảnh nặng hơn nó nhận. Hàm fitWithin, shouldOptimize và pickSmaller trong src/lib/image-optimize.ts của blog là bản gốc của những gì bạn vừa chạy, nên test chúng trên Node được.

Cách nén trên máy chủ cũng hợp lý, nhất là khi người dùng không phải tác giả đáng tin, hoặc khi bạn muốn nhiều kích thước cho nhiều màn hình. Cái giá là hàm xử lý ảnh chạy trên máy chủ của bạn, tốn thời gian và bộ nhớ. Còn thành phần next/image của Next.js cũng thu nhỏ ảnh, nhưng nó làm lúc ảnh được phục vụ cho người đọc, và ảnh gốc 8,7 MB vẫn nằm nguyên trong kho lưu trữ của bạn. Vì vậy nó giải quyết chuyện tải trang, không giải quyết chuyện kho đầy.

Ảnh nhẹ rồi, nhưng người đọc tìm thấy blog bằng cách nào?

Đến đây blog đã có trình soạn bài an toàn, ảnh đã gọn, và kho lưu trữ đủ cho hàng nghìn tấm. Nhưng vẫn còn một chuyện: Google chưa biết blog này tồn tại, và các bài viết chưa có tiêu đề, mô tả hay sơ đồ trang để máy tìm kiếm đọc. Cách làm cho một blog Next.js được tìm thấy là việc của các bài viết sau.

Bạn theo dõi cả series ở Xây blog với Next.js + Supabase. Nếu đang ôn phỏng vấn, các câu hỏi về Next.js, React và hiệu năng web có 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.