Hướng dẫn cách xây dựng Go để chạy đa nền tảng trên Ubuntu 20.04

Việc build một ứng dụng đa nền tảng đã trở nên rất quen thuộc với các lập trình viên ngày nay. Chính vì thế, các kiến trúc trở nên đa dạng và không ngừng thay đổi, điều này yêu cầu cần phải có một công cụ giúp hỗ trợ việc build ứng dụng dễ dàng hơn. Dưới đây sẽ là bài viết về cách xây dựng Go trên Ubuntu 20.04, nội dung trong bài sẽ giúp bạn tìm hiểu về công cụ của Go giúp build một ứng dụng trên các nền tảng khác nhau một cách tự động và nhanh chóng.

Giới thiệu về ngôn ngữ Go

Ngôn ngữ lập trình Go hay Golang cung cấp một chuỗi rất nhiều các công cụ hữu ích giúp cho việc lấy các packages và xây dựng các executables (các files khả thực thi) trở nên dễ dàng hơn bao giờ hết. Và một trong những tính năng mạnh mẽ nhất của Go là khả năng xây dựng các executables đa nền tảng miễn là nền tảng đó có hỗ trợ cho Go.

Điều này giúp cho việc kiểm thử và phân phối các packages trở nên thuận lợi hơn, bởi vì các bạn sẽ không cần phải truy cập vào một nền tảng cụ thể nào để có thể phân phối package cho chính nền tảng đó.

Với những ưu điểm trên của Go, trong bài hướng dẫn này các bạn sẽ sử dụng các công cụ trong Go để lấy một package trong Version Control System và tự động cài đặt các executables của package đó. Sau đó, các bạn sẽ tự tay xây dựng và cài đặt một file executable để làm quen được với quá trình đó. Cuối cùng là xây dựng một file executable cho các kiến trúc nền tảng khác, và tự động quá trình xây dựng để tạo các file executables cho đa nền tảng.

Khi đã hoàn thành, các bạn sẽ biết được cách để xây dựng các file executables cho Windows và MacOS, cũng như là các nền tảng khác theo mong muốn của mình.

Yêu cầu tiên quyết cho cách xây dựng Go trên Ubuntu 20.04

Đầu tiên, trước khi bước vào thực hành các bước, các bạn cần phải đảm bảo máy của mình có đủ các điều kiện sau:

• Thứ nhất là một máy chủ Ubuntu 20.04 đã được setup bao gồm một sudo non-root user và tường lửa.
• Thứ hai là Go đã được cài đặt trên máy (Hướng dẫn chi tiết tại đây).

Nếu đã có đủ hai điều kiện trước, các bạn đã sẵn sàng để theo dõi bài hướng dẫn này.

Các bước thực hiện

Bây giờ, các bạn sẽ đến với bước thực hiện đầu tiên là tạo một chương trình Go đơn giản.

Bước 1: Tạo một chương trình Go đơn giản

Ở bước này, như lẽ tự nhiên của bất kì một ứng dụng nào khi bắt đầu, các bạn sẽ tạo một chương trình huyền thoại có tên là Hello, World!.

Đầu tiên, tạo một thư mục mới cho project Go, nơi mà Go sẽ build các file của mình. Theo ví dụ trong bài này sẽ là thư mục hello:

mkdir hello

Sau đó, di chuyển vào thư mục vừa tạo:

cd hello

Khi import các packages, các bạn cần phải quản lí các dependencies thông qua các module. Để thực hiện, ta cần tạo một file go.mod với câu lệnh go mod init như sau:

go mod init hello

Tiếp theo, tạo file Hello, World! của Go bằng một text editor tùy ý, ở đây sử dụng nano:

nano hello.go

Thêm các dòng lệnh sau ở bên trong file hello.go:

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Lưu và đóng file bằng CTRL+X, sau đó Y và ENTER sau khi hoàn thành.

Kiểm tra lại code của mình có print dòng chữ Hello, World! hay không bằng lệnh:

go run .

Output
Hello, World!

Lệnh go run sẽ compile và chạy Go package từ danh sách trong source files của .go trong thư mục hello mà ta vừa tạo và đường dẫn mà ta imported. Nhưng các bạn cũng có thể sử dụng go build để tạo một executable file để giúp tiết kiệm thời gian.

Bước 2: Tạo một file Executable

Lệnh go run đã chạy code trong chương trình “Hello, World!”, nhưng điều các bạn muốn là build chương trình đó thành dạng binary (hay nhị phân) để có thể chạy ở bất kì nơi nào trên hệ thống, không phải chỉ là từ source của chương trình. Lệnh go build giúp build các executables.

go build hello

Lệnh trên sẽ không có bất kì output nào khi thao tác đã thực thi thành công. File executable sẽ được tạo ra trong thư mục hiện tại của các bạn, có cùng tên với thư mục chứa package. Với trường hợp của bài hướng dẫn này, file executable có tên là hello.

Nếu như các bạn đang ở trong thư mục package, thì có thể bỏ qua phần đường dẫn cho package và chỉ đơn giản là chạy go build.

Để chỉ định tên khác và vị trí khác cho file executable, ta thêm flag -o.

Bây giờ, các bạn sẽ thử tạo một file executable có tên là hello và đặt nó vào trong thư mục build nằm bên trong thư mục hiện tại đang làm việc:

go build -o build/hello hello

Lênh trên tạo một file executable và đồn thời tạo thư mục ./build nếu chưa có.

Các bạn đã có được một file executable cho chương trình hello của mình, tiếp theo sẽ tìm hiểu về cách để cài đặt các file executables.

Bước 3: Cài đặt Executable

Build một file executable, sẽ tạo ra file đó nằm bên trong thư mục mà ta đang làm việc hoặc theo chỉ định. Cài đặt một executable là quá trình tạo ra một file executable và lưu trữ file đó vào trong $GOPATH/bin. Lệnh go install có chức năng giống như go build nhưng khác là go install sẽ giúp đặt các file output vào đúng vị trí, ta không cần phải tự mình chỉ định.

Để cài đặt một executable, dùng lệnh go install theo sau là tên đường dẫn import của package. Ở đây, ta vẫn sử dụng chương “Hello, World!” để thử:

go install hello

Giống với go build, không có output nào hiện ra nếu lệnh chạy thành công. Và cũng tương tự, file executable được tạo với tên cùng với tên thư mục chứa package. Nhưng lần này, file executable được lưu bên trong $GOPATH/bin. Nếu $GOPATH/bin là một phần của biến môi trường $PATH trên máy các bạn, file executable sẽ có thể được thực thi từ bất kì nơi nào trên hệ điều hành.

Để xác nhận điều này dùng lệnh which:

which hello

Các bạn sẽ thấy output tương tự như sau:

Output of which
/home/sammy/go/bin/hello

Đến đây, các bạn đã hiểu được cách go get, go build và go install hoạt động, và chúng có liên quan như nào với nhau.

Tiếp theo các bạn sẽ tìm hiểu về một trong các tính năng phổ biến nhất của Go là tạo các file executables cho các nền tảng khác.

“Nếu bạn muốn chạy chương trình, triển khai ứng dụng của mình trên server ảo (VPS) tốc độ cao và ổn định, hãy xem xét dịch vụ thuê máy chủ ảo của Vietnix. Với nhiều gói dịch vụ VPS khác nhau như VPS Giá Rẻ, VPS Phổ Thông, VPS Cao Cấp và VPS NVMe có giá khởi điểm chỉ 89.000 VND/Tháng, bạn có thể lựa chọn gói có cấu hình phù hợp với nhu cầu của mình.

Vietnix cũng cung cấp cho bạn một giao diện quản lý VPS đơn giản và dễ sử dụng để bạn có thể quản lý máy chủ của mình một cách dễ dàng.

Việc sử dụng VPS của Vietnix cũng có nhiều lợi ích, bao gồm tốc độ truy cập nhanh và khả năng mở rộng linh hoạt, dễ dàng truy cập và quản lý máy chủ từ xa, bảo mật dữ liệu,… Ngoài ra, Vietnix còn hỗ trợ khách hàng 24/7 với đội ngũ kỹ thuật giàu kinh nghiệm để giải quyết các vấn đề kỹ thuật khi sử dụng VPS một cách nhanh chóng và hiệu quả.

Bước 4: Xây dựng Executable cho các kiến trúc khác nhau

Lệnh go build sẽ giúp ta build một file executable cho nền tảng bất kì nào được Go hỗ trợ. Điều này giúp ta có thể test, release và distribute ứng dụng của mình mà không cần phải build các file executables trên những nền tảng các bạn mong muốn sử dụng.

Việc biên dịch đa nền tảng hoạt động được nhờ vào việc cài đặt các biến môi trường chỉ định môi trường hệ điều hành và kiến trúc mà ta muốn hỗ trợ. Các bạn sử dụng biến GOOS cho hệ điều hành mong muốn và GOARCH cho kiến trúc mong muốn.

Để build một file executable, lệnh như sau:

GOOS=target-OS GOARCH=target-architecture go build package-import-path

Theo lệnh, ta cần phải chỉ định hệ điều hành và kiến trúc trước khi chạy lệnh go build. Điều này để cho các biến môi trường đó chỉ được áp dụng cho câu lệnh hiện tại đang thực thi. Sau đó, sẽ được reset hoặc unset sau khi lệnh được thực thi xong.

Để kiểm tra các hệ điều hành nào và nền tảng nào đang hiện có, sẵn sàng cho việc build các file executables, ta dùng tool dist như sau:

go tool dist list

Tool này sẽ cung cấp một danh sách các hệ điều hành và kiến trúc được phân biệt nhau bởi dấu /:

Output
aix/ppc64
android/386
android/amd64
android/arm
android/arm64
darwin/amd64
darwin/arm64
dragonfly/amd64
freebsd/386
freebsd/amd64
freebsd/arm
freebsd/arm64
illumos/amd64
ios/amd64
ios/arm64
js/wasm
linux/386
linux/amd64
linux/arm
linux/arm64
linux/mips
linux/mips64
linux/mips64le
linux/mipsle
linux/ppc64
linux/ppc64le
linux/riscv64
linux/s390x
netbsd/386
netbsd/amd64
netbsd/arm
netbsd/arm64
openbsd/386
openbsd/amd64
openbsd/arm
openbsd/arm64
openbsd/mips64
plan9/386
plan9/amd64
plan9/arm
solaris/amd64
windows/386
windows/amd64
windows/arm

Dựa vào danh sách được cung cấp, ta sẽ build chương trình hello cho Windows-64 bit như sau:

GOOS=windows GOARCH=amd64 go build hello

Ở đây cũng tương tự, nếu lệnh chạy thành công sẽ không có thông báo output. File executable sau khi build thành công sẽ được tạo ra ở trong thư mục làm việc hiện tại, và có tên của package. Tuy nhiên, bởi vì các bạn sẽ build cho Windows, nên tên của file executable sẽ có thêm suffix .exe.

Dùng lệnh ls sau, để kiểm tra file hello.exe có nằm trong thư mục hiện tại của mình không:

ls hello.exe

Nếu đã build thành công, các bạn sẽ thấy hello.exe được hiển thị ra như sau:

Output
hello.exe

Tiếp theo, các bạn sẽ tiến hành scripting quá trình trên để làm thuận tiện hơn cho quá trình release phần mềm của mình trên nhiều nền tảng hay môi trường khác nhau.

Bước 5: Tạo script tự động hóa biên dịch đa nền tảng (Cross-Compilation)

Quá trình tạo ra các file executables cho riêng mỗi nền tảng khác nhau sẽ trở nên khá khó khăn nếu ta thực hiện theo những gì bước 4 đã hướng dẫn. Tuy nhiên, ta có thể tạo một script để tự động hóa công việc này, khiến cho mọi thứ trở nên dễ dàng hơn.

Đoạn script sẽ nhận đường dẫn import của package để làm tham số, sau đó sẽ tuần tự duyệt qua danh sách cặp các hệ điều hành và nền tảng đã được định nghĩa sẵn để tạo ra file executable cho mỗi cặp và đặt các file đó vào thư mục hiện tại.

Mỗi file executable sẽ được đặt tên theo tên của package, theo sau là nền tảng và kiến trúc tương ứng dưới dạng package-OS-architecture. Đoạn script này sẽ là một script tổng quát và có thể được dùng cho bất kì project nào mà ta mong muốn.

Bên trong thư mục của project, ta tạo một file mới có tên là go-executable-build.bash bằng text editor tùy ý, bài hướng dẫn này sử dụng nano:

nano go-executable-build.bash

Các bạn sẽ bắt đầu đoạn script với dòng shebang. Dòng này lựa chọn trình thông dịch nào sẽ phân tích đoạn script khi được thực thi. Thêm dòng lệnh sau vào file vừa tạo để chỉ định bash sẽ thực thi đoạn script:

!/usr/bin/env bash

Các bạn sẽ lấy đường dẫn import của package như là tham số dòng lệnh. Để thực hiện, ta sử dụng biến $n – với n là một số không âm. Biến $0 giữ tên của script được thực thi, và từ $1 trở lên sẽ giữ các tham số khác do người dùng tự cung cấp.

Thêm dòng lệnh sau vào script để lấy tham số đầu tiên trên command line và lưu lại dưới biến có tên là package:

…
package=$1

Tiếp theo, ta cần đảm bảo rằng tham số đã được cung cấp. Nếu không có giá trị nào được cung cấp, sẽ exit – ngừng thực thi script và gửi ra một message để thông báo:

...

if [[ -z "$package" ]]; then
  echo "usage: $0 <package-name>"
  exit 1
fi

Đoạn lệnh if như trên, kiểm tra giá trị của biến $package. Nếu biến không được set, ta sẽ echo để thông báo về cách sử dụng và chấm dứt hay ngưng đoạn script bằng lệnh exit. exit cần có một tham số cho giá trị trở về – giá bằng 0 có nghĩa là script đã thực thi thành công và khác 0 cho thực thi không thành công.

Các bạn sử dụng 1 ở đây để chỉ định rằng đoạn script đã thực thi không thành công.

Chú ý: nếu các bạn muốn đoạn script được thực thi với một package được định nghĩa sẵn thì hãy thay đổi biến package để trỏ vào đường dẫn import, như ví dụ dưới đây:

...
package="github.com/user/hello"

Tiếp theo, các bạn cần trích xuất lấy tên của package từ đường dẫn. Đường dẫn import của package được phân chia bởi dấu / với tên của package nằm ở vị trí cuối cùng. Đầu tiên ta sẽ tách đường dẫn đó ra thành một mảng bởi dấu /:

package_split=(${package//\// })

Tên của package sẽ là phần tử cuối cùng của mảng $package_split. Với bash, ta có thẻ sử dụng index với số âm để truy cập một phần tử của mạng từ cuối lên thay vì là từ đầu xuống (tương tự như cách đánh index trong Python).

Thêm dòng lệnh sau để lấy tên của package từ mảng vừa tạo và lưu lại vào trong một biến tên là package_name:

…
package_name=${package_split[-1]}

Sau đó, ta sẽ cần phải chỉ định những hệ điều hành nào và những kiến trúc nào mình muốn build các file executables cho. Trong bài hướng dẫn này, các bạn sẽ build các file executables cho Windows 64-bit, Windows 32-bit và 64-bit macOS. Các bạn sẽ đặt các thông tin trên vào trong một mảng có định dạng là OS/Platform, để sau đó sẽ có thể tách từng cặp thành các biến GOOS và GOARCH bằng cách thức tương tự như việc tách lấy tên của package phía trên.

Thêm các nền tảng sau vào trong script:

...
platforms=("windows/amd64" "windows/386" "darwin/amd64")

Tiếp theo, các bạn cần duyệt qua mảng này để tách từng phần tử trong mảng ra thành các biến môi trường GOOS và GOARCH, và sử dụng chúng để build các file executables.

Sử dụng vòng lặp for ta có như sau:

...
for platform in "${platforms[@]}"
do
    ...
done

Biến platform đại diện cho từng phần tử trong mảng platforms qua từng lần duyệt. Ta cần phải tách platform thành hai biến là GOOS và GOARCH.

Thêm những dòng sau vào vòng lặp:

for platform in "${platforms[@]}"
do
    platform_split=(${platform//\// })
    GOOS=${platform_split[0]}
    GOARCH=${platform_split[1]}
    
done

Tiếp theo, ta cần tạo ra tên của file executable bằng cách kết hợp tên của package với tên của hệ điều hành và kiến trúc tương ứng. Và nếu là build cho Windows ta cần phải thêm suffix là .exe cho tên file. Tiếp tục thêm những dòng lệnh sau vào vòng lặp:

for platform in "${platforms[@]}"
do
    platform_split=(${platform//\// })
    GOOS=${platform_split[0]}
    GOARCH=${platform_split[1]}
    
    output_name=$package_name'-'$GOOS'-'$GOARCH

    if [ $GOOS = "windows" ]; then
        output_name+='.exe'
    fi
done

Với các biến trên, giờ ta có thể sử dụng go build để tạo file thực thi. Thêm dòng lệnh sau vào vòng lặp, ngay phía trên từ khóa done:

...
    if [ $GOOS = "windows" ]; then
        output_name+='.exe'
    fi
    
    env GOOS=$GOOS GOARCH=$GOARCH go build -o $output_name $package

done

Cuối cùng, ta nên kiểm tra lại việc có lỗi gì xảy ra trong quá trình build hay không. Ví dụ, ta có thể gặp phải lỗi nếu ta đang build cho một package không có source. Các bạn có thể kiểm tra mã trả về từ lệnh go build có phải là một giá trị khác 0 hay không.

Biến $? chứa mã trả về từ lệnh được thực thi trước đó. Nếu go build trả về mã khác 0, điều đó nghĩa là đã có vấn đề xảy ra và ta sẽ ngừng đoạn script lại ngay tại đó. Thêm những dòng lệnh sau vào vòng lặp, ngay bên dưới lệnh thực thi go build và phía trên từ khóa done:

...

    env GOOS=$GOOS GOARCH=$GOARCH go build -o $output_name $package

    if [ $? -ne 0 ]; then
           echo 'An error has occurred! Aborting the script execution...'
        exit 1
    fi

Đến đây, các bạn đã hoàn thành đoạn script sẽ giúp build các file executables trên nhiều nền tảng cho package Go. Dưới đây là bản đầy đủ của đoạn script.

#!/usr/bin/env bash

package=$1
if [[ -z "$package" ]]; then
  echo "usage: $0 <package-name>"
  exit 1
fi
package_split=(${package//\// })
package_name=${package_split[-1]}
    
platforms=("windows/amd64" "windows/386" "darwin/amd64")

for platform in "${platforms[@]}"
do
    platform_split=(${platform//\// })
    GOOS=${platform_split[0]}
    GOARCH=${platform_split[1]}
    output_name=$package_name'-'$GOOS'-'$GOARCH
    if [ $GOOS = "windows" ]; then
        output_name+='.exe'
    fi    

    env GOOS=$GOOS GOARCH=$GOARCH go build -o $output_name $package
    if [ $? -ne 0 ]; then
           echo 'An error has occurred! Aborting the script execution...'
        exit 1
    fi
done

Hãy kiểm tra để xác nhận script của các bạn giống với đoạn script trên. Sau đó lưu và thoát khỏi editor.

Trước khi sử dụng, ta cần phải cấp quyền khả thực thi cho file script của mình bằng lệnh chmod:

chmod +x go-executable-build.bash

Cuối cùng, ta tiến hành build cho chương trình hello của mình:

./go-executable-build.bash hello

Nếu thực thi thành công, các bạn sẽ nhận được ba file executables trong thư mục của mình. Một lần nữa, không có output thông báo nghĩa là đã thực thi thành công. Hãy sử dụng lệnh ls để kiểm tra.

ls hello*

Các bạn sẽ thấy ba phiên bản của file như dưới đây:

Example ls output
hello-darwin-amd64 hello-windows-386.exe hello-windows-amd64.exe

Bạn có thể thay đổi, thêm hoặc bớt các nền tảng mong muốn, các bạn chỉ cần chỉnh sửa biến platforms bên trong script.

Để chắc chắn rằng ứng dụng của các bạn đã hoạt động tốt, hãy sử dụng Travis-CI và AppVeyor để kiểm thử cho Windows.

Vietnix là lựa chọn đáng tin cậy nếu bạn cần VPS để triển khai theo bài viết. Với 10 năm kinh nghiệm và hơn 50.000 khách hàng, Vietnix được xem là nhà cung cấp VPS uy tín hàng đầu tại Việt Nam. Ngoài ra, Vietnix còn được nhiều người lựa chọn sử dụng dịch vụ phải những ưu thế sau:

• Hơn 100.000 dịch vụ đã được kích hoạt.
• Đạt được giải thưởng Thương hiệu Việt Nam xuất sắc 2022.
• 97% khách hàng đã và đang sử dụng dịch vụ có phản hồi tốt.

Liên hệ với Vietnix để biết thêm chi tiết và nhận ưu đãi hấp dẫn ngay hôm nay.

• Địa chỉ: 265 Hồng Lạc, Phường 10, Quận Tân Bình, Thành Phố Hồ Chí Minh
• Hotline: 1800 1093 – 07 088 44444
• Email: sales@vietnix.com.vn

Lời kết

Vietnix đã giới thiệu cho các bạn về cách sử dụng Go để lấy các package từ Version Control System, cũng như là build và thực thi cross-compile trên các nền tảng khác nhau. Cùng với đó là tự động hóa việc Cross-Compilation bằng một script tự tạo. Nếu có gì thắc mắc về bài viết cách xây dựng Go trên Ubuntu 20.04, hãy để lại bình luận bên dưới để được Vietnix giải đáp ngay lập tức.