Roadmap Docker: Đóng Gói Công Cụ Dòng Lệnh với Docker

Chào mừng quay trở lại với series “Roadmap Docker”! Sau khi đã cùng nhau khám phá Container là gì, sự khác biệt giữa Container, VM và Bare Metal, tiêu chuẩn OCI, các kỹ năng Linux cốt lõi, Package Managers, quản lý người dùng và quyền hạn, các lệnh Shell, tự động hóa với Shell script, và thậm chí là cả nền tảng web, lựa chọn ngôn ngữ, kiến trúc ứng dụng, và sâu hơn về Namespaces, cgroups, UnionFS, cách cài đặt Docker Engine, quản lý dữ liệu bền vững với Volume Mounts và Bind Mounts, sử dụng image bên thứ ba an toàn, chạy cơ sở dữ liệu trong Docker và cả môi trường kiểm thử, giờ là lúc chúng ta khám phá một ứng dụng thực tế khác của Docker mà có thể bạn chưa nghĩ đến: đóng gói các công cụ dòng lệnh (CLI – Command Line Interface).

Nếu bạn đã từng vật lộn với “địa ngục phụ thuộc” (dependency hell) khi cài đặt một công cụ CLI nào đó – nào là phiên bản Python không đúng, thư viện bị thiếu, xung đột giữa các phiên bản của cùng một phần mềm – thì bài viết này chính là dành cho bạn. Docker không chỉ dùng để chạy ứng dụng web hay microservice. Nó là một công cụ mạnh mẽ để tiêu chuẩn hóa môi trường, và điều này cực kỳ hữu ích cho các công cụ dòng lệnh.

Tại Sao Phải Đóng Gói Công Cụ Dòng Lệnh Trong Docker?

Bạn có một công cụ dòng lệnh tuyệt vời, có thể là trình biên dịch, trình phân tích code tĩnh, công cụ triển khai (deploy tool), hay đơn giản chỉ là một script tùy chỉnh. Vấn đề nảy sinh khi bạn cần chia sẻ nó với đồng đội, chạy trên CI/CD, hoặc thậm chí là chạy lại nó sau một thời gian dài. Môi trường khác nhau dẫn đến kết quả khác nhau, hoặc thậm chí là không chạy được. Đây là lúc Docker tỏa sáng.

Dưới đây là những lợi ích chính khi đóng gói CLI trong Docker:

• Tính Nhất Quán Môi Trường: Đảm bảo công cụ luôn chạy trong cùng một môi trường được định nghĩa sẵn, bất kể hệ điều hành hay cấu hình máy chủ nào.
• Cách Ly Phụ Thuộc: Tránh xung đột phiên bản phần mềm. Mỗi công cụ CLI có thể có bộ thư viện và phiên bản phụ thuộc riêng biệt trong container của nó mà không ảnh hưởng đến hệ thống host hay các container khác.
• Tính Di Động Cao: Chạy công cụ trên bất kỳ máy nào có Docker Engine được cài đặt. Không cần cài đặt phức tạp các phụ thuộc trên từng máy.
• Đơn Giản Hóa Thiết Lập: Chỉ cần lệnh docker run hoặc một script nhỏ là có thể sử dụng ngay, thay vì phải làm theo một danh sách dài các bước cài đặt thủ công.
• Quản Lý Phiên Bản: Mỗi image Docker đại diện cho một phiên bản cụ thể của công cụ CLI. Dễ dàng chuyển đổi giữa các phiên bản khác nhau.
• Bảo Mật: Chạy công cụ trong môi trường cách ly giúp giảm thiểu rủi ro bảo mật cho hệ thống host.
• Phân Phối Dễ Dàng: Chia sẻ công cụ đã được đóng gói dưới dạng Docker Image qua các registry như Docker Hub, GitLab Registry, hoặc Artifactory.

Nói một cách khác, bạn đang biến công cụ CLI của mình thành một “binary portable” (file thực thi di động), nhưng thay vì chỉ là một file, nó là cả một môi trường hoàn chỉnh.

Cách Tiếp Cận Cơ Bản: Sử Dụng Image Sẵn Có

Trường hợp đơn giản nhất là khi công cụ CLI bạn cần đã có sẵn image Docker chính thức hoặc được cộng đồng tin cậy cung cấp. Ví dụ, curl là một công cụ dòng lệnh phổ biến. Bạn có thể chạy curl từ một container Ubuntu mà không cần cài đặt nó trên máy host:

docker run --rm ubuntu:latest curl -s https://example.com

Lệnh này:

• docker run: Chạy một container mới.
• --rm: Tự động xóa container sau khi nó kết thúc (rất tiện cho các tác vụ ngắn).
• ubuntu:latest: Sử dụng image Ubuntu mới nhất làm nền.
• curl -s https://example.com: Lệnh sẽ được thực thi bên trong container. Nếu curl chưa có sẵn trong image Ubuntu, lệnh sẽ báo lỗi.

Để chạy một công cụ đã được cài đặt sẵn trong image, như git chẳng hạn:

docker run --rm alpine/git clone <repo_url>

Trong ví dụ này, image alpine/git đã được xây dựng sẵn để chứa công cụ git. Khi chạy container từ image này, lệnh clone <repo_url> sẽ được truyền làm đối số cho lệnh mặc định (hoặc ENTRYPOINT) của image.

Tuy nhiên, cách này vẫn hơi dài dòng. Mỗi lần chạy bạn phải gõ docker run .... Chúng ta sẽ giải quyết vấn đề này sau.

Đóng Gói Công Cụ CLI Tùy Chỉnh Bằng Dockerfile

Nếu công cụ CLI của bạn không có image sẵn, hoặc bạn cần một cấu hình đặc thù, bạn sẽ cần tạo Dockerfile của riêng mình. Đây là quy trình chuẩn để xây dựng image Docker.

Hãy tưởng tượng bạn có một script Python đơn giản tên là hello.py:

# hello.py
import sys

if __name__ == "__main__":
    name = "World"
    if len(sys.argv) > 1:
        name = sys.argv[1]
    print(f"Hello, {name}!")

Bạn muốn đóng gói script này cùng với Python runtime để nó có thể chạy ở bất kỳ đâu.

Dockerfile:

# Sử dụng image Python nhẹ nhàng làm nền
FROM python:3.9-alpine

# Sao chép script vào container
COPY hello.py /app/hello.py

# Đặt thư mục làm việc
WORKDIR /app

# Lệnh mặc định khi chạy container
# ENTRYPOINT sẽ biến container thành một "executable"
ENTRYPOINT ["python", "/app/hello.py"]

# CMD cung cấp đối số mặc định nếu không có đối số nào được truyền khi chạy
CMD ["World"]

Giải thích các bước:

• FROM python:3.9-alpine: Bắt đầu từ image Python 3.9 dựa trên Alpine Linux. Alpine là một bản phân phối Linux rất nhỏ gọn, lý tưởng cho các image Docker cần kích thước nhỏ. (Nhắc lại kiến thức về Linux cốt lõi và Package Managers – Alpine sử dụng apk).
• COPY hello.py /app/hello.py: Sao chép file script từ thư mục hiện tại (trên máy host) vào thư mục `/app/` bên trong container.
• WORKDIR /app: Thiết lập `/app` làm thư mục làm việc mặc định cho các lệnh sau (RUN, CMD, ENTRYPOINT).
• ENTRYPOINT ["python", "/app/hello.py"]: Đây là lệnh chính sẽ được thực thi khi container bắt đầu. Nó định nghĩa “nhiệm vụ” của container. Khi bạn chạy container và truyền đối số, các đối số đó sẽ được thêm vào sau lệnh này. Ví dụ: docker run my-hello-cli John sẽ chạy python /app/hello.py John.
• CMD ["World"]: Cung cấp đối số mặc định cho ENTRYPOINT nếu không có đối số nào được truyền từ lệnh docker run. Nếu chạy docker run my-hello-cli, lệnh đầy đủ sẽ là python /app/hello.py World.

Để xây dựng image từ Dockerfile này:

docker build -t my-hello-cli .

Lệnh này sẽ xây dựng một image và đặt tên (tag) là my-hello-cli.

Bây giờ, bạn có thể chạy công cụ CLI đã được đóng gói:

docker run --rm my-hello-cli

Kết quả: Hello, World!

docker run --rm my-hello-cli Alice

Kết quả: Hello, Alice!

Thật gọn gàng phải không nào?

Ví Dụ Khác: Đóng Gói một Công Cụ Node.js

Giả sử bạn có một công cụ CLI viết bằng Node.js và được publish lên npm. Ví dụ, công cụ cowsay.

Dockerfile:

FROM node:16-alpine

# Cài đặt cowsay toàn cục
RUN npm install -g cowsay

# Đặt ENTRYPOINT là lệnh cowsay
ENTRYPOINT ["cowsay"]

# CMD cung cấp văn bản mặc định
CMD ["Moo!"]

Xây dựng image:

docker build -t my-cowsay-cli .

Chạy thử:

docker run --rm my-cowsay-cli "Hello Docker!"

Bạn sẽ thấy chú bò nói “Hello Docker!” mà không cần cài đặt Node.js hay cowsay trên máy host.

Biến Container Thành “Native” CLI

Gõ docker run --rm my-tool args... mỗi lần thật bất tiện. Chúng ta muốn chạy nó như một lệnh bình thường: my-tool args.... Có hai cách chính để làm điều này:

1. Sử Dụng Alias

Cách đơn giản nhất là tạo một alias trong shell của bạn (ví dụ: .bashrc, .zshrc):

alias my-hello-cli='docker run --rm my-hello-cli'
alias my-cowsay='docker run --rm my-cowsay-cli'

Sau khi tải lại cấu hình shell (hoặc mở terminal mới), bạn có thể gõ:

my-hello-cli Bob

my-cowsay "Docker is awesome"

Ưu điểm: Rất nhanh và đơn giản.
Nhược điểm: Chỉ hoạt động trên máy cục bộ của bạn, cần thiết lập trên mỗi máy, không linh hoạt khi cần truyền thêm các cờ (flags) của Docker (như volume mounts).

2. Sử Dụng Wrapper Script

Cách linh hoạt hơn là viết một script shell nhỏ có cùng tên với công cụ bạn muốn chạy. Script này sẽ gọi lệnh docker run và truyền các đối số cần thiết.

Tạo file my-hello-cli (không có phần mở rộng) và đặt nó trong một thư mục nào đó có trong biến môi trường PATH của bạn (ví dụ: /usr/local/bin hoặc ~/bin).

#!/bin/bash

# Đảm bảo script có thể thực thi
# chmod +x my-hello-cli

# Tên image Docker
IMAGE_NAME="my-hello-cli"

# Lệnh Docker run cơ bản
DOCKER_CMD="docker run --rm"

# Nếu bạn cần truy cập file trên máy host, hãy mount thư mục hiện tại
# Thư mục hiện tại trên host: $(pwd)
# Thư mục làm việc bên trong container: /app (phải khớp với WORKDIR trong Dockerfile)
DOCKER_CMD+=" -v $(pwd):/app"
DOCKER_CMD+=" -w /app"

# Đảm bảo người dùng bên trong container có quyền ghi nếu cần
# Đồng bộ UID/GID với người dùng hiện tại trên host
# (Tham khảo bài viết về <a href="https://tuyendung.evotek.vn/roadmap-docker-nguoi-dung-nhom-va-quyen-han-trong-linux-cho-nguoi-moi-bat-dau-voi-docker/">Người Dùng, Nhóm và Quyền Hạn</a>)
# DOCKER_CMD+=" --user $(id -u):$(id -g)" # Cẩn thận khi sử dụng với các image base khác nhau

# Lệnh đầy đủ
FULL_COMMAND="$DOCKER_CMD $IMAGE_NAME \"$@\""

# Thực thi lệnh
eval $FULL_COMMAND

Đặt file này trong thư mục nằm trong biến PATH (ví dụ: /usr/local/bin/my-hello-cli) và cấp quyền thực thi (chmod +x /usr/local/bin/my-hello-cli). Bây giờ bạn có thể chạy my-hello-cli World trực tiếp từ terminal.

Wrapper script linh hoạt hơn Alias vì bạn có thể thêm logic phức tạp hơn, chẳng hạn như kiểm tra sự tồn tại của image, thêm các tùy chọn docker run dựa trên đối số, hoặc xử lý các volume mounts cần thiết (Hiểu Rõ Về Volume Mounts và Bind Mounts).

Kỹ Thuật Nâng Cao: Multi-Stage Builds

Nếu công cụ CLI của bạn cần được biên dịch (compile) từ mã nguồn (ví dụ: Go, Rust, C++), việc cài đặt tất cả các công cụ biên dịch trong image cuối cùng sẽ làm cho image rất lớn. Multi-stage builds là giải pháp hoàn hảo cho vấn đề này.

Ý tưởng là sử dụng một “giai đoạn” đầu tiên để biên dịch ứng dụng, sau đó sao chép file thực thi đã biên dịch sang một “giai đoạn” thứ hai (thường là một image base rất nhỏ gọn như Alpine hoặc scratch) để tạo image cuối cùng.

Ví dụ với một công cụ Go đơn giản:

// main.go
package main

import (
	"fmt"
	"os"
)

func main() {
	name := "Go Docker"
	if len(os.Args) > 1 {
		name = os.Args[1]
	}
	fmt.Printf("Hello from Go, %s!\n", name)
}

Dockerfile (Multi-stage):

# Giai đoạn 1: Biên dịch
FROM golang:1.18-alpine AS builder

WORKDIR /app

COPY main.go .

# Biên dịch ứng dụng
# CGO_ENABLED=0 để tạo binary tĩnh, không phụ thuộc thư viện C
RUN CGO_ENABLED=0 go build -o /usr/local/bin/my-go-cli main.go

# Giai đoạn 2: Image cuối cùng (rất nhỏ)
FROM alpine:latest

# Sao chép binary đã biên dịch từ giai đoạn builder
COPY --from=builder /usr/local/bin/my-go-cli /usr/local/bin/my-go-cli

# Thiết lập ENTRYPOINT
ENTRYPOINT ["my-go-cli"]

# CMD mặc định
CMD ["Go Docker"]

Xây dựng image:

docker build -t my-go-cli .

Image my-go-cli cuối cùng sẽ chỉ chứa Alpine Linux và file thực thi my-go-cli, có kích thước rất nhỏ so với việc sử dụng image golang:1.18-alpine đầy đủ.

Xử Lý Dữ Liệu & Cấu Hình

Công cụ CLI thường cần tương tác với file trên hệ thống file cục bộ hoặc đọc cấu hình. Docker cung cấp các cách để xử lý việc này:

1. Volume Mounts / Bind Mounts: Sử dụng tùy chọn -v hoặc --mount type=bind,source=...,target=... trong lệnh docker run để mount một thư mục hoặc file từ máy host vào container. Điều này cho phép công cụ CLI truy cập dữ liệu hoặc đọc file cấu hình từ host.

# Chạy linter trên file code trên host
docker run --rm -v $(pwd):/app -w /app my-linter-cli /app/src/code.py

# Chạy công cụ cloud với cấu hình từ host
docker run --rm -v ~/.aws:/root/.aws:ro aws-cli s3 ls

(Xem lại bài viết về Volume Mounts và Bind Mounts để hiểu rõ hơn).

2. Environment Variables: Truyền cấu hình bằng biến môi trường sử dụng cờ -e KEY=VALUE trong lệnh docker run. Nhiều công cụ CLI hiện đại hỗ trợ đọc cấu hình từ biến môi trường.

docker run --rm -e API_KEY=my-secret-key my-api-tool fetch-data

So Sánh: Cài Đặt Truyền Thống vs. Container Hóa

Để thấy rõ lợi ích, hãy xem bảng so sánh sau:

Thực Tiễn Tốt Nhất Khi Đóng Gói CLI

• Chọn Base Image Nhỏ Gọn: Sử dụng các image base như Alpine, Debian Slim, hoặc thậm chí là scratch (cho binary tĩnh từ multi-stage build) để giảm kích thước image cuối cùng. Image nhỏ hơn tải nhanh hơn và có bề mặt tấn công (attack surface) nhỏ hơn.
• Sử Dụng ENTRYPOINT và CMD Đúng Cách: ENTRYPOINT nên là lệnh thực thi chính của công cụ, còn CMD cung cấp đối số mặc định.
• Sử Dụng Multi-Stage Builds: Đặc biệt quan trọng khi biên dịch mã nguồn hoặc cần các công cụ chỉ dùng trong quá trình build.
• Quản Lý Dữ Liệu & Cấu Hình: Sử dụng Volume Mounts cho file/thư mục và Environment Variables cho cấu hình nhỏ, nhạy cảm.
• Chú Ý Đến Quyền Hạn Người Dùng: Nếu công cụ cần ghi file vào thư mục được mount từ host, bạn có thể cần điều chỉnh người dùng chạy trong container (Người Dùng, Nhóm và Quyền Hạn) để khớp với người dùng trên host, tránh lỗi quyền hạn. Cờ --user $(id -u):$(id -g) là một giải pháp phổ biến nhưng cần kiểm tra với image base của bạn.
• Luôn Sử Dụng --rm Cho Các Tác Vụ Ngắn: Giữ hệ thống Docker gọn gàng bằng cách tự động xóa container sau khi chạy xong.
• Tài Liệu Hóa: Ghi rõ cách sử dụng công cụ CLI đã đóng gói, bao gồm các volume mount cần thiết và biến môi trường.

Kết Luận

Đóng gói các công cụ dòng lệnh bằng Docker là một kỹ thuật mạnh mẽ giúp giải quyết triệt để các vấn đề về phụ thuộc, môi trường không nhất quán và tính di động. Bằng cách biến mỗi công cụ CLI thành một image Docker độc lập, bạn đảm bảo rằng chúng luôn hoạt động theo cách bạn mong đợi, bất kể chúng chạy ở đâu. Kỹ thuật này không chỉ hữu ích cho các công cụ tùy chỉnh mà còn là cách tuyệt vời để quản lý và sử dụng các công cụ của bên thứ ba một cách sạch sẽ và hiệu quả.

Hy vọng bài viết này đã mở ra cho bạn một góc nhìn mới về ứng dụng của Docker. Trong các bài tiếp theo của series “Roadmap Docker”, chúng ta sẽ tiếp tục khám phá những chủ đề thú vị và quan trọng khác trên hành trình làm chủ Docker của mình. Hãy cùng chờ đón nhé!