Compile and deploy code packages - Function Compute - Alibaba Cloud Documentation Center

Go is a statically-typed language. You need to compile programs on on-premises machines and package programs as .zip files. This topic describes how to package the Function Compute SDK for Go with your code.

Prerequisites

Go is installed. Function Compute supports Go 1.x. We recommend that you use Go 1.8 or later.

Compile and package files on Linux or macOS

Download Function Compute SDK for Go.

go get github.com/aliyun/fc-runtime-go-sdk/fc

In the directory in which the file is stored, run the following command to compile the file:
```
GOOS=linux go build main.go
```
Note
- The main.go file is used as an example. Replace it with your actual file name.
- After the compilation, a binary file with the same name as the file is generated in the directory.
Add GOOS=linux to ensure that the compiled executable file is compatible with the Go runtime of Function Compute. Pay special attention to this when you compile your files in a non-Linux environment.
Note:
- For Linux, we recommend that you add CGO_ENABLED=0 to use pure static compilation. This way, the executable files do not require external dependencies such as the libc library. This prevents incompatibility between the compilation environment and the dependencies of the Go runtime. Example:
```
GOOS=linux CGO_ENABLED=0 go build main.go
```
- If your machine uses a computer with macOS and M1 chips or another ARM architecture, add GOARCH=amd64 to allow cross-platform compilation. Example:
```
GOOS=linux GOARCH=amd64 go build main.go
```
Package the binary file that is generated in the preceding step.
```
zip fc-golang-demo.zip main
```

Compile and package files on Windows

Compile the executable file.
1. Press Win+R to open the Run dialog box.
2. Enter cmd and press Enter.
3. In the command prompt window, run the following commands:
```
set GOOS=linux
set GOARCH=amd64
go build -o main main.go
```
Use the build-fc-zip tool to package the files.
1. Run the go get command to download the build-fc-zip tool from GitHub.
```
go get -u github.com/aliyun/fc-runtime-go-sdk/cmd/build-fc-zip
```
2. Use the build-fc-zip tool to package the files. If you use the default installation method for Go, the tool is installed in the %USERPROFILE%\go\bin directory.
```
%USERPROFILE%\go\bin\build-fc-zip.exe -output main.zip main
```

Configure function handlers in Function Compute

Create an event function and set Runtime to Go 1.
Go is a compiled language. You need to upload the executable binary file as a ZIP package after the file is compiled on an on-premises machine. When you configure the Handler parameter for a Go FC function in the Function Compute console, set the Handler parameter to [File name]. "File name" indicates the name of the compiled binary file. When the function is invoked, Function Compute executes the binary file.
- If the compiled binary file is stored in the root directory of the ZIP package, as shown in the following figure, set the Handler parameter of the function in FC to main.
- If the compiled binary file is not stored in the root directory of the ZIP package, but stored in the bin/ directory, as shown in the following figure, set the Handler parameter to bin/main.