AWS Lambda - Fonction dans Go

La prise en charge de Go Language est un ajout récent à AWS. Pour travailler avec Go, vous devez sélectionner la langue dans la console AWS lors de la création de la fonction AWS Lambda. Dans ce chapitre, apprenons en détail la fonction AWS Lambda en langage Go.

Installer Go

Pour commencer, nous avons besoin de l'assistance Go Language. Dans cette section, nous allons passer en revue les détails suivants pour commencer à travailler avec AWS Lambda dans Go. Ceci est le site officiel pour télécharger Go:https://golang.org/dl/

Maintenant, téléchargez le package selon le système d'exploitation. Suivez la procédure indiquée ici pour installer Go sur le système d'exploitation correspondant.

Installation sous Windows

Notez que pour Windows, un téléchargement 32 bits et 64 bits est disponible. Téléchargez le fichier zip et extrayez le contenu et stockez-le dans un répertoire de votre choix.

Ajoutez les variables d'environnement disponibles sur ControlPanel ---> System ---> Advanced system settings.

Maintenant, cliquez sur Environment Variables et ajoutez le chemin du répertoire comme indiqué ici -

Vous pouvez également modifier la variable système comme indiqué ici -

Une fois ces étapes terminées, vous devriez pouvoir commencer à travailler avec Go. Ouvrez l'invite de commande et vérifiez la commande Go pour la version. Observez la capture d'écran suivante pour le même.

Installation pour Linux et Mac OS

Pour installer des packages sur Linux et Mac OS, suivez les instructions ci-dessous -

Déballez les paquets et stockez-les sur place /usr/local/go. Maintenant, ajoutez/usr/local/go/binà la variable d'environnement PATH. Cela peut être fait en utilisant/etc/profile ou $HOME/.profile.

Pour cela, vous pouvez utiliser la commande suivante

export PATH=$PATH:/usr/local/go/bin

Pour ajouter la prise en charge d'AWS pour Windows, Linux et mac, utilisez ce qui suit dans votre ligne de commande git -

go.exe get -u github.com/aws/aws-lambda-go/lambda 
go.exe get -u github.com/aws/aws-lambda-go/lambdacontext
go.exe get -u github.com/aws/aws-lambda-go/cmd/build-lambda-zip

Pour compiler le code Windows / Linux / Mac, utilisez les commandes suivantes -

GOOS=linux GOARCH=amd64 go build -o main main.go
%GOPATH%\bin\build-lambda-zip.exe -o main.zip main

Fonction AWS Lambda utilisant GO

Un programme retourné dans Go lorsque build donne un fichier exécutable. Ce qui suit est un programme simple dans Go avec la prise en charge d'AWS Lambda. Nous devons importer legithub.com/aws/aws-lambda-go/lambda, car il dispose de la fonctionnalité de programmation Lambda. Un autre besoin important pour AWS Lambda est le gestionnaire.

Main.go

// main.go
package main

import (
   "github.com/aws/aws-lambda-go/lambda"
)
func hello() (string, error) {
   return "Hello Lambda", nil
}
func main() {
   // Make the handler available for Remote Procedure Call by AWS Lambda
   lambda.Start(hello)
}

Notez que l'exécution du GoLe programme démarre à partir de main où lambda. start est appelé avec la fonction handler. Observez le code ci-dessous -

func main() {
   // Make the handler available for Remote Procedure Call by AWS Lambda
   lambda.Start(hello)
}

Maintenant, exécutons le fichier ci-dessus en utilisant la commande Go, puis compressons le fichier exécutable.

La structure du fichier que nous utilisons est comme indiqué ici -

Avec go build, il crée un fichier exécutable appelé main.exe. Pour compresser le fichier et le télécharger dans AWS Lambda, vous pouvez utiliser la procédure suivante:

Pour compiler le code Windows / Linux / Mac, utilisez les commandes suivantes -

GOOS=linux GOARCH=amd64 go build -o main main.go
%GOPATH%\bin\build-lambda-zip.exe -o main.zip main

Ensuite, connectez-vous à la console AWS et créez une fonction Lambda à l'aide de Go comme runtime -

Une fois la fonction créée, téléchargez le fichier zip exécutable créé ci-dessus.

Gestionnaire de fonctions Lambda avec Go

Handler est l'endroit où commence l'exécution du programme Go. De l'appel principal aulambda.start, l'exécution est appelée avec la fonction de gestionnaire. Notez que le gestionnaire à ajouter seramain.

Observez le code ici pour une compréhension -

func main() {
   // Make the handler available for Remote Procedure Call by AWS Lambda
   lambda.Start(hello)
}

Suivez les captures d'écran ci-dessous -

Maintenant, enregistrez la fonction et testez-la. Vous pouvez voir le résultat de l'exécution comme indiqué ici.

La sortie de journal correspondante sera comme indiqué ici -

Objet de contexte avec Go

AWS Lambda dans Go fournit les variables et propriétés globales suivantes pour le contexte.

MemoryLimitInMB - Limite de mémoire, en Mo configurée dans aws lambda.
FunctionName - nom de la fonction lambda aws.
FunctionVersion - la version de l'exécution de la fonction lambda aws.
LogStreamName - nom du flux de journal cloudwatch.
LogGroupName - nom du groupe cloudwatch.

Les propriétés disponibles sur le contexte sont données sous -

AwsRequestID

Il s'agit de l'ID de demande AWS que vous obtenez lorsque la fonction AWS Lambda est appelée.

ClientContext

Il contient des détails sur l'application cliente et l'appareil lorsqu'ils sont appelés via le kit SDK AWS Mobile. Cela peut être nul. Le contexte client fournit des détails tels que l'ID client, le titre de l'application, le nom de la version, le code de la version et le nom du package d'application.

InvokedFunctionArn

L'ARN de la fonction appelée. Un ARN non qualifié exécute la version $ LATEST et les alias exécutent la version de fonction vers laquelle il pointe.

Identité

Il donne des détails sur le fournisseur d'identité Amazon Cognito lorsqu'il est utilisé avec AWS Mobile SDK.

Les changements ajoutés à main.go pour imprimer les détails du contexte -

// main.go
package main

import (
   "context"
   "log"
   "github.com/aws/aws-lambda-go/lambda"
   "github.com/aws/aws-lambda-go/lambdacontext"
)

func hello(ctx context.Context) (string, error) {
   lc, _ := lambdacontext.FromContext(ctx);
   log.Print(lc);
   log.Print(lc.AwsRequestID);
   log.Print(lc.InvokedFunctionArn);
   return "Hello Lambda", nil
}

func main() {
   // Make the handler available for Remote Procedure Call by AWS Lambda
   lambda.Start(hello)
}

Nous devons importer le log et lambda contextpour l'utiliser avec Go. Les détails du contexte sont les suivants -

func hello(ctx context.Context) (string, error) {
   lc, _ := lambdacontext.FromContext(ctx);
   log.Print(lc);
   log.Print(lc.AwsRequestID);
   log.Print(lc.InvokedFunctionArn);	
   return "Hello Lambda", nil
}

Vous pouvez observer la sortie suivante en testant le code ci-dessus -

Journalisation des données

Avec Go vous pouvez enregistrer des données à l'aide du module log ou fmt comme indiqué ci-dessous -

// main.go
package main

import (
   "log"
   "fmt"
   "github.com/aws/aws-lambda-go/lambda"
)

func hello() (string, error) {
   log.Print("Hello from Lambda Go using log");
   fmt.Print("Hello from Lambda Go using fmt");
   return "Hello Lambda", nil
}

func main() {
   // Make the handler available for Remote Procedure Call by AWS Lambda
   lambda.Start(hello)
}

La sortie pour le même est comme indiqué ci-dessous -

Vérification des journaux dans CloudWatch

Vous pouvez également voir les journaux dans CloudWatch. Pour cela, accédez au service AWS et sélectionnez cloudwatch et cliquez surLogssur le côté gauche. Maintenant, recherchez la fonction Lambda dans la liste pour voir les journaux -

Erreurs de fonction

Vous pouvez créer une gestion des erreurs personnalisée dans AWS Lambda à l'aide du module d'erreurs comme indiqué dans le code ci-dessous -

// main.go
package main
import (
   "errors"
   "github.com/aws/aws-lambda-go/lambda"
)

func hello() error  {
   return errors.New("There is an error in the code!")
}

func main() {
   // Make the handler available for Remote Procedure Call by AWS Lambda
   lambda.Start(hello)
}

La sortie pour le code ci-dessus est comme indiqué ci-dessous -