Compiler, empaqueter et déployer une application Go - Function Compute

Go est un langage à compilation statique. Function Compute ne permettant pas de modifier du code Go directement dans la console, vous devez compiler votre application localement, intégrer le binaire dans un fichier .zip, puis le télécharger.

Prérequis

Avant de commencer, assurez-vous que l'élément suivant est installé :

L'environnement de développement Go (version 1.8 ou ultérieure). Function Compute prend en charge Go 1.x.

Fonctionnement

Écrivez votre fonction Go à l'aide du SDK Function Compute pour Go.
Compilez le fichier source localement pour obtenir un binaire compatible avec Linux.
Intégrez le binaire dans un fichier .zip.
Créez une fonction déclenchée par événement dans la console Function Compute, téléchargez le fichier .zip et définissez le champ Handler sur le nom du binaire compilé.

La valeur du champ Handler doit correspondre exactement au nom du binaire compilé. Si le binaire s'appelle main et se trouve à la racine du fichier .zip, définissez Handler sur main . S'il réside dans un sous-répertoire tel que bin/ , définissez Handler sur bin/main . Function Compute exécute directement ce binaire lors de l'invocation de la fonction.

Compilation et empaquetage sous Linux ou macOS

Téléchargez le SDK Function Compute pour Go.
```
go get github.com/aliyun/fc-runtime-go-sdk/fc
```
Créez un fichier source (par exemple, main.go), puis générez le binaire. Exécutez la commande correspondant à votre machine : Linux (x86-64) — produisez un binaire lié statiquement afin d'éviter les dépendances externes comme libc :
```
GOOS=linux CGO_ENABLED=0 go build main.go
```
macOS avec puce Apple Silicon (M1) — effectuez une compilation croisée pour l'architecture x86-64 utilisée par Function Compute :
```
GOOS=linux GOARCH=amd64 go build main.go
```
macOS avec processeur Intel — spécifiez GOOS=linux pour générer un binaire compatible avec Linux :
```
GOOS=linux go build main.go
```
Une fois la génération terminée, un binaire portant le même nom que votre fichier source apparaît dans le répertoire courant.
Intégrez le binaire dans un fichier .zip.
```
zip fc-golang-demo.zip main
```

Compilation et empaquetage sous Windows

Créez un fichier source tel que main.go, puis ouvrez l'invite de commandes : appuyez sur Win+R, saisissez cmd et validez avec Entrée.
Générez le binaire.
```
set GOOS=linux
set GOARCH=amd64
go build -o main main.go
```
Après la génération, un binaire nommé main est créé dans le répertoire courant.
Utilisez l'outil build-fc-zip pour empaqueter le binaire. Sous Windows, privilégiez cet outil plutôt que la commande native zip afin de conserver les permissions des fichiers.
1. Installez build-fc-zip.
```
set GOOS=windows
set GOARCH=amd64
go install github.com/aliyun/fc-runtime-go-sdk/cmd/build-fc-zip@latest
```
  Par défaut, l'outil s'installe dans %USERPROFILE%\go\bin.
2. Empaquetez le binaire.
```
%USERPROFILE%\go\bin\build-fc-zip.exe -output main.zip main
```

Créer une fonction et configurer le handler

Créer une fonction déclenchée par événement. Pour le paramètre Runtime, sélectionnez Go 1.
Téléchargez votre package de code et configurez le handler. Pour plus de détails, consultez Créer une fonction événementielle. Dans la configuration du Handler sur la console Function Compute, le Handler d'une fonction Go FC doit pointer directement vers [filename]. Ce nom de fichier correspond au binaire compilé.
- Si le binaire se trouve à la racine du package .zip, définissez Handler sur main.
- Si le binaire réside dans un sous-répertoire tel que bin/, définissez Handler sur bin/main.