Compile, package, and deploy a Go application - Function Compute: Central de Documentação do Alibaba Cloud

Go é uma linguagem compilada estaticamente. O Function Compute não permite editar código Go diretamente no console. Por isso, compile sua aplicação localmente, empacote o binário em um arquivo .zip e faça o upload.

Pré-requisitos

Antes de começar, verifique se você tem:

O ambiente de desenvolvimento Go instalado (Go 1.8 ou posterior). O Function Compute oferece suporte ao Go 1.x.

Como funciona

Escreva sua função Go usando o SDK do Function Compute para Go.
Compile o arquivo source localmente em um binário compatível com Linux.
Empacote o binário em um arquivo .zip.
Crie uma função acionada por evento no console do Function Compute, faça o upload do arquivo .zip e defina o campo Handler como o nome do binário compilado.

O campo Handler deve corresponder exatamente ao nome do binário compilado. Se o binário se chamar main e estiver na raiz do arquivo .zip, defina Handler como main . Caso esteja em um subdiretório, como bin/ , defina Handler como bin/main . O Function Compute executa esse binário diretamente quando a função é invocada.

Compilação e empacotamento no Linux ou macOS

Baixe o SDK do Function Compute para Go.

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

Crie um arquivo source (por exemplo, main.go) e gere o binário. Utilize o comando correspondente à sua máquina: Linux (x86-64) — gere um binário vinculado estaticamente para evitar dependências externas, como libc:
```
GOOS=linux CGO_ENABLED=0 go build main.go
```
macOS com Apple silicon (M1) — faça a compilação cruzada para a arquitetura x86-64 usada pelo Function Compute:
```
GOOS=linux GOARCH=amd64 go build main.go
```
macOS com Intel — defina GOOS=linux para produzir um binário compatível com Linux:
```
GOOS=linux go build main.go
```
Após a compilação, um binário com o mesmo nome do seu arquivo source será criado no diretório atual.
Empacote o binário em um arquivo .zip.
```
zip fc-golang-demo.zip main
```

Compilação e empacotamento no Windows

Crie um arquivo source, como main.go, e abra o Prompt de Comando: pressione Win+R, insira cmd e pressione Enter.
Gere o binário.
```
set GOOS=linux
set GOARCH=amd64
go build -o main main.go
```
Após a compilação, um binário chamado main será criado no diretório atual.
Utilize a ferramenta build-fc-zip para empacotar o binário. No Windows, use essa ferramenta em vez do comando nativo zip para preservar as permissões de arquivo.
1. Instale o build-fc-zip.
```
set GOOS=windows
set GOARCH=amd64
go install github.com/aliyun/fc-runtime-go-sdk/cmd/build-fc-zip@latest
```
  Por padrão, a ferramenta é instalada em %USERPROFILE%\go\bin.
2. Empacote o binário.
```
%USERPROFILE%\go\bin\build-fc-zip.exe -output main.zip main
```

Crie uma função e configure o handler

Crie uma função acionada por evento. Em Runtime, selecione Go 1.
Faça o upload do seu pacote de código e configure o handler. Para mais detalhes, consulte Criar uma função de evento. Na configuração do Handler no console do Function Compute, o Handler de uma função Go FC deve ser definido diretamente como [filename]. Esse nome de arquivo corresponde ao nome do arquivo binário compilado.
- Se o binário estiver na raiz do pacote .zip, defina Handler como main.
- Caso o binário esteja em um subdiretório, como bin/, defina Handler como bin/main.