Sửa lỗi 'exec: executable file not found in $PATH' Khi Dùng os/exec Trong Go

Tình Huống

Chương trình Go của bạn gọi ra một lệnh bên ngoài — có thể là gcc, ffmpeg, git, hoặc một CLI tool nào đó. Chạy bình thường trên terminal. Nhưng khi deploy thành systemd service, đưa vào Docker, hay chạy trên CI — bỗng nhiên xuất hiện:

exec: "gcc": executable file not found in $PATH

Cùng một binary. Cùng một máy. Khác môi trường. Binary không biến mất đâu cả — chỉ là process của bạn không thấy nó mà thôi.

Chuyện Gì Đang Xảy Ra

Khi os/exec chạy một lệnh bằng tên (không phải đường dẫn đầy đủ), nó tìm binary trong $PATH. Và nó tìm trong $PATH của chính nó — không phải của bạn.

Terminal session của bạn có PATH đầy đủ kiểu như /usr/local/bin:/usr/bin:/home/user/.local/bin:/usr/local/go/bin. Còn systemd service, cron job, hay Docker container khởi động với gần như không có gì — thường chỉ là /usr/bin:/bin.

Vì vậy gcc ở /usr/local/bin/gcc, hay go ở /usr/local/go/bin/go, đơn giản là không tồn tại theo góc nhìn của process.

Bước 1: Xác Nhận Binary Có Tồn Tại Không

Loại trừ điều hiển nhiên trước — binary có thực sự được cài không?

which gcc
# hoặc
type gcc

# Nếu không tìm thấy:
sudo apt install gcc          # Debian/Ubuntu
sudo yum install gcc          # RHEL/CentOS
brew install gcc              # macOS

which trả về một đường dẫn nghĩa là binary tồn tại. Bạn đang gặp vấn đề về khả năng nhìn thấy PATH, không phải vấn đề cài đặt.

Bước 2: Debug Xem Process Go Của Bạn Thấy Gì

Thêm đoạn code này vào chương trình để xem chính xác $PATH trông như thế nào lúc runtime:

package main

import (
    "fmt"
    "os"
    "os/exec"
)

func main() {
    // In PATH mà process thực sự có
    fmt.Println("PATH:", os.Getenv("PATH"))

    // Thử resolve binary
    path, err := exec.LookPath("gcc")
    if err != nil {
        fmt.Println("LookPath error:", err)
    } else {
        fmt.Println("Found gcc at:", path)
    }
}

Chạy nó trong đúng điều kiện xảy ra lỗi — với tư cách service user, bên trong Docker, hoặc qua sudo -u myuser ./binary. PATH bị rút gọn sẽ làm vấn đề lộ rõ ngay.

Cách Sửa Nhanh: Dùng Đường Dẫn Đầy Đủ Của Binary

Bỏ qua hoàn toàn việc tìm kiếm PATH. Truyền đường dẫn tuyệt đối vào exec.Command:

cmd := exec.Command("/usr/bin/gcc", "-o", "output", "main.c")
out, err := cmd.CombinedOutput()
if err != nil {
    log.Fatalf("gcc failed: %v\n%s", err, out)
}

Hoạt động bất kể $PATH là gì. Nhưng có một hạn chế: binary nằm ở chỗ khác nhau trên các máy khác nhau — /usr/local/bin/gcc trên Homebrew macOS, /usr/bin/gcc trên Ubuntu. Hardcode đường dẫn sẽ bị gãy trên máy kế tiếp.

Cách Sửa Tốt Hơn: Resolve Path Khi Khởi Động, Thất Bại Ngay Lập Tức

Resolve đường dẫn một lần khi khởi động và lưu lại. Binary bị thiếu sẽ crash ngay với thông báo rõ ràng — không âm thầm phát nổ sâu trong ba goroutine:

package main

import (
    "fmt"
    "log"
    "os/exec"
)

var gccPath string

func init() {
    var err error
    gccPath, err = exec.LookPath("gcc")
    if err != nil {
        log.Fatalf("Required binary 'gcc' not found in PATH: %v", err)
    }
}

func compileFile(src, out string) error {
    cmd := exec.Command(gccPath, "-o", out, src)
    output, err := cmd.CombinedOutput()
    if err != nil {
        return fmt.Errorf("gcc error: %w\n%s", err, output)
    }
    return nil
}

Chương trình hoặc khởi động sạch sẽ, hoặc dừng ngay lập tức với thông báo cho bạn biết chính xác vấn đề là gì. Không có bất ngờ lúc 2 giờ sáng.

Cách Sửa Triệt Để: Truyền PATH Đúng Cho Tiến Trình Con

Đường dẫn hardcode quá cứng nhắc? Mở rộng PATH của subprocess trực tiếp trong code. Tiện lợi khi các tool nằm rải rác ở /usr/local/bin, ~/.local/bin, hoặc các thư mục riêng của ngôn ngữ như /usr/local/go/bin:

package main

import (
    "os"
    "os/exec"
    "strings"
)

func runWithExtendedPath(name string, args ...string) ([]byte, error) {
    cmd := exec.Command(name, args...)

    // Kế thừa env hiện tại, nhưng mở rộng PATH
    env := os.Environ()
    for i, e := range env {
        if strings.HasPrefix(e, "PATH=") {
            env[i] = e + ":/usr/local/bin:/usr/local/go/bin:/home/ubuntu/.local/bin"
            break
        }
    }
    cmd.Env = env

    return cmd.CombinedOutput()
}

Hoặc thiết lập môi trường đầy đủ một cách tường minh khi bạn biết chính xác những gì cần thiết:

cmd := exec.Command("gcc", "-o", "output", "main.c")
cmd.Env = append(os.Environ(),
    "PATH=/usr/local/bin:/usr/bin:/bin",
)
out, err := cmd.CombinedOutput()

Sửa Cho systemd Services

Systemd service khởi động với môi trường tối giản — PATH của user không được kế thừa. Hãy thiết lập tường minh trong unit file:

[Service]
Environment="PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/go/bin"
ExecStart=/opt/myapp/myapp

Muốn giữ các biến trong file riêng? Dùng EnvironmentFile=/etc/myapp/env thay thế. Dù cách nào, nhớ reload sau khi chỉnh sửa:

sudo systemctl daemon-reload
sudo systemctl restart myapp

Sửa Cho Docker Containers

Docker image khởi động từ đầu — binary phải được cài và có thể truy cập từ PATH. Xác minh cả hai trong Dockerfile:

FROM golang:1.22-alpine

RUN apk add --no-cache gcc musl-dev

# Xác minh gcc có thể truy cập trước khi build
RUN which gcc

COPY . /app
WORKDIR /app
RUN go build -o server .
CMD ["/app/server"]

Kiểm Tra Sau Khi Sửa

Kiểm tra trong đúng điều kiện xảy ra lỗi trước đó:

# Với service:
sudo systemctl restart myapp
journalctl -u myapp -n 50

# Với Docker:
docker build -t myapp . && docker run myapp

# Kiểm tra nhanh trong code:
path, err := exec.LookPath("gcc")
fmt.Printf("gcc resolved to: %s (err: %v)\n", path, err)

Không có lỗi, subprocess thoát sạch sẽ? Vậy là xong.

Tóm Tắt

Lỗi này có nghĩa là os/exec không tìm thấy binary trong $PATH của process — không phải binary không tồn tại.
Service, container, và cron job không kế thừa PATH của interactive shell của bạn.
Dùng exec.LookPath để debug xem chính xác process Go của bạn thấy gì lúc runtime.
Cách sửa nhanh: truyền đường dẫn tuyệt đối của binary vào exec.Command.
Cách sửa gọn hơn: resolve khi khởi động bằng LookPath, crash ngay với thông báo rõ ràng.
Với service: thiết lập Environment= trong unit file của systemd.