Hướng dẫn sử dụng Polars trong Python: Xử lý dữ liệu lớn, dập tắt lỗi OOM thay thế Pandas

Python tutorial - IT technology blog
Python tutorial - IT technology blog

Bối cảnh: Đêm 2 giờ sáng và án tử Out Of Memory (OOM)

2 giờ 15 phút sáng, điện thoại rung dồn dập vì còi PagerDuty. Pod chạy batch job tổng hợp giao dịch trên cụm Kubernetes vừa chuyển sang màu đỏ lòm: CrashLoopBackOff.

Mở vội terminal check log bằng kubectl describe pod, dòng thông báo quen thuộc hiện ra:

Out of memory: Kill process 28415 (python3) score 942 or sacrifice child
Killed process 28415 (python3) total-vm:18452140kB, anon-rss:15984120kB

Thủ phạm không đâu xa: một cronjob Python dùng Pandas để đọc file CSV nặng 3.2 GB (~22 triệu dòng log). Node được cấp 16 GB RAM nhưng vẫn sập.

Vấn đề nằm ở cơ chế nạp eager evaluation của Pandas. Nó kéo toàn bộ dữ liệu vào bộ nhớ cùng lúc. Cộng thêm overhead từ Python object, mức RAM thực tế thường phình to gấp 4 đến 5 lần dung lượng file gốc trên đĩa. Chỉ cần thêm một lệnh merge hay tạo cột mới, OOM Killer của Linux Kernel sẽ trảm tiến trình ngay lập tức.

Tăng RAM cho worker node chỉ là cách chữa cháy tốn tiền. Mình quyết định viết lại pipeline bằng Polars — thư viện DataFrame viết bằng Rust trên nền tảng Apache Arrow. Điểm ăn tiền ở đây là Polars tận dụng đa nhân CPU (không dính GIL) và có cơ chế Lazy Evaluation để tối ưu truy vấn trước khi chạy.

Cài đặt Polars cho môi trường Production

Polars phân phối sẵn pre-built binary wheel. Bạn không cần cài Rust compiler lên container hay server staging.

Cài đặt gói core qua pip:

pip install --upgrade polars

Nếu pipeline cần đọc ghi Parquet hoặc kéo dữ liệu trực tiếp từ PostgreSQL/ClickHouse, hãy cài thêm các package sau:

pip install pyarrow connectorx fsspec

Lưu ý với VPS đời cũ: bản Polars chuẩn tận dụng tập lệnh AVX2. Nếu deploy trên chip cũ không hỗ trợ AVX2, hãy dùng bản build tương thích riêng:

pip install polars-lts-cpu

Chuyển đổi tư duy: Từ Eager sang Lazy Execution

Nhiều bạn mới qua Polars vẫn giữ thói quen gọi pl.read_csv(). Lệnh này vẫn kéo trọn dữ liệu vào RAM, chẳng khác gì Pandas. Muốn trị dứt điểm OOM, bạn phải dùng pl.scan_csv() hoặc pl.scan_parquet() để tạo LazyFrame.

Dưới đây là đoạn code thực tế mình viết lại để lọc log lỗi và tổng hợp doanh thu theo từng user:

import polars as pl

# 1. Khởi tạo LazyFrame - Chưa có byte dữ liệu nào được đọc vào RAM
lazy_df = pl.scan_csv(
    "/var/log/app/transactions_large.csv",
    has_header=True,
    separator=",",
    low_memory=True
)

# 2. Xây dựng Query Plan
query = (
    lazy_df
    .filter(pl.col("status") == "FAILED")
    .filter(pl.col("amount") > 0)
    .with_columns([
        pl.col("timestamp").str.strptime(pl.Datetime, "%Y-%m-%d %H:%M:%S"),
        pl.col("error_code").fill_null("UNKNOWN")
    ])
    # Trích xuất txn_id bằng Regex
    .with_columns(
        pl.col("raw_message").str.extract(r"TXN_([A-Z0-9]+)", 1).alias("txn_id")
    )
    .group_by(["user_id", "error_code"])
    .agg([
        pl.len().alias("fail_count"),
        pl.col("amount").sum().alias("total_failed_amount")
    ])
    .sort("fail_count", descending=True)
)

# 3. Kích hoạt tính toán dạng Streaming: Xử lý theo từng batch nhỏ
result_df = query.collect(streaming=True)

# Ghi kết quả ra định dạng Parquet
result_df.write_parquet("/var/log/app/summary_failed.parquet")
print("Job hoàn thành ngon lành, không chạm đỉnh RAM!")

Tip nhỏ về regex: đoạn TXN_([A-Z0-9]+) dùng để bóc transaction ID từ log thô. Lúc debug gấp giữa đêm, thay vì ngồi viết test script mất thời gian, mình paste nhanh mẫu log vào regex tester trên toolcraft.app/vi/tools/developer/regex-tester để kiểm tra group capture trực tiếp trên trình duyệt rồi mới ráp vào code.

Cơ chế nào giúp Lazy Execution tiết kiệm RAM?

  • Predicate Pushdown: Polars nhận diện bộ lọc status == 'FAILED' và áp dụng ngay trong lúc đọc file từ ổ cứng. Các dòng thành công bị bỏ qua ngay tại tầng I/O, không nạp vào bộ nhớ.
  • Projection Pushdown: File có 35 cột nhưng query chỉ dùng 5 cột? Polars sẽ chỉ parse đúng 5 cột đó, bỏ hẳn 30 cột còn lại.
  • Streaming Engine: Khi gọi collect(streaming=True), Polars chia nhỏ dữ liệu thành từng batch nhỏ vừa vặn với L3 cache và RAM. Nhờ đó, file 50 GB vẫn có thể chạy mượt trên máy 8 GB RAM.

Đo đạc Benchmark: Polars vs Pandas trên server production

Trước khi đóng ticket incident, mình tiến hành benchmark lại hai giải pháp trên cùng file log 3.2 GB.

1. Kiểm tra Query Plan trước khi chạy

Để chắc chắn Polars đã đẩy các bước lọc xuống tầng đọc đĩa, hãy in plan bằng lệnh:

print(query.explain())

Nếu thấy mục SELECTION: None ở tầng trên và xuất hiện PROJECT 5/35 COLUMNS cùng PREDICATE ở tầng dưới, query của bạn đã được tối ưu chuẩn.

2. Đo tài nguyên thực tế với psutil

import time
import psutil
import os

def get_mem_mb():
    return psutil.Process(os.getpid()).memory_info().rss / (1024 * 1024)

start_time = time.time()
print(f"RAM ban đầu: {get_mem_mb():.1f} MB")

df = query.collect(streaming=True)

print(f"RAM đỉnh điểm: {get_mem_mb():.1f} MB")
print(f"Thời gian xử lý: {time.time() - start_time:.2f}s")

Kết quả thực tế trên VM 8 vCPU, 16 GB RAM

  • Pandas 2.2: Ngốn đỉnh điểm 15.2 GB RAM. Thời gian chạy 84 giây. Nguy cơ OOM cao nếu có service khác chạy cùng lúc.
  • Polars 0.20 (Streaming): Đỉnh RAM dừng ở mức 820 MB. Thời gian chạy rút xuống còn 11.2 giây. Cả 8 core CPU đều được tận dụng đều đặn ở mức 90-95%.

Sau đêm đó, team mình chuyển đổi toàn bộ pipeline xử lý file từ 500 MB trở lên sang Polars. Kết quả: cluster Kubernetes chạy êm ru, pod limit giảm từ 16 GB xuống 2 GB, tiết kiệm ngay vài trăm USD tiền cloud mỗi tháng.

Share: