AWS Lambda - Funktion in Go

Die Unterstützung von Go Language wurde kürzlich zu AWS hinzugefügt. Um mit Go arbeiten zu können, müssen Sie die Sprache in der AWS-Konsole auswählen, während Sie die AWS Lambda-Funktion erstellen. In diesem Kapitel erfahren Sie mehr über die AWS Lambda-Funktion in der Sprache Go.

Go installieren

Um loszulegen, benötigen wir Unterstützung für Go Language. In diesem Abschnitt werden wir die folgenden Details durchgehen, um mit AWS Lambda in Go zu arbeiten. Dies ist die offizielle Seite für Go-Download:https://golang.org/dl/

Laden Sie jetzt das Paket gemäß dem Betriebssystem herunter. Befolgen Sie die hier angegebenen Schritte, um Go auf dem jeweiligen Betriebssystem zu installieren.

Installation unter Windows

Beachten Sie, dass für Windows 32-Bit- und 64-Bit-Downloads verfügbar sind. Laden Sie die Zip-Datei herunter, extrahieren Sie den Inhalt und speichern Sie ihn in einem Verzeichnis Ihrer Wahl.

Fügen Sie die Umgebungsvariablen hinzu, die unter verfügbar sind ControlPanel ---> System ---> Advanced system settings.

Klicken Sie nun auf Environment Variables Schaltfläche und fügen Sie den Verzeichnispfad wie hier gezeigt hinzu -

Sie können die Systemvariable auch wie hier gezeigt bearbeiten -

Sobald diese Schritte abgeschlossen sind, sollten Sie in der Lage sein, mit Go zu arbeiten. Öffnen Sie die Eingabeaufforderung und überprüfen Sie den Befehl Go auf Version. Beachten Sie dazu den folgenden Screenshot.

Installation für Linux und Mac OS

Befolgen Sie zum Installieren von Paketen unter Linux und Mac OS die folgenden Anweisungen:

Packen Sie die Pakete aus und lagern Sie sie am Ort /usr/local/go. Fügen Sie nun hinzu/usr/local/go/binauf die Umgebungsvariable PATH. Dies kann mit erfolgen/etc/profile oder $HOME/.profile.

Zu diesem Zweck können Sie den folgenden Befehl verwenden

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

Verwenden Sie Folgendes in Ihrer git-Befehlszeile, um AWS-Unterstützung für Windows, Linux und Mac hinzuzufügen:

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

Verwenden Sie die folgenden Befehle, um den Code Windows / Linux / Mac zu kompilieren:

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

AWS Lambda-Funktion mit GO

Ein Programm, das beim Erstellen in Go zurückgegeben wird, liefert eine ausführbare Datei. Das Folgende ist ein einfaches Programm in Go mit AWS Lambda-Unterstützung. Wir müssen das importierengithub.com/aws/aws-lambda-go/lambda, da dies die Lambda-Programmierfunktionalität hat. Ein weiterer wichtiger Bedarf für AWS Lambda ist der Handler.

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)
}

Beachten Sie, dass die Ausführung der GoProgramm startet von Haupt, wo Lambda. start wird mit der Handlerfunktion aufgerufen. Beachten Sie den unten gezeigten Code -

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

Lassen Sie uns nun die obige Datei mit dem Befehl Go ausführen und dann die ausführbare Datei komprimieren.

Die Struktur der Datei, die wir verwendet haben, ist wie hier gezeigt -

Mit go builderstellt eine ausführbare Datei mit dem Namen main.exe. Gehen Sie wie folgt vor, um die Datei zu komprimieren und in AWS Lambda hochzuladen:

Verwenden Sie die folgenden Befehle, um den Code Windows / Linux / Mac zu kompilieren:

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

Melden Sie sich dann bei der AWS-Konsole an und erstellen Sie die Lambda-Funktion mit Go als Laufzeit -

Laden Sie nach dem Erstellen der Funktion die oben erstellte ausführbare Zip-Datei hoch.

Lambda-Funktionshandler mit Go

Im Handler beginnt die Ausführung des Go-Programms. Vom Hauptanruf bislambda.startDie Ausführung wird mit der Handlerfunktion aufgerufen. Beachten Sie, dass der hinzuzufügende Handler sein wirdmain.

Beachten Sie den Code hier zum Verständnis -

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

Befolgen Sie die folgenden Screenshots -

Speichern Sie nun die Funktion und testen Sie sie. Sie können das Ausführungsergebnis wie hier gezeigt sehen.

Die entsprechende Protokollausgabe wird wie hier gezeigt angezeigt -

Kontextobjekt mit Go

AWS Lambda in Go bietet die folgenden globalen Variablen und Eigenschaften für den Kontext.

• MemoryLimitInMB - Speicherlimit in MB, das in aws lambda konfiguriert ist.

• FunctionName - Name der aws Lambda-Funktion.

• FunctionVersion - Die Version der aws Lambda-Funktion wird ausgeführt.

• LogStreamName - Name des Cloudwatch-Protokolldatenstroms.

• LogGroupName - Name der Cloudwatch-Gruppe.

Die im Kontext verfügbaren Eigenschaften sind wie folgt angegeben:

AwsRequestID

Dies ist die AWS-Anforderungs-ID, die Sie erhalten, wenn die AWS Lambda-Funktion aufgerufen wird.

ClientContext

Diese enthält Details zur Clientanwendung und zum Gerät, wenn diese über das AWS Mobile SDK aufgerufen werden. Es kann null sein. Der Clientkontext enthält Details wie Client-ID, Anwendungstitel, Versionsname, Versionscode und den Namen des Anwendungspakets.

InvokedFunctionArn

Die ARN der aufgerufenen Funktion. Ein nicht qualifizierter ARN führt die $ LATEST-Version aus und Aliase führen die Funktionsversion aus, auf die er zeigt.

Identität

Bei Verwendung mit dem AWS Mobile SDK werden Details zum Amazon Cognito-Identitätsanbieter angezeigt.

Die Änderungen wurden hinzugefügt main.go Kontextdetails drucken -

// 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)
}

Wir müssen das importieren log und lambda contextum es mit Go zu benutzen. Die Kontextdetails lauten wie folgt:

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
}

Sie können die folgende Ausgabe beim Testen des obigen Codes beobachten:

Daten protokollieren

Mit Go Sie können Daten mit dem Protokoll- oder FMT-Modul wie unten gezeigt protokollieren -

// 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)
}

Die Ausgabe für dasselbe ist wie unten gezeigt -

Überprüfen von Protokollen in CloudWatch

Sie können die Protokolle auch in CloudWatch anzeigen. Gehen Sie dazu zum AWS-Service, wählen Sie Cloudwatch aus und klicken Sie aufLogsauf der linken Seite. Suchen Sie nun in der Liste nach der Lambda-Funktion, um die Protokolle anzuzeigen.

Funktionsfehler

Sie können eine benutzerdefinierte Fehlerbehandlung in AWS Lambda mithilfe des Fehlermoduls erstellen, wie im folgenden Code gezeigt.

// 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)
}

Die Ausgabe für den oben gezeigten Code ist wie folgt: