Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Erstellen von Lambda-Funktionen mit Go
Go wird anders implementiert als andere verwaltete Laufzeiten. Da Go nativ zu einer ausführbaren Binärdatei kompiliert wird, ist keine spezielle Sprachlaufzeit erforderlich. Verwenden Sie eine [reine Betriebssystemlaufzeit](runtimes-provided.md) (die `provided`-Laufzeit-Familie), um Go-Funktionen für Lambda bereitzustellen.
**Topics**
+ [Unterstützte Go-Laufzeiten](#golang-al1)
+ [Tools und Bibliotheken](#golang-libraries)
+ [Definieren des Lambda-Funktions-Handlers in Go](golang-handler.md)
+ [Verwenden des Lambda-Kontextobjekts zum Abrufen von Go-Funktionsinformationen](golang-context.md)
+ [Bereitstellen von Lambda-Go-Funktionen mit ZIP-Dateiarchiven](golang-package.md)
+ [Bereitstellen von Go-Lambda-Funktionen mit Container-Images](go-image.md)
+ [Arbeiten mit Ebenen für Go Lambda-Funktionen](golang-layers.md)
+ [Go-Lambda-Funktionen protokollieren und überwachen](golang-logging.md)
+ [Go-Code instrumentieren in AWS Lambda](golang-tracing.md)
## Unterstützte Go-Laufzeiten
Die verwaltete Laufzeit Go 1.x für Lambda ist [veraltet](lambda-runtimes.md#runtime-support-policy). Wenn Sie Funktionen haben, die die Go 1.x-Laufzeit verwenden, müssen Sie Ihre Funktionen nach `provided.al2023` oder `provided.al2` migrieren. Die `provided.al2` Laufzeiten `provided.al2023` und bieten mehrere Vorteile gegenüber`go1.x`, darunter Unterstützung für die Arm64-Architektur (AWS Graviton2-Prozessoren), kleinere Binärdateien und etwas schnellere Aufrufzeiten.
Für diese Migration sind keine Codeänderungen erforderlich. Die einzigen erforderlichen Änderungen betreffen die Erstellung Ihres Bereitstellungspakets sowie die Laufzeit, die Sie zur Erstellung Ihrer Funktion verwenden. *Weitere Informationen finden Sie im Compute-Blog unter [AWS Lambda Funktionen von der GO1.x-Laufzeit zur benutzerdefinierten Laufzeit auf Amazon Linux 2 migrieren](https://aws.amazon.com/blogs/compute/migrating-aws-lambda-functions-from-the-go1-x-runtime-to-the-custom-runtime-on-amazon-linux-2/).AWS *
| Name | ID | Betriebssystem | Datum der Veraltung | Blockfunktion erstellen | Blockfunktion aktualisieren |
| --- | --- | --- | --- | --- | --- |
| Reine OS-Laufzeit | `provided.al2023` | Amazon Linux 2023 | 30. Juni 2029 | 31. Juli 2029 | 31. August 2029 |
| Reine OS-Laufzeit | `provided.al2` | Amazon Linux 2 | 31. Juli 2026 | 31. August 2026 | 30. September 2026 |
## Tools und Bibliotheken
Lambda stellt die folgenden Tools und Bibliotheken für die Go-Laufzeit bereit:
+ [AWS SDK für Go v2](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2): Das offizielle AWS SDK für die Programmiersprache Go.
+ [Github. com/aws/aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda): Die Implementierung des Lambda-Programmiermodells für Go. [Dieses Paket wird von verwendet AWS Lambda , um Ihren Handler aufzurufen.](golang-handler.md)
+ [Github. com/aws/aws-lambda-go/lambdacontext](https://github.com/aws/aws-lambda-go/tree/master/lambdacontext): Helfer für den Zugriff auf Kontextinformationen aus dem [Kontextobjekt](golang-context.md).
+ [Github. com/aws/aws-lambda-go/events](https://github.com/aws/aws-lambda-go/tree/master/events): Diese Bibliothek bietet Typdefinitionen für gängige Integrationen mit Ereignisquellen.
+ [Github. com/aws/aws-lambda-go/cmd/build-lambda-zip](https://github.com/aws/aws-lambda-go/tree/master/cmd/build-lambda-zip): Dieses Tool kann verwendet werden, um ein ZIP-Dateiarchiv unter Windows zu erstellen.
Weitere Informationen finden Sie unter. [aws-lambda-go](https://github.com/aws/aws-lambda-go) GitHub
Lambda stellt die folgenden Beispielanwendungen für die Go-Laufzeit bereit:
**Lambda-Beispielanwendungen in Go**
+ [go-al2](https://github.com/aws-samples/sessions-with-aws-sam/tree/master/go-al2): Eine Hello World-Funktion, die die öffentliche IP-Adresse zurückgibt. Diese App verwendet die benutzerdefinierte Laufzeit `provided.al2`.
+ [blank-go](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-go) — Eine Go-Funktion, die die Verwendung der Go-Bibliotheken, der Protokollierung, der Umgebungsvariablen und des SDK von Lambda zeigt. AWS Diese App verwendet die Laufzeit `go1.x`.
# Definieren des Lambda-Funktions-Handlers in Go
Der Lambda-Funktions*handler* ist die Methode in Ihrem Funktionscode, die Ereignisse verarbeitet. Wenn Ihre Funktion aufgerufen wird, führt Lambda die Handler-Methode aus. Ihre Funktion wird so lange ausgeführt, bis der Handler eine Antwort zurückgibt, beendet wird oder ein Timeout auftritt.
Auf dieser Seite wird beschrieben, wie Sie mit Lambda-Funktionshandlern in Go arbeiten, einschließlich der Projekteinrichtung, Benennungskonventionen und Best Practices. Diese Seite enthält auch ein Beispiel für eine Go-Lambda-Funktion, die Informationen über einen Auftrag aufnimmt, eine Textdatei als Quittung erstellt und diese Datei in einem Bucket von Amazon Simple Storage Service (Amazon S3) platziert. Informationen darüber, wie Sie Ihre Funktion nach dem Schreiben einsetzen können, finden Sie unter [Bereitstellen von Lambda-Go-Funktionen mit ZIP-Dateiarchiven](golang-package.md) oder [Bereitstellen von Go-Lambda-Funktionen mit Container-Images](go-image.md).
**Topics**
+ [Einrichten Ihres Go-Handler-Projekts](#golang-handler-setup)
+ [Beispiel für Go Lambda-Funktionscode](#golang-example-code)
+ [Namenskonventionen für Handler](#golang-handler-naming)
+ [Definieren Sie das Eingabeereignisobjekt und greifen Sie darauf zu](#golang-example-input)
+ [Zugreifen auf und Verwenden des Lambda-Kontextobjekts](#golang-example-context)
+ [Gültige Handler-Signaturen für Go-Handler](#golang-handler-signatures)
+ [Verwenden Sie die AWS SDK für Go v2 in Ihrem Handler](#golang-example-sdk-usage)
+ [Zugriff auf Umgebungsvariablen](#golang-example-envvars)
+ [Verwenden des globalen Zustands](#golang-handler-state)
+ [Bewährte Codemethoden für Go-Lambda-Funktionen](#go-best-practices)
## Einrichten Ihres Go-Handler-Projekts
Eine Lambda-Funktion in [Go](https://golang.org/) wird als ausführbare Go-Datei erstellt. Sie können ein Go-Lambda-Funktionsprojekt auf die gleiche Weise initialisieren wie jedes andere Go-Projekt, indem Sie den folgenden `go mod init`-Befehl verwenden:
```
go mod init example-go
```
Hier ist `example-go` der Name des Moduls. Sie können dies durch alles ersetzen. Dieser Befehl initialisiert Ihr Projekt und erzeugt die `go.mod`-Datei, in der die Abhängigkeiten Ihres Projekts aufgelistet sind.
Verwenden Sie den Befehl `go get`, um externe Abhängigkeiten zu Ihrem Projekt hinzuzufügen. Für alle Lambda-Funktionen in Go müssen Sie zum Beispiel das Paket [github.com/aws/aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda) einbinden, das das Lambda-Programmiermodell für Go implementiert. Binden Sie dieses Paket mit dem folgenden `go get`-Befehl ein:
```
go get github.com/aws/aws-lambda-go
```
Ihr Funktionscode sollte sich in einer Go-Datei befinden. Im folgenden Beispiel benennen wir diese Datei `main.go`. In dieser Datei implementieren Sie Ihre Kernfunktionslogik in einer Handler-Methode sowie in einer `main()`-Funktion, die diesen Handler aufruft.
## Beispiel für Go Lambda-Funktionscode
Das folgende Beispiel für einen Go-Lambda-Funktionscode nimmt Informationen über eine Bestellung auf, erstellt eine Textdateiquittung und platziert diese Datei in einem Amazon-S3-Bucket.
**Example `main.go`-Lambda-Funktion**
```
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
"strings"
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/s3"
)
type Order struct {
OrderID string `json:"order_id"`
Amount float64 `json:"amount"`
Item string `json:"item"`
}
var (
s3Client *s3.Client
)
func init() {
// Initialize the S3 client outside of the handler, during the init phase
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
log.Fatalf("unable to load SDK config, %v", err)
}
s3Client = s3.NewFromConfig(cfg)
}
func uploadReceiptToS3(ctx context.Context, bucketName, key, receiptContent string) error {
_, err := s3Client.PutObject(ctx, &s3.PutObjectInput{
Bucket: &bucketName,
Key: &key,
Body: strings.NewReader(receiptContent),
})
if err != nil {
log.Printf("Failed to upload receipt to S3: %v", err)
return err
}
return nil
}
func handleRequest(ctx context.Context, event json.RawMessage) error {
// Parse the input event
var order Order
if err := json.Unmarshal(event, &order); err != nil {
log.Printf("Failed to unmarshal event: %v", err)
return err
}
// Access environment variables
bucketName := os.Getenv("RECEIPT_BUCKET")
if bucketName == "" {
log.Printf("RECEIPT_BUCKET environment variable is not set")
return fmt.Errorf("missing required environment variable RECEIPT_BUCKET")
}
// Create the receipt content and key destination
receiptContent := fmt.Sprintf("OrderID: %s\nAmount: $%.2f\nItem: %s",
order.OrderID, order.Amount, order.Item)
key := "receipts/" + order.OrderID + ".txt"
// Upload the receipt to S3 using the helper method
if err := uploadReceiptToS3(ctx, bucketName, key, receiptContent); err != nil {
return err
}
log.Printf("Successfully processed order %s and stored receipt in S3 bucket %s", order.OrderID, bucketName)
return nil
}
func main() {
lambda.Start(handleRequest)
}
```
Diese `main.go`-Datei enthält die folgenden Abschnitte des Codes:
+ `package main`: In Go muss das Paket, das Ihre `func main()`-Funktion enthält, immer `main` heißen.
+ `import`-Block: Verwenden Sie diesen Block, um Bibliotheken einzubinden, die Ihre Lambda-Funktion benötigt.
+ `type Order struct {}`-Block: Definieren Sie die Form des erwarteten Eingabeereignisses in dieser Go-Struktur.
+ `var ()`-Block: Verwenden Sie diesen Block, um alle globalen Variablen zu definieren, die Sie in Ihrer Lambda-Funktion verwenden werden.
+ `func init() {}`: Fügen Sie in diese `init()`-Methode beliebigen Code ein, den Lambda während der [Initialisierungsphase](lambda-runtime-environment.md#runtimes-lifecycle-ib) ausführen soll.
+ `func uploadReceiptToS3(...) {}`: Dies ist eine Hilfsmethode, auf die von der `handleRequest`-Haupthandler-Methode verwiesen wird.
+ `func handleRequest(ctx context.Context, event json.RawMessage) error {}`: Dies ist die **Haupthandler-Methode**, die Ihre Hauptanwendungslogik enthält.
+ `func main() {}`: Dies ist ein erforderlicher Einstiegspunkt für Ihren Lambda-Handler. Das Argument für die `lambda.Start()`-Methode ist Ihre Haupthandler-Methode.
Damit diese Funktion ordnungsgemäß funktioniert, muss ihre [Ausführungsrolle](lambda-intro-execution-role.md) die `s3:PutObject`-Aktion zulassen. Stellen Sie außerdem sicher, dass Sie die `RECEIPT_BUCKET`-Umgebungsvariable definieren. Nach einem erfolgreichen Aufruf sollte der Amazon-S3-Bucket eine Empfangsdatei enthalten.
## Namenskonventionen für Handler
Für Lambda-Funktionen in Go können Sie einen beliebigen Namen für den Handler verwenden. In diesem Beispiel lautet der Name der Handler-Methode `handleRequest`. Sie können die Umgebungsvariable `_HANDLER` verwenden, um in Ihrem Code auf den Handler-Wert zu verweisen.
Bei Go-Funktionen, die mit einem [.zip-Bereitstellungspaket](golang-package.md) bereitgestellt werden, muss die ausführbare Datei, die Ihren Funktionscode enthält, den Namen `bootstrap` tragen. Darüber hinaus muss sich die `bootstrap`-Datei im Stammverzeichnis der .zip-Datei befinden. Für Go-Funktionen, die über ein [Container-Image](go-image.md#go-image-provided) bereitgestellt werden, können Sie einen beliebigen Namen für die ausführbare Datei verwenden.
## Definieren Sie das Eingabeereignisobjekt und greifen Sie darauf zu
JSON ist das gebräuchlichste und standardmäßigste Eingabeformat für Lambda-Funktionen. In diesem Beispiel erwartet die Funktion eine Eingabe ähnlich der folgenden:
```
{
"order_id": "12345",
"amount": 199.99,
"item": "Wireless Headphones"
}
```
Wenn Sie mit Lambda-Funktionen in Go arbeiten, können Sie die Form des erwarteten Eingabeereignisses als Go-Struktur definieren. In diesem Beispiel definieren wir eine Struktur, die einen `Order` darstellt:
```
type Order struct {
OrderID string `json:"order_id"`
Amount float64 `json:"amount"`
Item string `json:"item"`
}
```
Diese Struktur entspricht der erwarteten Eingabeform. Nachdem Sie Ihre Struktur definiert haben, können Sie eine Handler-Signatur schreiben, die einen generischen JSON-Typ verwendet, der mit der [encoding/json-Standardbibliothek](https://pkg.go.dev/encoding/json) kompatibel ist. Sie können es dann mit der Funktion [func Unmarshal](https://golang.org/pkg/encoding/json/#Unmarshal) in Ihre Struktur deserialisieren. Dies wird in den ersten Zeilen des Handlers veranschaulicht:
```
func handleRequest(ctx context.Context, event json.RawMessage) error {
// Parse the input event
var order Order
if err := json.Unmarshal(event, &order); err != nil {
log.Printf("Failed to unmarshal event: %v", err)
return err
...
}
```
Nach dieser Deserialisierung können Sie auf die Felder der `order`-Variablen zugreifen. Zum Beispiel holt `order.OrderID` den Wert von `"order_id"` aus der ursprünglichen Eingabe.
**Anmerkung**
Das `encoding/json`-Paket kann nur auf exportierte Felder zugreifen. Um exportiert werden, müssen Feldnamen in der Ereignisstruktur großgeschrieben werden.
## Zugreifen auf und Verwenden des Lambda-Kontextobjekts
Das Lambda-[Kontextobjekt](golang-context.md) enthält Informationen über Aufruf, Funktion und Ausführungsumgebung. In diesem Beispiel haben wir diese Variable wie `ctx` in der Handler-Signatur deklariert:
```
func handleRequest(ctx context.Context, event json.RawMessage) error {
...
}
```
Die `ctx context.Context`-Eingabe ist ein optionales Argument in Ihrem Funktionshandler. Weitere Informationen zu akzeptierten Handler-Signaturen finden Sie unter [Gültige Handler-Signaturen für Go-Handler](#golang-handler-signatures).
Wenn Sie mit dem AWS-SDK andere Dienste aufrufen, wird das Kontextobjekt in einigen wichtigen Bereichen benötigt. Um beispielsweise Ihre SDK-Clients ordnungsgemäß zu initialisieren, können Sie die richtige AWS-SDK-Konfiguration mithilfe des Kontextobjekts wie folgt laden:
```
// Load AWS SDK configuration using the default credential provider chain
cfg, err := config.LoadDefaultConfig(ctx)
```
SDK-Aufrufe selbst benötigen möglicherweise das Kontextobjekt als Eingabe. Der Aufruf von `s3Client.PutObject` akzeptiert beispielsweise das Kontextobjekt als erstes Argument:
```
// Upload the receipt to S3
_, err = s3Client.PutObject(ctx, &s3.PutObjectInput{
...
})
```
Außerhalb von AWS-SDK-Anfragen können Sie das Kontextobjekt auch für die Funktionsüberwachung verwenden. Weitere Informationen über das Kontextobjekt finden Sie unter [Verwenden des Lambda-Kontextobjekts zum Abrufen von Go-Funktionsinformationen](golang-context.md).
## Gültige Handler-Signaturen für Go-Handler
Sie haben bei der Erstellung eines Lambda-Funktions-Handlers in Go mehrere Möglichkeiten. Allerdings müssen die folgenden Regeln beachten:
+ Der Handler muss eine Funktion sein.
+ Der Handler kann zwischen 0 und 2 Argumente aufnehmen. Bei zwei Argumenten muss das erste Argument implementiere `context.Context`.
+ Der Handler kann zwischen 0 und 2 Argumente zurückgeben. Bei einem einzigen Rückgabewert muss er implementiere `error`. Bei zwei Rückgabewerten muss der zweite Wert implementiere `error`.
Im Folgenden werden gültige Handler-Signaturen aufgeführt. `TIn` und `TOut` stellen Typen dar, die mit der Standardbibliothek *encoding/json* kompatibel sind. Weitere Informationen zur Deserialisierung dieser Typen finden Sie unter [func Unmarshal](https://golang.org/pkg/encoding/json/#Unmarshal).
+
```
func ()
```
+
```
func () error
```
+
```
func () (TOut, error)
```
+
```
func (TIn) error
```
+
```
func (TIn) (TOut, error)
```
+
```
func (context.Context) error
```
+
```
func (context.Context) (TOut, error)
```
+
```
func (context.Context, TIn) error
```
+
```
func (context.Context, TIn) (TOut, error)
```
## Verwenden Sie die AWS SDK für Go v2 in Ihrem Handler
Oft verwenden Sie Lambda-Funktionen, um mit anderen AWS-Ressourcen zu interagieren oder diese zu aktualisieren. Die einfachste Art, eine Schnittstelle zu diesen Ressourcen herzustellen, ist die Verwendung von [AWS SDK für Go v2](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2).
**Anmerkung**
AWS SDK für Go (v1) befindet sich im Wartungsmodus und der Support wird am 31. Juli 2025 eingestellt. Wir empfehlen, dass Sie in Zukunft nur noch AWS SDK für Go v2 verwenden.
Um Ihrer Funktion SDK-Abhängigkeiten hinzuzufügen, verwenden Sie den `go get`-Befehl für die spezifischen SDK-Clients, die Sie benötigen. Im Beispielcode zuvor haben wir die `config`-Bibliothek und die `s3`-Bibliothek verwendet. Fügen Sie diese Abhängigkeiten hinzu, indem Sie die folgenden Befehle in dem Verzeichnis ausführen, das Ihre `go.mod`- und `main.go `-Dateien enthält:
```
go get github.com/aws/aws-sdk-go-v2/config
go get github.com/aws/aws-sdk-go-v2/service/s3
```
Importieren Sie dann die Abhängigkeiten entsprechend in den Importblock Ihrer Funktion:
```
import (
...
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/s3"
)
```
Wenn Sie das SDK in Ihrem Handler verwenden, konfigurieren Sie Ihre Clients mit den richtigen Einstellungen. Der einfachste Weg, dies zu tun, besteht darin, die [standardmäßige Anbieterkette für Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html#credentialProviderChain) zu verwenden. Dieses Beispiel zeigt eine Möglichkeit, diese Konfiguration zu laden:
```
// Load AWS SDK configuration using the default credential provider chain
cfg, err := config.LoadDefaultConfig(ctx)
if err != nil {
log.Printf("Failed to load AWS SDK config: %v", err)
return err
}
```
Nachdem Sie diese Konfiguration in die `cfg`-Variable geladen haben, können Sie diese Variable an Client-Instanziierungen übergeben. Der Beispielcode instanziiert einen Amazon-S3-Client wie folgt:
```
// Create an S3 client
s3Client := s3.NewFromConfig(cfg)
```
In diesem Beispiel haben wir unseren Amazon-S3-Client in der `init()`-Funktion initialisiert, um zu vermeiden, dass wir ihn bei jedem Aufruf unserer Funktion initialisieren müssen. Das Problem ist, dass Lambda in der `init()`-Funktion keinen Zugriff auf das Kontextobjekt hat. Als Abhilfe können Sie in der Initialisierungsphase einen Platzhalter wie `context.TODO()` übergeben. Wenn Sie später über den Client einen Anruf tätigen, übergeben Sie das vollständige Kontextobjekt. Diese Abhilfemaßnahme wird auch in [Verwendung des Kontexts bei Initialisierungen und Aufrufen von AWS-SDK-Clients](golang-context.md#golang-context-sdk) beschrieben.
Nachdem Sie Ihren SDK-Client konfiguriert und initialisiert haben, können Sie ihn für die Interaktion mit anderen AWS-Diensten verwenden. Der Beispielcode ruft die Amazon S3 `PutObject`-API wie folgt auf:
```
_, err = s3Client.PutObject(ctx, &s3.PutObjectInput{
Bucket: &bucketName,
Key: &key,
Body: strings.NewReader(receiptContent),
})
```
## Zugriff auf Umgebungsvariablen
In Ihrem Handler-Code können Sie mithilfe der `os.Getenv()`-Methode auf beliebige [Umgebungsvariablen](configuration-envvars.md) verweisen. In diesem Beispiel verweisen wir mit der folgenden Codezeile auf die definierte `RECEIPT_BUCKET`-Umgebungsvariable:
```
// Access environment variables
bucketName := os.Getenv("RECEIPT_BUCKET")
if bucketName == "" {
log.Printf("RECEIPT_BUCKET environment variable is not set")
return fmt.Errorf("missing required environment variable RECEIPT_BUCKET")
}
```
## Verwenden des globalen Zustands
Um zu vermeiden, dass bei jedem Funktionsaufruf neue Ressourcen erstellt werden, können Sie globale Variablen außerhalb des Handler-Codes Ihrer Lambda-Funktion deklarieren und ändern. Sie definieren diese globalen Variablen in einem `var`-Block oder einer Anweisung. Darüber hinaus deklariert Ihr Handler möglicherweise eine `init()`-Funktion, die während der [Initialisierungsphase](lambda-runtime-environment.md#runtimes-lifecycle-ib) ausgeführt wird. Die `init`-Methode verhält sich in AWS Lambda genauso wie in normalen Go-Programmen.
## Bewährte Codemethoden für Go-Lambda-Funktionen
Halten Sie sich an die Richtlinien in der folgenden Liste, um beim Erstellen Ihrer Lambda-Funktionen die besten Codierungspraktiken anzuwenden:
+ **Trennen Sie den Lambda-Handler von Ihrer Core-Logik.** Auf diese Weise können Sie eine Funktion zur besseren Prüfbarkeit von Einheiten schaffen.
+ **Minimieren Sie die Komplexität Ihrer Abhängigkeiten.** Ziehen Sie einfachere Frameworks vor, die sich schnell beim Start der [Ausführungsumgebung](lambda-runtime-environment.md) laden lassen.
+ **Minimieren Sie die Größe Ihres Bereitstellungspakets auf die für die Laufzeit erforderliche Größe.** Dadurch verkürzt sich die Zeit, die für das Herunterladen und Entpacken Ihres Bereitstellungspakets vor dem Aufruf benötigt wird.
**Nutzen Sie die Wiederverwendung der Ausführungsumgebung zur Verbesserung Ihrer Funktion.** Initialisieren Sie SDK-Clients und Datenbankverbindungen außerhalb des Funktions-Handlers und speichern Sie statische Komponenten lokal im `/tmp`-Verzeichnis. Nachfolgende Aufrufe, die von derselben Instance Ihrer Funktion verarbeitet werden, können diese Ressourcen wiederverwenden. Dies spart Kosten durch Reduzierung der Funktionslaufzeit.
Um potenzielle Datenlecks über Aufrufe hinweg zu vermeiden, verwenden Sie die Ausführungsumgebung nicht, um Benutzerdaten, Ereignisse oder andere Informationen mit Sicherheitsauswirkungen zu speichern. Wenn Ihre Funktion auf einem veränderbaren Zustand beruht, der nicht im Speicher innerhalb des Handlers gespeichert werden kann, sollten Sie für jeden Benutzer eine separate Funktion oder separate Versionen einer Funktion erstellen.
**Verwenden Sie eine Keep-Alive-Direktive, um dauerhafte Verbindungen zu pflegen.** Lambda bereinigt Leerlaufverbindungen im Laufe der Zeit. Der Versuch, eine Leerlaufverbindung beim Aufruf einer Funktion wiederzuverwenden, führt zu einem Verbindungsfehler. Um Ihre persistente Verbindung aufrechtzuerhalten, verwenden Sie die Keep-Alive-Direktive, die Ihrer Laufzeit zugeordnet ist. Ein Beispiel finden Sie unter [Wiederverwenden von Verbindungen mit Keep-Alive in Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html).
**Verwenden Sie [Umgebungsvariablen](configuration-envvars.md) um Betriebsparameter an Ihre Funktion zu übergeben.** Wenn Sie z. B. Daten in einen Amazon-S3-Bucket schreiben, anstatt den Bucket-Namen, in den Sie schreiben, hartzucodieren, konfigurieren Sie den Bucket-Namen als Umgebungsvariable.
**Vermeiden Sie rekursive Aufrufe** in Ihrer Lambda-Funktion, bei denen die Funktion sich selbst aufruft oder einen Prozess initiiert, der die Funktion erneut aufrufen kann. Dies kann zu unvorhergesehenen Mengen an Funktionsaufrufen führen und höhere Kosten zur Folge haben. Wenn Sie eine unbeabsichtigte Menge von Aufrufen feststellen, legen Sie die reservierte gleichzeitige Ausführung der Funktion auf `0` fest, um sofort alle Aufrufe der Funktion zu drosseln, während Sie den Code aktualisieren.
**Verwenden Sie keine nicht dokumentierten, nicht öffentlichen APIs** in Ihrem Lambda-Funktionscode. Für AWS Lambda-verwaltete Laufzeiten wendet Lambda regelmäßig Sicherheits- und Funktionsupdates auf Lambdas interne APIs an. Diese internen API-Updates können abwärtskompatibel sein, was zu unbeabsichtigten Konsequenzen wie Aufruffehlern führt, wenn Ihre Funktion von diesen nicht öffentlichen APIs abhängig ist. Eine Liste öffentlich zugänglicher APIs finden Sie in der [API-Referenz](https://docs.aws.amazon.com/lambda/latest/api/welcome.html).
**Schreiben Sie idempotenten Code.** Das Schreiben idempotenter Code für Ihre Funktionen stellt sicher, dass doppelte Ereignisse auf die gleiche Weise behandelt werden. Ihr Code sollte Ereignisse ordnungsgemäß validieren und doppelte Ereignisse ordnungsgemäß behandeln. Weitere Informationen finden Sie unter [Wie mache ich meine Lambda-Funktion idempotent?](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-idempotent/).
# Verwenden des Lambda-Kontextobjekts zum Abrufen von Go-Funktionsinformationen
In Lambda bietet das Kontextobjekt Methoden und Eigenschaften mit Informationen über den Aufruf, die Funktion und die Ausführungsumgebung. Wenn Lambda Ihre Funktion ausführt, wird ein Context-Objekt an den [Handler](golang-handler.md) übergeben. Um das Kontextobjekt in Ihrem Handler zu verwenden, können Sie es optional als Eingabeparameter für Ihren Handler deklarieren. Das Kontextmenüobjekt ist erforderlich, wenn Sie in Ihrem Handler Folgendes tun möchten:
+ Sie benötigen Zugriff auf eine der [globalen Variablen, Methoden oder Eigenschaften](#golang-context-library), die vom Kontextobjekt angeboten werden. Diese Methoden und Eigenschaften sind nützlich für Aufgaben wie die Bestimmung der Entität, die Ihre Funktion aufgerufen hat, oder die Messung der Aufrufzeit Ihrer Funktion, wie in [Zugreifen auf Aufrufkontextinformationen](#golang-context-access) dargestellt.
+ Sie müssen das AWS SDK für Go verwenden, um Anrufe an andere Dienste zu tätigen. Das Kontextobjekt ist ein wichtiger Eingabeparameter für die meisten dieser Aufrufe. Weitere Informationen finden Sie unter [Verwendung des Kontexts bei Initialisierungen und Aufrufen von AWS-SDK-Clients](#golang-context-sdk).
**Topics**
+ [Unterstützte Variablen, Methoden und Eigenschaften im Kontextmenüobjekt](#golang-context-library)
+ [Zugreifen auf Aufrufkontextinformationen](#golang-context-access)
+ [Verwendung des Kontexts bei Initialisierungen und Aufrufen von AWS-SDK-Clients](#golang-context-sdk)
## Unterstützte Variablen, Methoden und Eigenschaften im Kontextmenüobjekt
Die Lambda-Kontextbibliothek bietet die folgenden globalen Variablen, Methoden und Eigenschaften.
**Globale Variablen**
+ `FunctionName` – Der Name der Lambda-Funktion.
+ `FunctionVersion` – Die [Version](configuration-versions.md) der Funktion.
+ `MemoryLimitInMB` – Die Menge an Arbeitsspeicher, die der Funktion zugewiesen ist.
+ `LogGroupName` – Protokollgruppe für die Funktion.
+ `LogStreamName` – Der Protokollstrom für die Funktionsinstance.
**Context-Methoden**
+ `Deadline` – Gibt das Datum zurück, an dem eine Zeitüberschreitung für die Ausführung eintritt (in Unix-Millisekunden).
**Context-Eigenschaften**
+ `InvokedFunctionArn` – Der Amazon-Ressourcenname (ARN), der zum Aufrufen der Funktion verwendet wird. Gibt an, ob der Aufrufer eine Versionsnummer oder einen Alias angegeben hat.
+ `AwsRequestID` – Der Bezeichner der Aufrufanforderung.
+ `Identity` – Informationen zur Amazon-Cognito-Identität, die die Anforderung autorisiert hat.
+ `ClientContext` – (mobile Apps) Clientkontext, der Lambda von der Clientanwendung bereitgestellt wird.
## Zugreifen auf Aufrufkontextinformationen
Lambda-Funktionen haben Zugriff auf Metadaten über ihre Umgebung und die Aufrufanforderung. Darauf kann unter [Paketkontext](https://golang.org/pkg/context/) zugegriffen werden. Falls Ihr Handler `context.Context` als Parameter umfasst, fügt Lambda Informationen über Ihre Funktion in der `Value`-Eigenschaft des Kontexts ein. Beachten Sie, dass Sie die `lambdacontext`-Bibliothek importieren müssen, um auf die Inhalte des `context.Context`-Objekts zuzugreifen.
```
package main
import (
"context"
"log"
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-lambda-go/lambdacontext"
)
func CognitoHandler(ctx context.Context) {
lc, _ := lambdacontext.FromContext(ctx)
log.Print(lc.Identity.CognitoIdentityPoolID)
}
func main() {
lambda.Start(CognitoHandler)
}
```
Im Beispiel oben ist `lc` die Variable, mit der die vom Kontextobjekt erfassten Informationen verarbeitet werden, und `log.Print(lc.Identity.CognitoIdentityPoolID)` druckt diese Informationen. In diesem Fall ist dies CognitoIdentityPoolID.
Das folgende Beispiel bietet eine Einführung in die Verwendung der Kontextobjekte zur Überwachung der Abschlussdauer Ihrer Lambda-Funktion. Damit können Sie die Leistungserwartungen analysieren und Ihren Funktionscode bei Bedarf entsprechend anpassen.
```
package main
import (
"context"
"log"
"time"
"github.com/aws/aws-lambda-go/lambda"
)
func LongRunningHandler(ctx context.Context) (string, error) {
deadline, _ := ctx.Deadline()
deadline = deadline.Add(-100 * time.Millisecond)
timeoutChannel := time.After(time.Until(deadline))
for {
select {
case <- timeoutChannel:
return "Finished before timing out.", nil
default:
log.Print("hello!")
time.Sleep(50 * time.Millisecond)
}
}
}
func main() {
lambda.Start(LongRunningHandler)
}
```
## Verwendung des Kontexts bei Initialisierungen und Aufrufen von AWS-SDK-Clients
Wenn Ihr Handler das AWS SDK für Go verwenden muss, um andere Dienste aufzurufen, schließen Sie das Kontextobjekt als Eingabe in Ihren Handler ein. In AWS ist es eine bewährte Praxis, das Kontextobjekt in den meisten AWS-SDK-Aufrufen zu übergeben. Der Aufruf von Amazon S3 `PutObject` akzeptiert beispielsweise das Kontextobjekt (`ctx`) als erstes Argument:
```
// Upload an object to S3
_, err = s3Client.PutObject(ctx, &s3.PutObjectInput{
...
})
```
Um Ihre SDK-Clients richtig zu initialisieren, können Sie auch das Kontext-Objekt verwenden, um die richtige Konfiguration zu laden, bevor Sie dieses Konfigurationsobjekt an den Client übergeben:
```
// Load AWS SDK configuration using the default credential provider chain
cfg, err := config.LoadDefaultConfig(ctx)
...
s3Client = s3.NewFromConfig(cfg)
```
Wenn Sie Ihre SDK-Clients außerhalb Ihres Haupthandlers initialisieren möchten (d. h. während der Initialisierungsphase), können Sie ein Platzhalter-Kontextobjekt übergeben:
```
func init() {
// Initialize the S3 client outside of the handler, during the init phase
cfg, err := config.LoadDefaultConfig(context.TODO())
...
s3Client = s3.NewFromConfig(cfg)
}
```
Wenn Sie Ihre Clients auf diese Weise initialisieren, stellen Sie sicher, dass Sie bei SDK-Aufrufen von Ihrem Haupthandler das richtige Kontextobjekt übergeben.
# Bereitstellen von Lambda-Go-Funktionen mit ZIP-Dateiarchiven
Der Code Ihrer AWS Lambda Funktion besteht aus Skripten oder kompilierten Programmen und deren Abhängigkeiten. Sie verwenden ein *Bereitstellungspaket*, um Ihren Funktionscode in Lambda bereitzustellen. Lambda unterstützt zwei Arten von Bereitstellungspaketen: Container-Images und ZIP-Dateiarchiven.
Auf dieser Seite wird beschrieben, wie Sie eine .zip-Datei als Bereitstellungspaket für die Go-Laufzeit erstellen und dann die .zip-Datei verwenden, um Ihren Funktionscode AWS Lambda mithilfe von AWS-Managementkonsole, AWS Command Line Interface (AWS CLI) und AWS Serverless Application Model (AWS SAM) bereitzustellen.
Da Lambda POSIX-Dateiberechtigungen verwendet, müssen Sie möglicherweise [Berechtigungen für den Bereitstellungspaketordner festlegen](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-deployment-package-errors/), bevor Sie das ZIP-Dateiarchiv erstellen.
**Topics**
+ [Erstellen einer ZIP-Datei unter macOS und Linux](#golang-package-mac-linux)
+ [Erstellen einer ZIP-Datei unter Windows](#golang-package-windows)
+ [Go Lambda-Funktionen mithilfe von ZIP-Dateien erstellen und aktualisieren](#golang-package-create-function)
## Erstellen einer ZIP-Datei unter macOS und Linux
Im Folgenden wird beschrieben, wie Sie Ihre ausführbare Datei mithilfe des Befehls `go build` kompilieren und ein Bereitstellungspaket in Form einer ZIP-Datei für Lambda erstellen. Stellen Sie vor dem Kompilieren Ihres Codes sicher, dass Sie das [Lambda-Paket](https://github.com/aws/aws-lambda-go/tree/master/lambda) von installiert haben. GitHub Dieses Modul stellt eine Implementierung der Laufzeitschnittstelle bereit, die die Interaktion zwischen Lambda und Ihrem Funktionscode verwaltet. Führen Sie den folgenden Befehl aus, um diese Bibliothek herunterzuladen.
```
go get github.com/aws/aws-lambda-go/lambda
```
Wenn Ihre Funktion das verwendet AWS SDK für Go, laden Sie den Standardsatz von SDK-Modulen zusammen mit allen AWS Service-API-Clients herunter, die für Ihre Anwendung erforderlich sind. Informationen zur Installation des SDK for Go finden Sie unter [Erste Schritte mit der AWS SDK für Go V2](https://github.com/aws/aws-sdk-go-v2?tab=readme-ov-file#getting-started).
### Verwenden der bereitgestellten Laufzeitfamilie
Go wird anders implementiert als andere verwaltete Laufzeiten. Da Go nativ zu einer ausführbaren Binärdatei kompiliert wird, ist keine spezielle Sprachlaufzeit erforderlich. Verwenden Sie eine [reine Betriebssystemlaufzeit](runtimes-provided.md) (die `provided`-Laufzeit-Familie), um Go-Funktionen für Lambda bereitzustellen.
**So erstellen Sie ein ZIP-Bereitstellungspaket (macOS/Linux)**
1. Kompilieren Sie Ihre ausführbare Datei in dem Projektverzeichnis, das die Datei `main.go` Ihrer Anwendung enthält. Beachten Sie Folgendes:
+ Die ausführbare Datei muss `bootstrap` heißen. Weitere Informationen finden Sie unter [Namenskonventionen für Handler](golang-handler.md#golang-handler-naming).
+ Legen Sie die [Befehlssatzarchitektur](foundation-arch.md) des Ziels fest. Reine Betriebssystem-Laufzeiten unterstützen sowohl arm64 als auch x86\$164.
+ Sie können das optionale Tag `lambda.norpc` verwenden, um die RPC-Komponente (Remote Procedure Call, Remoteprozeduraufruf) der Bibliothek [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda) auszuschließen. Die RPC-Komponente ist nur erforderlich, wenn Sie die veraltete Go 1.x-Laufzeit verwenden. Durch Ausschließen der RPC-Komponente verringert sich die Größe des Bereitstellungspakets.
arm64-Architektur:
```
GOOS=linux GOARCH=arm64 go build -tags lambda.norpc -o bootstrap main.go
```
x86\$164-Architektur:
```
GOOS=linux GOARCH=amd64 go build -tags lambda.norpc -o bootstrap main.go
```
1. (Optional) Möglicherweise müssen Sie Pakete mit Einstellung von `CGO_ENABLED=0` in Linux kompilieren:
```
GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -o bootstrap -tags lambda.norpc main.go
```
Dieser Befehl erstellt ein stabiles Binärpaket für Standard-C-Bibliotheksversionen (`libc`), was auf Lambda und anderen Geräten unterschiedlich sein kann.
1. Erstellen Sie ein Bereitstellungspaket, indem Sie die ausführbare Datei in eine ZIP-Datei packen.
```
zip myFunction.zip bootstrap
```
**Anmerkung**
Fügen Sie die `bootstrap`-Datei dem Stamm der ZIP-Datei hinzu.
1. Erstellen der -Funktion Beachten Sie Folgendes:
+ Die Binärdatei muss `bootstrap` benannt werden, aber der Handlername kann beliebig sein. Weitere Informationen finden Sie unter [Namenskonventionen für Handler](golang-handler.md#golang-handler-naming).
+ Die `--architectures`-Option ist nur bei Verwendung von „arm64“ erforderlich. Der Standardwert ist „x86\$164“.
+ Geben Sie für `--role` den Amazon-Ressourcennamen (ARN) der [Ausführungsrolle](lambda-intro-execution-role.md) an.
```
aws lambda create-function --function-name myFunction \
--runtime provided.al2023 --handler bootstrap \
--architectures arm64 \
--role arn:aws:iam::111122223333:role/lambda-ex \
--zip-file fileb://myFunction.zip
```
## Erstellen einer ZIP-Datei unter Windows
Die folgenden Schritte zeigen, wie Sie das [build-lambda-zip](https://github.com/aws/aws-lambda-go/tree/main/cmd/build-lambda-zip)Tool für Windows von herunterladen GitHub, Ihre ausführbare Datei kompilieren und ein ZIP-Bereitstellungspaket erstellen.
**Anmerkung**
Falls noch nicht geschehen, müssen Sie [git](https://git-scm.com/) installieren und die ausführbare `git`-Datei Ihrer Windows- `%PATH%`-Umgebungsvariable hinzufügen.
Stellen Sie vor dem Kompilieren Ihres Codes sicher, dass Sie die [Lambda-Bibliothek](https://github.com/aws/aws-lambda-go/tree/master/lambda) von installiert haben. GitHub Führen Sie den folgenden Befehl aus, um diese Bibliothek herunterzuladen.
```
go get github.com/aws/aws-lambda-go/lambda
```
Wenn Ihre Funktion das verwendet AWS SDK für Go, laden Sie den Standardsatz von SDK-Modulen zusammen mit allen AWS Service-API-Clients herunter, die für Ihre Anwendung erforderlich sind. Informationen zur Installation des SDK for Go finden Sie unter [Erste Schritte mit der AWS SDK für Go V2](https://aws.github.io/aws-sdk-go-v2/docs/getting-started/).
### Verwenden der bereitgestellten Laufzeitfamilie
Go wird anders implementiert als andere verwaltete Laufzeiten. Da Go nativ zu einer ausführbaren Binärdatei kompiliert wird, ist keine spezielle Sprachlaufzeit erforderlich. Verwenden Sie eine [reine Betriebssystemlaufzeit](runtimes-provided.md) (die `provided`-Laufzeit-Familie), um Go-Funktionen für Lambda bereitzustellen.
**So erstellen Sie ein ZIP-Bereitstellungspaket (Windows)**
1. Laden Sie das **build-lambda-zip**Tool von herunter GitHub.
```
go install github.com/aws/aws-lambda-go/cmd/build-lambda-zip@latest
```
1. Verwenden Sie das Tool aus Ihrer `GOPATH`, um eine ZIP-Datei zu erstellen. Bei einer Go-Standardinstallation befindet sich das Tool in der Regel unter `%USERPROFILE%\Go\bin`. Navigieren Sie andernfalls an den Installationsort der Go-Laufzeit und führen Sie einen der folgenden Schritte aus:
------
#### [ cmd.exe ]
Verwenden Sie in „cmd.exe“ je nach [Befehlssatzarchitektur](foundation-arch.md) des Ziels eine der folgenden Optionen. Reine Betriebssystem-Laufzeiten unterstützen sowohl arm64 als auch x86\$164.
Sie können das optionale Tag `lambda.norpc` verwenden, um die RPC-Komponente (Remote Procedure Call, Remoteprozeduraufruf) der Bibliothek [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda) auszuschließen. Die RPC-Komponente ist nur erforderlich, wenn Sie die veraltete Go 1.x-Laufzeit verwenden. Durch Ausschließen der RPC-Komponente verringert sich die Größe des Bereitstellungspakets.
**Example für die x86\$164-Architektur**
```
set GOOS=linux
set GOARCH=amd64
set CGO_ENABLED=0
go build -tags lambda.norpc -o bootstrap main.go
%USERPROFILE%\Go\bin\build-lambda-zip.exe -o myFunction.zip bootstrap
```
**Example für die arm64-Architektur**
```
set GOOS=linux
set GOARCH=arm64
set CGO_ENABLED=0
go build -tags lambda.norpc -o bootstrap main.go
%USERPROFILE%\Go\bin\build-lambda-zip.exe -o myFunction.zip bootstrap
```
------
#### [ PowerShell ]
Führen Sie in PowerShell, abhängig von Ihrer [Ziel-Befehlssatzarchitektur](foundation-arch.md), einen der folgenden Schritte aus. Reine Betriebssystem-Laufzeiten unterstützen sowohl arm64 als auch x86\$164.
Sie können das optionale Tag `lambda.norpc` verwenden, um die RPC-Komponente (Remote Procedure Call, Remoteprozeduraufruf) der Bibliothek [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda) auszuschließen. Die RPC-Komponente ist nur erforderlich, wenn Sie die veraltete Go 1.x-Laufzeit verwenden. Durch Ausschließen der RPC-Komponente verringert sich die Größe des Bereitstellungspakets.
x86\$164-Architektur:
```
$env:GOOS = "linux"
$env:GOARCH = "amd64"
$env:CGO_ENABLED = "0"
go build -tags lambda.norpc -o bootstrap main.go
~\Go\Bin\build-lambda-zip.exe -o myFunction.zip bootstrap
```
arm64-Architektur:
```
$env:GOOS = "linux"
$env:GOARCH = "arm64"
$env:CGO_ENABLED = "0"
go build -tags lambda.norpc -o bootstrap main.go
~\Go\Bin\build-lambda-zip.exe -o myFunction.zip bootstrap
```
------
1. Erstellen der -Funktion Beachten Sie Folgendes:
+ Die Binärdatei muss `bootstrap` benannt werden, aber der Handlername kann beliebig sein. Weitere Informationen finden Sie unter [Namenskonventionen für Handler](golang-handler.md#golang-handler-naming).
+ Die `--architectures`-Option ist nur bei Verwendung von „arm64“ erforderlich. Der Standardwert ist „x86\$164“.
+ Geben Sie für `--role` den Amazon-Ressourcennamen (ARN) der [Ausführungsrolle](lambda-intro-execution-role.md) an.
```
aws lambda create-function --function-name myFunction \
--runtime provided.al2023 --handler bootstrap \
--architectures arm64 \
--role arn:aws:iam::111122223333:role/lambda-ex \
--zip-file fileb://myFunction.zip
```
## Go Lambda-Funktionen mithilfe von ZIP-Dateien erstellen und aktualisieren
Nach der Erstellung Ihres ZIP-Bereitstellungspakets können Sie es verwenden, um eine neue Lambda-Funktion zu erstellen oder eine vorhandene zu aktualisieren. Sie können Ihr .zip-Paket mithilfe der Lambda-Konsole, der und der AWS Command Line Interface Lambda-API bereitstellen. Sie können Lambda-Funktionen auch mit AWS Serverless Application Model (AWS SAM) und CloudFormation erstellen und aktualisieren.
Die maximale Größe eines ZIP-Bereitstellungspakets für Lambda beträgt 250 MB (entpackt). Beachten Sie, dass dieser Grenzwert für die kombinierte Größe aller hochgeladenen Dateien gilt, einschließlich aller Lambda-Ebenen.
Die Lambda-Laufzeit benötigt die Berechtigung zum Lesen der Dateien in Ihrem Bereitstellungspaket. In der oktalen Schreibweise von Linux-Berechtigungen benötigt Lambda 644 Berechtigungen für nicht ausführbare Dateien (rw-r--r--) und 755 Berechtigungen () für Verzeichnisse und ausführbare Dateien. rwxr-xr-x
Verwenden Sie unter Linux und MacOS den `chmod`-Befehl, um Dateiberechtigungen für Dateien und Verzeichnisse in Ihrem Bereitstellungspaket zu ändern. Um beispielsweise einer nicht ausführbaren Datei die richtigen Berechtigungen zu geben, führen Sie den folgenden Befehl aus.
```
chmod 644
```
Informationen zum Ändern von Dateiberechtigungen in Windows finden Sie unter [Festlegen, Anzeigen, Ändern oder Entfernen von Berechtigungen für ein Objekt](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc731667(v=ws.10)) in der Microsoft-Windows-Dokumentation.
**Anmerkung**
Wenn Sie Lambda nicht die Berechtigungen gewähren, die es für den Zugriff auf Verzeichnisse in Ihrem Bereitstellungspaket benötigt, setzt Lambda die Berechtigungen für diese Verzeichnisse auf 755 (). rwxr-xr-x
### Erstellen und Aktualisieren von Funktionen mit ZIP-Dateien unter Verwendung der Konsole
Eine neue Funktion müssen Sie zuerst in der Konsole erstellen und dann Ihr ZIP-Archiv hochladen. Zum Aktualisieren einer bestehenden Funktion öffnen Sie die Seite für Ihre Funktion und gehen dann genauso vor, um Ihre aktualisierte ZIP-Datei hinzuzufügen.
Bei einer ZIP-Datei mit unter 50 MB können Sie eine Funktion erstellen oder aktualisieren, indem Sie die Datei direkt von Ihrem lokalen Computer hochladen. Bei ZIP-Dateien mit einer Größe von mehr als 50 MB müssen Sie Ihr Paket zuerst in einen Amazon-S3-Bucket hochladen. Anweisungen zum Hochladen einer Datei in einen Amazon S3-Bucket mithilfe von finden Sie unter [Erste Schritte mit Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html). AWS-Managementkonsole Informationen zum Hochladen von Dateien mit dem AWS CLI finden Sie unter [Objekte verschieben](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) im *AWS CLI Benutzerhandbuch*.
**Anmerkung**
Sie können eine vorhandene Container-Image-Funktion nicht konvertieren, um ein ZIP-Archiv zu verwenden. Sie müssen eine neue Funktion erstellen.
**So erstellen Sie eine neue Funktion (Konsole)**
1. Öffnen Sie die [Funktionsseite](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole und wählen Sie **Funktion erstellen** aus.
1. Wählen Sie **Author from scratch** aus.
1. Führen Sie unter **Basic information** (Grundlegende Informationen) die folgenden Schritte aus:
1. Geben Sie als **Funktionsname** den Namen Ihrer Funktion ein.
1. Wählen Sie unter **Runtime (Laufzeit)** `provided.al2023` aus.
1. (Optional) Erweitern Sie unter **Berechtigungen** die Option **Standardausführungsrolle ändern**. Sie können eine neue **Ausführungsrolle** erstellen oder eine vorhandene Rolle verwenden.
1. Wählen Sie **Funktion erstellen**. Lambda erstellt eine grundlegende „Hello World“-Funktion mit der von Ihnen gewählten Laufzeit.
**So laden Sie ein ZIP-Archiv von Ihrem lokalen Computer hoch (Konsole)**
1. Wählen Sie auf der [Funktionsseite](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole die Funktion aus, für die Sie die ZIP-Datei hochladen möchten.
1. Wählen Sie die Registerkarte **Code** aus.
1. Wählen Sie im Bereich **Codequelle** die Option **Hochladen von** aus.
1. Wählen Sie die **ZIP-Datei** aus.
1. Laden Sie die ZIP-Datei wie folgt hoch:
1. Wählen Sie **Hochladen** und dann Ihre ZIP-Datei in der Dateiauswahl aus.
1. Klicken Sie auf **Open**.
1. Wählen Sie **Speichern**.
**So laden Sie ein ZIP-Archiv aus einem Amazon-S3-Bucket hoch (Konsole)**
1. Wählen Sie auf der [Funktionsseite](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole die Funktion aus, für die Sie eine neue ZIP-Datei hochladen möchten.
1. Wählen Sie die Registerkarte **Code** aus.
1. Wählen Sie im Bereich **Codequelle** die Option **Hochladen von** aus.
1. Wählen Sie den **Amazon-S3-Speicherort** aus.
1. Fügen Sie die Amazon-S3-Link-URL Ihrer ZIP-Datei ein und wählen Sie **Speichern** aus.
### Erstellen und Aktualisieren von Funktionen mit ZIP-Dateien mithilfe der AWS CLI
Sie können die [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) verwenden, um eine neue Funktion zu erstellen oder eine vorhandene unter Verwendung einer ZIP-Datei zu aktualisieren. Verwenden Sie die [Erstellungsfunktion und](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) die [update-function-code](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html)Befehle, um Ihr .zip-Paket bereitzustellen. Wenn Ihre ZIP-Datei kleiner als 50 MB ist, können Sie das ZIP-Paket von einem Dateispeicherort auf Ihrem lokalen Build-Computer hochladen. Bei größeren Dateien müssen Sie Ihr ZIP-Paket aus einem Amazon-S3-Bucket hochladen. Anweisungen zum Hochladen einer Datei in einen Amazon S3 S3-Bucket mithilfe von finden Sie unter [Objekte verschieben](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) im *AWS CLI Benutzerhandbuch*. AWS CLI
**Anmerkung**
Wenn Sie Ihre ZIP-Datei mithilfe von aus einem Amazon S3 S3-Bucket hochladen AWS CLI, muss sich der Bucket im selben Verzeichnis befinden AWS-Region wie Ihre Funktion.
Um eine neue Funktion mithilfe einer .zip-Datei mit dem zu erstellen AWS CLI, müssen Sie Folgendes angeben:
+ Den Namen Ihrer Funktion (`--function-name`)
+ Die Laufzeit Ihrer Funktion (`--runtime`)
+ Den Amazon-Ressourcennamen (ARN) der [Ausführungsrolle](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) der Funktion (`--role`).
+ Den Namen der Handler-Methode in Ihrem Funktionscode (`--handler`)
Sie müssen auch den Speicherort Ihrer ZIP-Datei angeben. Befindet sich Ihre ZIP-Datei in einem Ordner auf Ihrem lokalen Build-Computer, verwenden Sie die `--zip-file`-Option, um den Dateipfad anzugeben, wie im folgenden Beispielbefehl gezeigt.
```
aws lambda create-function --function-name myFunction \
--runtime provided.al2023 --handler bootstrap \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--zip-file fileb://myFunction.zip
```
Zur Angabe des Speicherorts der ZIP-Datei in einem Amazon-S3-Bucket verwenden Sie die im folgenden Beispielbefehl gezeigte `--code`-Option. Sie müssen den `S3ObjectVersion`-Parameter nur für versionierte Objekte verwenden.
```
aws lambda create-function --function-name myFunction \
--runtime provided.al2023 --handler bootstrap \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion
```
Um eine vorhandene Funktion mit der CLI zu aktualisieren, geben Sie den Namen Ihrer Funktion unter Verwendung des `--function-name`-Parameters an. Sie müssen auch den Speicherort der ZIP-Datei angeben, die Sie zum Aktualisieren Ihres Funktionscodes verwenden möchten. Befindet sich Ihre ZIP-Datei in einem Ordner auf Ihrem lokalen Build-Computer, verwenden Sie die `--zip-file`-Option, um den Dateipfad anzugeben, wie im folgenden Beispielbefehl gezeigt.
```
aws lambda update-function-code --function-name myFunction \
--zip-file fileb://myFunction.zip
```
Zur Angabe des Speicherorts der ZIP-Datei in einem Amazon-S3-Bucket verwenden Sie die im folgenden Beispielbefehl gezeigten `--s3-bucket`- und `--s3-key`-Optionen. Sie müssen den `--s3-object-version`-Parameter nur für versionierte Objekte verwenden.
```
aws lambda update-function-code --function-name myFunction \
--s3-bucket amzn-s3-demo-bucket --s3-key myFileName.zip --s3-object-version myObject Version
```
### Erstellen und Aktualisieren von Funktionen mit ZIP-Dateien unter Verwendung der Lambda-API
Um Funktionen zu erstellen und zu konfigurieren, die ein ZIP-Dateiarchiv verwenden, verwenden Sie die folgenden API-Operationen:
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)
### Funktionen mit ZIP-Dateien erstellen und aktualisieren mit AWS SAM
Das AWS Serverless Application Model (AWS SAM) ist ein Toolkit, das dabei hilft, den Prozess der Erstellung und Ausführung serverloser Anwendungen zu optimieren. AWS Sie definieren die Ressourcen für Ihre Anwendung in einer YAML- oder JSON-Vorlage und verwenden die AWS SAM Befehlszeilenschnittstelle (AWS SAM CLI), um Ihre Anwendungen zu erstellen, zu verpacken und bereitzustellen. Wenn Sie eine Lambda-Funktion aus einer AWS SAM Vorlage erstellen, AWS SAM wird automatisch ein ZIP-Bereitstellungspaket oder ein Container-Image mit Ihrem Funktionscode und allen von Ihnen angegebenen Abhängigkeiten erstellt. Weitere Informationen zur Verwendung AWS SAM zum Erstellen und Bereitstellen von Lambda-Funktionen finden Sie unter [Erste Schritte mit AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) im *AWS Serverless Application Model Entwicklerhandbuch*.
Sie können es auch verwenden AWS SAM , um eine Lambda-Funktion mithilfe eines vorhandenen ZIP-Dateiarchivs zu erstellen. Um eine Lambda-Funktion zu erstellen AWS SAM, können Sie Ihre ZIP-Datei in einem Amazon S3 S3-Bucket oder in einem lokalen Ordner auf Ihrem Build-Computer speichern. Anweisungen zum Hochladen einer Datei in einen Amazon S3 S3-Bucket mithilfe von finden Sie unter [Objekte verschieben](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) im *AWS CLI Benutzerhandbuch*. AWS CLI
In Ihrer AWS SAM Vorlage spezifiziert die `AWS::Serverless::Function` Ressource Ihre Lambda-Funktion. Legen Sie in dieser Ressource die folgenden Eigenschaften fest, um eine Funktion zu erstellen, die als ZIP-Datei-Archiv definiert ist:
+ `PackageType` – festlegen auf `Zip`
+ `CodeUri`- auf die Amazon S3 S3-URI, den Pfad zum lokalen Ordner oder [FunctionCode](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html)Objekt des Funktionscodes gesetzt
+ `Runtime` – festlegen auf die gewünschte Laufzeit
Wenn Ihre ZIP-Datei größer als 50 MB ist, müssen Sie sie nicht zuerst in einen Amazon S3 S3-Bucket hochladen. AWS SAM AWS SAM kann .zip-Pakete bis zur maximal zulässigen Größe von 250 MB (entpackt) von einem Speicherort auf Ihrem lokalen Build-Computer hochladen.
*Weitere Informationen zum Bereitstellen von Funktionen mithilfe der ZIP-Datei in finden Sie [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)im AWS SAM Entwicklerhandbuch.AWS SAM *
**Beispiel: Wird verwendet AWS SAM , um eine Go-Funktion mit der bereitgestellten.al2023 zu erstellen**
1. Erstellen Sie eine AWS SAM Vorlage mit den folgenden Eigenschaften:
+ **BuildMethod**: Gibt den Compiler für Ihre Anwendung an. Verwenden Sie `go1.x`.
+ **Runtime**: Verwenden Sie `provided.al2023`.
+ **CodeUri**: Geben Sie den Pfad zu Ihrem Code ein.
+ **Architectures**: Verwenden Sie `[arm64]` für die arm64-Architektur. Verwenden Sie für die x86\$164-Befehlssatzarchitektur die Option `[amd64]` oder entfernen Sie die Eigenschaft `Architectures`.
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: 'AWS::Serverless-2016-10-31'
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: go1.x
Properties:
CodeUri: hello-world/ # folder where your main program resides
Handler: bootstrap
Runtime: provided.al2023
Architectures: [arm64]
```
1. Verwenden Sie den Befehl [sam build](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-build.html), um die ausführbare Datei zu kompilieren.
```
sam build
```
1. Verwenden Sie den Befehl [sam deploy](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html), um die Funktion in Lambda bereitzustellen.
```
sam deploy --guided
```
### Funktionen mit ZIP-Dateien erstellen und aktualisieren mit CloudFormation
Sie können verwenden CloudFormation , um eine Lambda-Funktion mithilfe eines ZIP-Dateiarchivs zu erstellen. Um eine Lambda-Funktion aus einer ZIP-Datei zu erstellen, müssen Sie Ihre Datei zunächst in einen Amazon-S3-Bucket hochladen. Anweisungen zum Hochladen einer Datei in einen Amazon S3 S3-Bucket mithilfe von finden Sie unter [Objekte verschieben](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) im *AWS CLI Benutzerhandbuch. AWS CLI*
In Ihrer CloudFormation Vorlage spezifiziert die `AWS::Lambda::Function` Ressource Ihre Lambda-Funktion. Legen Sie in dieser Ressource die folgenden Eigenschaften fest, um eine Funktion zu erstellen, die als ZIP-Datei-Archiv definiert ist:
+ `PackageType` – festlegen auf `Zip`
+ `Code` – Geben Sie den Namen des Amazon-S3-Buckets und den ZIP-Dateinamen in die Felder `S3Bucket` und `S3Key` ein
+ `Runtime` – festlegen auf die gewünschte Laufzeit
Die CloudFormation generierte ZIP-Datei darf 4 MB nicht überschreiten. *Weitere Informationen zum Bereitstellen von Funktionen mithilfe der ZIP-Datei finden Sie [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)im CloudFormation Benutzerhandbuch. CloudFormation*
# Bereitstellen von Go-Lambda-Funktionen mit Container-Images
Es gibt zwei Möglichkeiten, ein Container-Image für eine Go-Lambda-Funktion zu erstellen:
+ [Verwenden eines AWS reinen Betriebssystem-Basisimages](#go-image-provided)
Go wird anders implementiert als andere verwaltete Laufzeiten. Da Go nativ zu einer ausführbaren Binärdatei kompiliert wird, ist keine spezielle Sprachlaufzeit erforderlich. Verwenden Sie ein [Basis-Image nur für das Betriebssystem](images-create.md#runtimes-images-provided), um Go-Images für Lambda zu erstellen. Um das Image mit Lambda kompatibel zu machen, müssen Sie das `aws-lambda-go/lambda`-Paket in das Image aufnehmen.
+ [Verwenden Sie ein Nicht-Basis-Image AWS](#go-image-other)
Sie können auch ein alternatives Basis-Image aus einer anderen Container-Registry verwenden. Sie können auch ein von Ihrer Organisation erstelltes benutzerdefiniertes Image verwenden. Um das Image mit Lambda kompatibel zu machen, müssen Sie das `aws-lambda-go/lambda`-Paket in das Image aufnehmen.
**Tipp**
Um die Zeit zu reduzieren, die benötigt wird, bis Lambda-Container-Funktionen aktiv werden, siehe die Docker-Dokumentation unter [Verwenden mehrstufiger Builds](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds). Um effiziente Container-Images zu erstellen, folgen Sie den [Bewährte Methoden für das Schreiben von Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
Auf dieser Seite wird erklärt, wie Sie Container-Images für Lambda erstellen, testen und bereitstellen.
## AWS Basis-Images für die Bereitstellung von Go-Funktionen
Go wird anders implementiert als andere verwaltete Laufzeiten. Da Go nativ zu einer ausführbaren Binärdatei kompiliert wird, ist keine spezielle Sprachlaufzeit erforderlich. Verwenden Sie ein [reines Betriebssystem-Basisimage](images-create.md#runtimes-images-provided), um Go-Funktionen für Lambda bereitzustellen.
| Name | ID | Betriebssystem | Datum der Veraltung | Blockfunktion erstellen | Blockfunktion aktualisieren |
| --- | --- | --- | --- | --- | --- |
| Reine OS-Laufzeit | `provided.al2023` | Amazon Linux 2023 | 30. Juni 2029 | 31. Juli 2029 | 31. August 2029 |
| Reine OS-Laufzeit | `provided.al2` | Amazon Linux 2 | 31. Juli 2026 | 31. August 2026 | 30. September 2026 |
Öffentliche Galerie von Amazon Elastic Container Registry: [gallery.ecr. aws/lambda/provided](https://gallery.ecr.aws/lambda/provided)
## Laufzeitschnittstellen-Clients von Go
Das `aws-lambda-go/lambda`-Paket enthält eine Implementierung der Laufzeitschnittstelle. Beispiele für die Verwendung von `aws-lambda-go/lambda` in Ihrem Image finden Sie unter [Verwenden eines AWS reinen Betriebssystem-Basisimages](#go-image-provided) oder [Verwenden Sie ein Nicht-Basis-Image AWS](#go-image-other).
## Verwenden eines AWS reinen Betriebssystem-Basisimages
Go wird anders implementiert als andere verwaltete Laufzeiten. Da Go nativ zu einer ausführbaren Binärdatei kompiliert wird, ist keine spezielle Sprachlaufzeit erforderlich. Verwenden Sie ein [reines Betriebssystem-Basis-Image](images-create.md#runtimes-images-provided), um Container-Images für Go-Funktionen zu erstellen.
| Tags (Markierungen) | Laufzeit | Betriebssystem | Dockerfile | Ablehnung |
| --- | --- | --- | --- | --- |
| al2023 | Reine OS-Laufzeit | Amazon Linux 2023 | [Dockerfile für reine Betriebssystem-Runtime aktiviert GitHub](https://github.com/aws/aws-lambda-base-images/blob/provided.al2023/Dockerfile.provided.al2023) | 30. Juni 2029 |
| al2 | Reine OS-Laufzeit | Amazon Linux 2 | [Dockerfile nur für Betriebssystem, Runtime aktiviert GitHub](https://github.com/aws/aws-lambda-base-images/blob/provided.al2/Dockerfile.provided.al2) | 31. Juli 2026 |
Weitere Informationen zu diesen Basis-Images finden Sie in der öffentlichen Amazon-ECR-Galerie unter [provided](https://gallery.ecr.aws/lambda/provided).
Sie müssen das [aws-lambda-go/lambda-Paket in Ihren Go-Handler](https://github.com/aws/aws-lambda-go) aufnehmen. Dieses Paket implementiert das Programmiermodell für Go, einschließlich der Laufzeitschnittstelle.
### Voraussetzungen
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (Mindestversion 25.0.0)
+ Das Docker-[buildx-Plugin](https://github.com/docker/buildx/blob/master/README.md).
+ Go
### Erstellen eines Images aus dem Basis-Image „provided.al2023“
**So erstellen und implementieren Sie eine Go-Funktion mit dem `provided.al2023`-Basis-Image.**
1. Erstellen Sie ein Verzeichnis für das Projekt und wechseln Sie dann zu diesem Verzeichnis.
```
mkdir hello
cd hello
```
1. Initialisieren Sie ein neues Go-Modul.
```
go mod init example.com/hello-world
```
1. Fügen Sie die **Lambda-Bibliothek** als Abhängigkeit Ihres neuen Moduls hinzu.
```
go get github.com/aws/aws-lambda-go/lambda
```
1. Erstellen Sie eine Datei namens `main.go` und öffnen Sie diese dann in einem Text-Editor. Dies ist der Code für die Lambda-Funktion. Sie können den folgenden Beispielcode zum Testen verwenden oder ihn durch Ihren eigenen ersetzen.
```
package main
import (
"context"
"github.com/aws/aws-lambda-go/events"
"github.com/aws/aws-lambda-go/lambda"
)
func handler(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
response := events.APIGatewayProxyResponse{
StatusCode: 200,
Body: "\"Hello from Lambda!\"",
}
return response, nil
}
func main() {
lambda.Start(handler)
}
```
1. Verwenden Sie einen Texteditor, um ein Dockerfile in Ihrem Projektverzeichnis zu erstellen.
+ Die folgende Beispiel-Docker-Datei verwendet eine [mehrstufige Entwicklung](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds). Dadurch können Sie in jedem Schritt ein anderes Basis-Image verwenden. Sie können ein Image verwenden, z. B. ein [Go-Basis-Image](https://hub.docker.com/_/golang), um Ihren Code zu kompilieren und die ausführbare Binärdatei zu erstellen. Sie können dann ein anderes Image verwenden, z. B. `provided.al2023` in der `FROM`-Abschlusserklärung, um das Image zu definieren, das Sie für Lambda bereitstellen. Der Build-Prozess ist vom endgültigen Bereitstellungs-Image getrennt, so dass das endgültige Image nur die Dateien enthält, die zum Ausführen der Anwendung benötigt werden.
+ Sie können das optionale Tag `lambda.norpc` verwenden, um die RPC-Komponente (Remote Procedure Call, Remoteprozeduraufruf) der Bibliothek [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda) auszuschließen. Die RPC-Komponente ist nur erforderlich, wenn Sie die veraltete Go 1.x-Laufzeit verwenden. Durch Ausschließen der RPC-Komponente verringert sich die Größe des Bereitstellungspakets.
+ Beachten Sie, dass das Dockerfile-Beispiel keine [USER-Anweisung](https://docs.docker.com/reference/dockerfile/#user) enthält. Wenn Sie ein Container-Image für Lambda bereitstellen, definiert Lambda automatisch einen Standard-Linux-Benutzer mit Berechtigungen mit geringsten Rechten. Dies unterscheidet sich vom Standardverhalten von Docker, bei dem standardmäßig der `root`-Benutzer verwendet wird, wenn keine `USER`-Anweisung bereitgestellt wird.
**Example – Mehrstufige Docker-Datei**
**Anmerkung**
Stellen Sie sicher, dass die Version von Go, die Sie in der Docker-Datei angeben (z. B. `golang:1.20`), dieselbe Version von Go ist, mit der Sie Ihre Anwendung erstellt haben.
```
FROM golang:1.20 as build
WORKDIR /helloworld
# Copy dependencies list
COPY go.mod go.sum ./
# Build with optional lambda.norpc tag
COPY main.go .
RUN go build -tags lambda.norpc -o main main.go
# Copy artifacts to a clean image
FROM public.ecr.aws/lambda/provided:al2023
COPY --from=build /helloworld/main ./main
ENTRYPOINT [ "./main" ]
```
1. Erstellen Sie Ihr Docker-Image mit dem [docker build](https://docs.docker.com/engine/reference/commandline/build/)-Befehl. Das folgende Beispiel benennt das Bild in `docker-image` und gibt ihm den `test` [Tag](https://docs.docker.com/engine/reference/commandline/build/#tag). Um Ihr Image mit Lambda kompatibel zu machen, müssen Sie die Option `--provenance=false` verwenden.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**Anmerkung**
Der Befehl gibt die `--platform linux/amd64`-Option an, um sicherzustellen, dass Ihr Container mit der Lambda-Ausführungsumgebung kompatibel ist, unabhängig von der Architektur des Entwicklungsrechners. Wenn Sie beabsichtigen, eine Lambda-Funktion mithilfe der ARM64 Befehlssatzarchitektur zu erstellen, müssen Sie den Befehl so ändern, dass er stattdessen die `--platform linux/arm64` Option verwendet.
### (Optional) Testen Sie das Image lokal
Verwenden Sie den [Laufzeit-Schnittstellen-Emulator](https://github.com/aws/aws-lambda-runtime-interface-emulator/), um Ihr Image lokal zu testen. Der Laufzeit-Schnittstellen-Emulator ist im `provided.al2023`-Basis-Image enthalten.
**So führen Sie den Laufzeit-Schnittstellen-Emulator auf Ihrem lokalen Computer aus**
1. Starten Sie Ihr Docker-Image mit dem **docker run**-Befehl. Beachten Sie Folgendes:
+ `docker-image` ist der Image-Name und `test` ist das Tag.
+ `./main` ist `ENTRYPOINT` aus Ihrem Dockerfile.
```
docker run -d -p 9000:8080 \
--entrypoint /usr/local/bin/aws-lambda-rie \
docker-image:test ./main
```
Dieser Befehl führt das Image als Container aus und erstellt einen lokalen Endpunkt bei `localhost:9000/2015-03-31/functions/function/invocations`.
1. Veröffentlichen Sie in einem neuen Terminalfenster ein Ereignis mit einem **curl**-Befehl an den folgenden Endpunkt:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Für einige Funktionen ist möglicherweise eine JSON-Nutzlast erforderlich. Beispiel:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
1. Die Container-ID erhalten.
```
docker ps
```
1. Verwenden Sie den Befehl [docker kill](https://docs.docker.com/engine/reference/commandline/kill/), um den Container zu anzuhalten. Ersetzen Sie in diesem Befehl `3766c4ab331c` durch die Container-ID aus dem vorherigen Schritt.
```
docker kill 3766c4ab331c
```
### Das Image bereitstellen
**Um das Image in Amazon ECR hochzuladen und die Lambda-Funktion zu erstellen**
1. Führen Sie den [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)Befehl aus, um die Docker-CLI bei Ihrer Amazon ECR-Registrierung zu authentifizieren.
+ Setzen Sie den `--region` Wert auf den AWS-Region Ort, an dem Sie das Amazon ECR-Repository erstellen möchten.
+ Ersetzen Sie es `111122223333` durch Ihre AWS-Konto ID.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. Erstellen Sie ein Repository in Amazon ECR mithilfe des Befehls [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**Anmerkung**
Das Amazon ECR-Repository muss sich im selben Format AWS-Region wie die Lambda-Funktion befinden.
Wenn erfolgreich, sehen Sie eine Antwort wie diese:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Kopieren Sie das `repositoryUri` aus der Ausgabe im vorherigen Schritt.
1. Führen Sie den Befehl [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) aus, um Ihr lokales Image als neueste Version in Ihrem Amazon-ECR-Repository zu markieren. In diesem Befehl gilt Folgendes:
+ `docker-image:test` ist der Name und das [Tag](https://docs.docker.com/engine/reference/commandline/build/#tag) Ihres Docker-Images. Dies sind der Imagename und das Tag, die Sie im `docker build`-Befehl angegeben haben.
+ Ersetzen Sie `` durch den `repositoryUri`, den Sie kopiert haben. Stellen Sie sicher, dass Sie `:latest` am Ende der URI angeben.
```
docker tag docker-image:test :latest
```
Beispiel:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Führen Sie den Befehl [docker push](https://docs.docker.com/engine/reference/commandline/push/) aus, um Ihr lokales Image im Amazon-ECR-Repository bereitzustellen. Stellen Sie sicher, dass Sie `:latest` am Ende der Repository-URI angeben.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Erstellen Sie eine Ausführungsrolle](lambda-intro-execution-role.md#permissions-executionrole-api) für die Funktion, wenn Sie noch keine haben. Sie benötigen den Amazon-Ressourcennamen (ARN) der Rolle im nächsten Schritt.
1. So erstellen Sie die Lambda-Funktion: Geben Sie für `ImageUri` die Repository-URI von zuvor an. Stellen Sie sicher, dass Sie `:latest` am Ende der URI angeben.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**Anmerkung**
Sie können eine Funktion mit einem Bild in einem anderen AWS Konto erstellen, sofern sich das Bild in derselben Region wie die Lambda-Funktion befindet. Weitere Informationen finden Sie unter [Kontoübergreifende Berechtigungen von Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Die Funktion aufrufen.
```
aws lambda invoke --function-name hello-world response.json
```
Das Ergebnis sollte ungefähr wie folgt aussehen:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Um die Ausgabe der Funktion zu sehen, überprüfen Sie die `response.json`-Datei.
Um den Funktionscode zu aktualisieren, müssen Sie das Image erneut erstellen, das neue Image in das Amazon ECR-Repository hochladen und dann den [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Befehl verwenden, um das Image für die Lambda-Funktion bereitzustellen.
Lambda löst das Image-Tag in einen bestimmten Image-Digest auf. Das heißt, wenn Sie das Image-Tag, das zur Bereitstellung der Funktion verwendet wurde, auf ein neues Image in Amazon ECR verweisen, aktualisiert Lambda die Funktion nicht automatisch, um das neue Image zu verwenden.
Um das neue Image für dieselbe Lambda-Funktion bereitzustellen, müssen Sie den [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Befehl verwenden, auch wenn das Image-Tag in Amazon ECR gleich bleibt. Im folgenden Beispiel erstellt die `--publish`-Option eine neue Version der Funktion unter Verwendung des aktualisierten Container-Images.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
## Verwenden Sie ein Nicht-Basis-Image AWS
Sie können ein Container-Image für Go aus einem AWS Nicht-Base-Image erstellen. Das Beispiel-Dockerfile in den folgenden Schritten verwendet ein [Alpine-Basis-Image](https://hub.docker.com/_/golang/).
Sie müssen das [aws-lambda-go/lambda-Paket](https://github.com/aws/aws-lambda-go) in Ihren Go-Handler aufnehmen. Dieses Paket implementiert das Programmiermodell für Go, einschließlich der Laufzeitschnittstelle.
### Voraussetzungen
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (Mindestversion 25.0.0)
+ Das Docker-[buildx-Plugin](https://github.com/docker/buildx/blob/master/README.md).
+ Go
### Erstellen eines Images aus einem alternativen Basis-Image
**Erstellen und Bereitstellen einer Go-Funktion mit einem Alpine-Basis-Image**
1. Erstellen Sie ein Verzeichnis für das Projekt und wechseln Sie dann zu diesem Verzeichnis.
```
mkdir hello
cd hello
```
1. Initialisieren Sie ein neues Go-Modul.
```
go mod init example.com/hello-world
```
1. Fügen Sie die **Lambda-Bibliothek** als Abhängigkeit Ihres neuen Moduls hinzu.
```
go get github.com/aws/aws-lambda-go/lambda
```
1. Erstellen Sie eine Datei namens `main.go` und öffnen Sie diese dann in einem Text-Editor. Dies ist der Code für die Lambda-Funktion. Sie können den folgenden Beispielcode zum Testen verwenden oder ihn durch Ihren eigenen ersetzen.
```
package main
import (
"context"
"github.com/aws/aws-lambda-go/events"
"github.com/aws/aws-lambda-go/lambda"
)
func handler(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
response := events.APIGatewayProxyResponse{
StatusCode: 200,
Body: "\"Hello from Lambda!\"",
}
return response, nil
}
func main() {
lambda.Start(handler)
}
```
1. Verwenden Sie einen Texteditor, um ein Dockerfile in Ihrem Projektverzeichnis zu erstellen. Das folgende Beispiel-Dockerfile verwendet ein [Alpine-Basis-Image](https://hub.docker.com/_/golang/). Beachten Sie, dass das Dockerfile-Beispiel keine [USER-Anweisung](https://docs.docker.com/reference/dockerfile/#user) enthält. Wenn Sie ein Container-Image für Lambda bereitstellen, definiert Lambda automatisch einen Standard-Linux-Benutzer mit Berechtigungen mit geringsten Rechten. Dies unterscheidet sich vom Standardverhalten von Docker, bei dem standardmäßig der `root`-Benutzer verwendet wird, wenn keine `USER`-Anweisung bereitgestellt wird.
**Example Dockerfile**
**Anmerkung**
Stellen Sie sicher, dass die Version von Go, die Sie in der Docker-Datei angeben (z. B. `golang:1.20`), dieselbe Version von Go ist, mit der Sie Ihre Anwendung erstellt haben.
```
FROM golang:1.20.2-alpine3.16 as build
WORKDIR /helloworld
# Copy dependencies list
COPY go.mod go.sum ./
# Build
COPY main.go .
RUN go build -o main main.go
# Copy artifacts to a clean image
FROM alpine:3.16
COPY --from=build /helloworld/main /main
ENTRYPOINT [ "/main" ]
```
1. Erstellen Sie Ihr Docker-Image mit dem [docker build](https://docs.docker.com/engine/reference/commandline/build/)-Befehl. Das folgende Beispiel benennt das Bild in `docker-image` und gibt ihm den `test` [Tag](https://docs.docker.com/engine/reference/commandline/build/#tag). Um Ihr Image mit Lambda kompatibel zu machen, müssen Sie die Option `--provenance=false` verwenden.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**Anmerkung**
Der Befehl gibt die `--platform linux/amd64`-Option an, um sicherzustellen, dass Ihr Container mit der Lambda-Ausführungsumgebung kompatibel ist, unabhängig von der Architektur des Entwicklungsrechners. Wenn Sie beabsichtigen, eine Lambda-Funktion mithilfe der ARM64 Befehlssatzarchitektur zu erstellen, müssen Sie den Befehl so ändern, dass er stattdessen die `--platform linux/arm64` Option verwendet.
### (Optional) Testen Sie das Image lokal
Verwenden Sie den [Laufzeit-Schnittstellen-Emulator](https://github.com/aws/aws-lambda-runtime-interface-emulator/), um das Image lokal zu testen. Sie können [den Emulator in Ihr Image integrieren](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image) oder ihn mit dem folgenden Verfahren auf Ihrem lokalen Computer installieren.
**Installieren des Laufzeitschnittstellen-Emulators auf Ihrem lokalen Computer**
1. Führen Sie in Ihrem Projektverzeichnis den folgenden Befehl aus, um den Runtime-Interface-Emulator (x86-64-Architektur) herunterzuladen GitHub und auf Ihrem lokalen Computer zu installieren.
------
#### [ Linux/macOS ]
```
mkdir -p ~/.aws-lambda-rie && \
curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
chmod +x ~/.aws-lambda-rie/aws-lambda-rie
```
Um den arm64-Emulator zu installieren, ersetzen Sie die GitHub Repository-URL im vorherigen Befehl durch Folgendes:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
#### [ PowerShell ]
```
$dirPath = "$HOME\.aws-lambda-rie"
if (-not (Test-Path $dirPath)) {
New-Item -Path $dirPath -ItemType Directory
}
$downloadLink = "https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie"
$destinationPath = "$HOME\.aws-lambda-rie\aws-lambda-rie"
Invoke-WebRequest -Uri $downloadLink -OutFile $destinationPath
```
Um den arm64-Emulator zu installieren, ersetzen Sie das `$downloadLink` durch Folgendes:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
1. Starten Sie Ihr Docker-Image mit dem **docker run**-Befehl. Beachten Sie Folgendes:
+ `docker-image` ist der Image-Name und `test` ist das Tag.
+ `/main` ist `ENTRYPOINT` aus Ihrem Dockerfile.
------
#### [ Linux/macOS ]
```
docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
--entrypoint /aws-lambda/aws-lambda-rie \
docker-image:test \
/main
```
------
#### [ PowerShell ]
```
docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
--entrypoint /aws-lambda/aws-lambda-rie `
docker-image:test `
/main
```
------
Dieser Befehl führt das Image als Container aus und erstellt einen lokalen Endpunkt bei `localhost:9000/2015-03-31/functions/function/invocations`.
**Anmerkung**
Wenn Sie das Docker-Image für die ARM64 Befehlssatzarchitektur erstellt haben, stellen Sie sicher, dass Sie die `--platform linux/arm64` Option anstelle von verwenden. `--platform linux/amd64`
1. Veröffentlichen Sie ein Ereignis auf dem lokalen Endpunkt.
------
#### [ Linux/macOS ]
Führen Sie unter Linux oder macOS den folgenden `curl`-Befehl aus:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Wenn Sie Ihren eigenen Funktionscode anstelle des Beispielfunktionscodes verwenden, wird empfohlen, die Funktion mit einer JSON-Nutzlast aufzurufen. Beispiel:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
Führen Sie in PowerShell den folgenden `Invoke-WebRequest` Befehl aus:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Wenn Sie Ihren eigenen Funktionscode anstelle des Beispielfunktionscodes verwenden, wird empfohlen, die Funktion mit einer JSON-Nutzlast aufzurufen. Beispiel:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Die Container-ID erhalten.
```
docker ps
```
1. Verwenden Sie den Befehl [docker kill](https://docs.docker.com/engine/reference/commandline/kill/), um den Container zu anzuhalten. Ersetzen Sie in diesem Befehl `3766c4ab331c` durch die Container-ID aus dem vorherigen Schritt.
```
docker kill 3766c4ab331c
```
### Das Image bereitstellen
**Um das Image in Amazon ECR hochzuladen und die Lambda-Funktion zu erstellen**
1. Führen Sie den [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)Befehl aus, um die Docker-CLI bei Ihrer Amazon ECR-Registrierung zu authentifizieren.
+ Setzen Sie den `--region` Wert auf den AWS-Region Ort, an dem Sie das Amazon ECR-Repository erstellen möchten.
+ Ersetzen Sie es `111122223333` durch Ihre AWS-Konto ID.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. Erstellen Sie ein Repository in Amazon ECR mithilfe des Befehls [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**Anmerkung**
Das Amazon ECR-Repository muss sich im selben Format AWS-Region wie die Lambda-Funktion befinden.
Wenn erfolgreich, sehen Sie eine Antwort wie diese:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Kopieren Sie das `repositoryUri` aus der Ausgabe im vorherigen Schritt.
1. Führen Sie den Befehl [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) aus, um Ihr lokales Image als neueste Version in Ihrem Amazon-ECR-Repository zu markieren. In diesem Befehl gilt Folgendes:
+ `docker-image:test` ist der Name und das [Tag](https://docs.docker.com/engine/reference/commandline/build/#tag) Ihres Docker-Images. Dies sind der Imagename und das Tag, die Sie im `docker build`-Befehl angegeben haben.
+ Ersetzen Sie `` durch den `repositoryUri`, den Sie kopiert haben. Stellen Sie sicher, dass Sie `:latest` am Ende der URI angeben.
```
docker tag docker-image:test :latest
```
Beispiel:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Führen Sie den Befehl [docker push](https://docs.docker.com/engine/reference/commandline/push/) aus, um Ihr lokales Image im Amazon-ECR-Repository bereitzustellen. Stellen Sie sicher, dass Sie `:latest` am Ende der Repository-URI angeben.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Erstellen Sie eine Ausführungsrolle](lambda-intro-execution-role.md#permissions-executionrole-api) für die Funktion, wenn Sie noch keine haben. Sie benötigen den Amazon-Ressourcennamen (ARN) der Rolle im nächsten Schritt.
1. So erstellen Sie die Lambda-Funktion: Geben Sie für `ImageUri` die Repository-URI von zuvor an. Stellen Sie sicher, dass Sie `:latest` am Ende der URI angeben.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**Anmerkung**
Sie können eine Funktion mit einem Bild in einem anderen AWS Konto erstellen, sofern sich das Bild in derselben Region wie die Lambda-Funktion befindet. Weitere Informationen finden Sie unter [Kontoübergreifende Berechtigungen von Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Die Funktion aufrufen.
```
aws lambda invoke --function-name hello-world response.json
```
Das Ergebnis sollte ungefähr wie folgt aussehen:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Um die Ausgabe der Funktion zu sehen, überprüfen Sie die `response.json`-Datei.
Um den Funktionscode zu aktualisieren, müssen Sie das Image erneut erstellen, das neue Image in das Amazon ECR-Repository hochladen und dann den [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Befehl verwenden, um das Image für die Lambda-Funktion bereitzustellen.
Lambda löst das Image-Tag in einen bestimmten Image-Digest auf. Das heißt, wenn Sie das Image-Tag, das zur Bereitstellung der Funktion verwendet wurde, auf ein neues Image in Amazon ECR verweisen, aktualisiert Lambda die Funktion nicht automatisch, um das neue Image zu verwenden.
Um das neue Image für dieselbe Lambda-Funktion bereitzustellen, müssen Sie den [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Befehl verwenden, auch wenn das Image-Tag in Amazon ECR gleich bleibt. Im folgenden Beispiel erstellt die `--publish`-Option eine neue Version der Funktion unter Verwendung des aktualisierten Container-Images.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
# Arbeiten mit Ebenen für Go Lambda-Funktionen
Wir empfehlen nicht, [Ebenen](chapter-layers.md) zu verwenden, um Abhängigkeiten für in Go geschriebene Lambda-Funktionen zu verwalten. Dies liegt daran, dass Lambda-Funktionen in Go zu einer einzigen ausführbaren Datei kompiliert werden, die Sie Lambda bei der Bereitstellung Ihrer Funktion zur Verfügung stellen. Diese ausführbare Datei enthält Ihren kompilierten Funktionscode zusammen mit all seinen Abhängigkeiten. Die Verwendung von Ebenen verkompliziert nicht nur diesen Vorgang, sondern führt auch zu längeren Kaltstartzeiten, da Ihre Funktionen während der Init-Phase zusätzliche Assemblys manuell in den Speicher laden müssen.
Um externe Abhängigkeiten mit Ihren Go-Handlern zu verwenden, nehmen Sie sie direkt in Ihr Bereitstellungspaket auf. Auf diese Weise vereinfachen Sie den Bereitstellungsprozess und nutzen auch die Vorteile der integrierten Go-Compiler-Optimierungen. Ein Beispiel dafür, wie Sie eine Abhängigkeit wie das AWS SDK for Go in Ihrer Funktion importieren und verwenden, finden Sie unter [Definieren des Lambda-Funktions-Handlers in Go](golang-handler.md).
# Go-Lambda-Funktionen protokollieren und überwachen
AWS Lambda überwacht automatisch Lambda-Funktionen in Ihrem Namen und sendet Protokolle an Amazon CloudWatch. Ihre Lambda-Funktion enthält eine CloudWatch Logs-Log-Gruppe und einen Log-Stream für jede Instanz Ihrer Funktion. Die Lambda-Laufzeitumgebung sendet Details zu den einzelnen Aufrufen an den Protokollstream und leitet Protokolle und andere Ausgaben aus dem Code Ihrer Funktion weiter. Weitere Informationen finden Sie unter [Senden von Lambda-Funktionsprotokollen an CloudWatch Logs](monitoring-cloudwatchlogs.md).
Auf dieser Seite wird beschrieben, wie Sie eine Protokollausgabe aus dem Code Ihrer Lambda-Funktion erstellen und mithilfe der AWS Command Line Interface Lambda-Konsole oder der CloudWatch Konsole auf Logs zugreifen.
**Topics**
+ [Erstellen einer Funktion, die Protokolle zurückgibt](#golang-logging-output)
+ [Anzeigen von Protokollen in der Lambda-Konsole](#golang-logging-console)
+ [Protokolle in der Konsole anzeigen CloudWatch](#golang-logging-cwconsole)
+ [Logs mit dem Befehl () anzeigen AWS Command Line Interface AWS CLI](#golang-logging-cli)
+ [Löschen von Protokollen](#golang-logging-delete)
## Erstellen einer Funktion, die Protokolle zurückgibt
Um Protokolle aus dem Code Ihrer Funktion auszugeben, können Sie Methoden für [das Fmt-Paket](https://golang.org/pkg/fmt/) verwenden oder eine Protokollierungsbibliothek, die zu `stdout` oder `stderr` schreibt. Im folgenden Beispiel wird [das Protokollpaket](https://golang.org/pkg/log/) verwendet.
**Example [main.go](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-go/function/main.go) – Protokollierung**
```
func handleRequest(ctx context.Context, event events.SQSEvent) (string, error) {
// event
eventJson, _ := json.MarshalIndent(event, "", " ")
log.Printf("EVENT: %s", eventJson)
// environment variables
log.Printf("REGION: %s", os.Getenv("AWS_REGION"))
log.Println("ALL ENV VARS:")
for _, element := range os.Environ() {
log.Println(element)
}
```
**Example Protokollformat**
```
START RequestId: dbda340c-xmpl-4031-8810-11bb609b4c71 Version: $LATEST
2020/03/27 03:40:05 EVENT: {
"Records": [
{
"messageId": "19dd0b57-b21e-4ac1-bd88-01bbb068cb78",
"receiptHandle": "MessageReceiptHandle",
"body": "Hello from SQS!",
"md5OfBody": "7b27xmplb47ff90a553787216d55d91d",
"md5OfMessageAttributes": "",
"attributes": {
"ApproximateFirstReceiveTimestamp": "1523232000001",
"ApproximateReceiveCount": "1",
"SenderId": "123456789012",
"SentTimestamp": "1523232000000"
},
...
2020/03/27 03:40:05 AWS_LAMBDA_LOG_STREAM_NAME=2020/03/27/[$LATEST]569cxmplc3c34c7489e6a97ad08b4419
2020/03/27 03:40:05 AWS_LAMBDA_FUNCTION_NAME=blank-go-function-9DV3XMPL6XBC
2020/03/27 03:40:05 AWS_LAMBDA_FUNCTION_MEMORY_SIZE=128
2020/03/27 03:40:05 AWS_LAMBDA_FUNCTION_VERSION=$LATEST
2020/03/27 03:40:05 AWS_EXECUTION_ENV=AWS_Lambda_go1.x
END RequestId: dbda340c-xmpl-4031-8810-11bb609b4c71
REPORT RequestId: dbda340c-xmpl-4031-8810-11bb609b4c71 Duration: 38.66 ms Billed Duration: 243 ms Memory Size: 128 MB Max Memory Used: 54 MB Init Duration: 203.69 ms
XRAY TraceId: 1-5e7d7595-212fxmpl9ee07c4884191322 SegmentId: 42ffxmpl0645f474 Sampled: true
```
Die Go-Laufzeit protokolliert die Zeilen `START`, `END` und `REPORT` für jeden Aufruf. Die Berichtszeile enthält die folgenden Details.
**Datenfelder für REPORT-Zeilen**
+ **RequestId**— Die eindeutige Anforderungs-ID für den Aufruf.
+ **Dauer** – Die Zeit, die die Handler-Methode Ihrer Funktion mit der Verarbeitung des Ereignisses verbracht hat.
+ **Fakturierte Dauer** – Die für den Aufruf fakturierte Zeit.
+ **Speichergröße** – Die der Funktion zugewiesene Speichermenge.
+ **Max. verwendeter Speicher** – Die Speichermenge, die von der Funktion verwendet wird. Wenn Aufrufe eine Ausführungsumgebung gemeinsam nutzen, meldet Lambda den maximalen Speicherverbrauch für alle Aufrufe. Dieses Verhalten kann zu einem höheren als erwarteten gemeldeten Wert führen.
+ **Initialisierungsdauer** – Für die erste Anfrage die Zeit, die zur Laufzeit zum Laden der Funktion und Ausführen von Code außerhalb der Handler-Methode benötigt wurde.
+ **XRAY TraceId** [— Für verfolgte Anfragen die AWS X-Ray Trace-ID.](services-xray.md)
+ **SegmentId**— Für verfolgte Anfragen die X-Ray-Segment-ID.
+ **Stichprobe** – Bei verfolgten Anforderungen das Stichprobenergebnis.
## Anzeigen von Protokollen in der Lambda-Konsole
Sie können die Lambda-Konsole verwenden, um die Protokollausgabe nach dem Aufrufen einer Lambda-Funktion anzuzeigen.
Wenn Ihr Code über den eingebetteten **Code**-Editor getestet werden kann, finden Sie Protokolle in den **Ausführungsergebnissen**. Wenn Sie das Feature Konsolentest verwenden, um eine Funktion aufzurufen, finden Sie die **Protokollausgabe** im Abschnitt **Details**.
## Protokolle in der Konsole anzeigen CloudWatch
Sie können die CloudWatch Amazon-Konsole verwenden, um Protokolle für alle Lambda-Funktionsaufrufe anzuzeigen.
**Um Protokolle auf der Konsole anzuzeigen CloudWatch**
1. Öffnen Sie die [Seite Protokollgruppen](https://console.aws.amazon.com/cloudwatch/home?#logs:) auf der CloudWatch Konsole.
1. Wählen Sie die Protokollgruppe für Ihre Funktion (***your-function-name*/aws/lambda/**).
1. Wählen Sie eine Protokollstream aus.
Jeder Protokoll-Stream entspricht einer [Instance Ihrer Funktion](lambda-runtime-environment.md). Ein Protokollstream wird angezeigt, wenn Sie Ihre Lambda-Funktion aktualisieren und wenn zusätzliche Instanzen für gleichzeitige Aufrufe erstellt werden. Um Protokolle für einen bestimmten Aufruf zu finden, empfehlen wir, Ihre Funktion mit zu instrumentieren. AWS X-Ray X-Ray erfasst Details zu der Anforderung und dem Protokollstream in der Trace.
## Logs mit dem Befehl () anzeigen AWS Command Line Interface AWS CLI
Das AWS CLI ist ein Open-Source-Tool, mit dem Sie mithilfe von Befehlen in Ihrer Befehlszeilen-Shell mit AWS Diensten interagieren können. Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
Sie können die [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) verwenden, um Protokolle für einen Aufruf mit der `--log-type`-Befehlsoption abzurufen. Die Antwort enthält das Feld `LogResult`, das bis zu 4 KB base64-verschlüsselte Protokolle aus dem Aufruf enthält.
**Example eine Log-ID abrufen**
Das folgende Beispiel zeigt, wie eine *Protokoll-ID* aus dem `LogResult`-Feld für eine Funktion namens `my-function` abgerufen wird.
```
aws lambda invoke --function-name my-function out --log-type Tail
```
Die Ausgabe sollte folgendermaßen aussehen:
```
{
"StatusCode": 200,
"LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}
```
**Example entschlüsseln der Protokolle**
Verwenden Sie in derselben Eingabeaufforderung das `base64`-Dienstprogramm, um die Protokolle zu entschlüsseln. Das folgende Beispiel zeigt, wie Base64-codierte Logs für abgerufen werde `my-function`.
```
aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode
```
Die **cli-binary-format** Option ist erforderlich, wenn Sie AWS CLI Version 2 verwenden. Um dies zur Standardeinstellung zu machen, führen Sie `aws configure set cli-binary-format raw-in-base64-out` aus. Weitere Informationen finden Sie unter [Von AWS CLI unterstützte globale Befehlszeilenoptionen](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) im *AWS Command Line Interface -Benutzerhandbuch für Version 2*.
Die Ausgabe sollte folgendermaßen aussehen:
```
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed Duration: 80 ms Memory Size: 128 MB Max Memory Used: 73 MB
```
Das `base64`-Dienstprogramm ist unter Linux, macOS und [Ubuntu auf Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10)verfügbar. macOS-Benutzer müssen möglicherweise `base64 -D` verwenden.
**Example get-logs.sh-Skript**
Verwenden Sie in derselben Eingabeaufforderung das folgende Skript, um die letzten fünf Protokollereignisse herunterzuladen. Das Skript verwendet `sed` zum Entfernen von Anführungszeichen aus der Ausgabedatei und wechselt 15 Sekunden lang in den Ruhezustand, um Zeit einzuräumen, damit Protokolle verfügbar werden können. Die Ausgabe enthält die Antwort von Lambda und die `get-log-events`Ausgabe des Befehls.
Kopieren Sie den Inhalt des folgenden Codebeispiels und speichern Sie es in Ihrem Lambda-Projektverzeichnis unter `get-logs.sh`.
Die **cli-binary-format** Option ist erforderlich, wenn Sie AWS CLI Version 2 verwenden. Um dies zur Standardeinstellung zu machen, führen Sie `aws configure set cli-binary-format raw-in-base64-out` aus. Weitere Informationen finden Sie unter [Von AWS CLI unterstützte globale Befehlszeilenoptionen](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) im *AWS Command Line Interface -Benutzerhandbuch für Version 2*.
```
#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5
```
**Example macOS und Linux (nur diese Systeme)**
In derselben Eingabeaufforderung müssen macOS- und Linux-Benutzer möglicherweise den folgenden Befehl ausführen, um sicherzustellen, dass das Skript ausführbar ist.
```
chmod -R 755 get-logs.sh
```
**Example die letzten fünf Protokollereignisse abrufen**
Führen Sie an derselben Eingabeaufforderung das folgende Skript aus, um die letzten fünf Protokollereignisse abzurufen.
```
./get-logs.sh
```
Die Ausgabe sollte folgendermaßen aussehen:
```
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
"ingestionTime": 1559763003309
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}
```
## Löschen von Protokollen
Wenn Sie eine Funktion löschen, werden Protokollgruppen nicht automatisch gelöscht. Um das unbegrenzte Speichern von Protokollen zu vermeiden, löschen Sie die Protokollgruppe oder [konfigurieren Sie eine Aufbewahrungszeitraum](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention) nach dem Protokolle automatisch gelöscht werden.
# Go-Code instrumentieren in AWS Lambda
Lambda lässt sich integrieren AWS X-Ray , um Ihnen zu helfen, Lambda-Anwendungen zu verfolgen, zu debuggen und zu optimieren. Sie können mit X-Ray eine Anforderung verfolgen, während sie Ressourcen in Ihrer Anwendung durchläuft, die Lambda-Funktionen und andere AWS -Services enthalten können.
Um Protokollierungsdaten an X-Ray zu senden, können Sie eine von zwei SDK-Bibliotheken verwenden:
+ [AWS Distro for OpenTelemetry (ADOT)](https://aws.amazon.com/otel) — Eine sichere, produktionsbereite und AWS unterstützte Distribution des () SDK. OpenTelemetry OTel
+ [AWS X-Ray SDK for Go](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-go.html) — Ein SDK zum Generieren und Senden von Trace-Daten an X-Ray.
Jedes SDKs bietet Möglichkeiten, Ihre Telemetriedaten an den X-Ray-Dienst zu senden. Sie können dann mit X-Ray die Leistungsmetriken Ihrer Anwendung anzeigen, filtern und erhalten, um Probleme und Möglichkeiten zur Optimierung zu identifizieren.
**Wichtig**
X-Ray und Powertools für AWS Lambda SDKs sind Teil einer eng integrierten Instrumentierungslösung von AWS. Die ADOT Lambda Layers sind Teil eines branchenweiten Standards für die Verfolgung von Instrumenten, die im Allgemeinen mehr Daten erfassen, aber möglicherweise nicht für alle Anwendungsfälle geeignet sind. Sie können die end-to-end Ablaufverfolgung in X-Ray mit beiden Lösungen implementieren. Weitere Informationen zur Auswahl zwischen beiden finden Sie unter [Wählen zwischen der AWS Distribution für Open Telemetry und](https://docs.aws.amazon.com/xray/latest/devguide/xray-instrumenting-your-app.html#xray-instrumenting-choosing) X-Ray. SDKs
**Topics**
+ [Verwenden von ADOT zur Instrumentierung Ihrer Go-Funktionen](#golang-adot)
+ [Instrumentierung Ihrer Go-Funktionen mithilfe von X-Ray-SDK](#golang-xray-sdk)
+ [Aktivieren der Nachverfolgung mit der Lambda-Konsole](#golang-tracing-console)
+ [Aktivieren der Nachverfolgung mit der Lambda-API](#golang-tracing-api)
+ [Die Ablaufverfolgung wird aktiviert mit CloudFormation](#golang-tracing-cloudformation)
+ [Interpretieren einer X-Ray-Nachverfolgung](#golang-tracing-interpretation)
## Verwenden von ADOT zur Instrumentierung Ihrer Go-Funktionen
ADOT bietet vollständig verwaltete [Lambda-Schichten](chapter-layers.md), die alles zusammenfassen, was Sie für die Erfassung von Telemetriedaten mithilfe des SDK benötigen. OTel Indem Sie diese Ebene verwenden, können Sie Ihre Lambda-Funktionen instrumentieren, ohne einen Funktionscode ändern zu müssen. Sie können Ihren Layer auch so konfigurieren, dass er eine benutzerdefinierte Initialisierung von durchführt. OTel Weitere Informationen finden Sie unter [Benutzerdefinierte Konfiguration für den ADOT Collector auf Lambda](https://aws-otel.github.io/docs/getting-started/lambda#custom-configuration-for-the-adot-collector-on-lambda) in der ADOT-Dokumentation.
Für Go-Laufzeiten können Sie den **AWS -verwaltete Lambda-Ebene für ADOT Go** hinzufügen, um Ihre Funktionen automatisch zu instrumentieren. Eine ausführliche Anleitung zum Hinzufügen dieser Ebene finden Sie unter [AWS Distro for OpenTelemetry Lambda Support for Go](https://aws-otel.github.io/docs/getting-started/lambda/lambda-go) in der ADOT-Dokumentation.
## Instrumentierung Ihrer Go-Funktionen mithilfe von X-Ray-SDK
Um Details zu Aufrufen aufzuzeichnen, die Ihre Lambda-Funktion an andere Ressourcen in Ihrer Anwendung tätigt, können Sie auch das AWS X-Ray SDK for Go verwenden. Um das SDK zu erhalten, laden Sie das SDK aus seinem [GitHub Repository](https://github.com/aws/aws-xray-sdk-go) herunter mit`go get`:
```
go get github.com/aws/aws-xray-sdk-go
```
Um AWS SDK-Clients zu instrumentieren, übergeben Sie den Client an die `xray.AWS()` Methode. Anschließend können Sie Aufrufe verfolgen, indem Sie die `WithContext`-Version der Methode verwenden.
```
svc := s3.New(session.New())
xray.AWS(svc.Client)
...
svc.ListBucketsWithContext(ctx aws.Context, input *ListBucketsInput)
```
Aktivieren Sie nach Hinzufügen der richtigen Abhängigkeiten die Nachverfolgung in der Konfiguration Ihrer Funktion über die Lambda-Konsole oder die API.
## Aktivieren der Nachverfolgung mit der Lambda-Konsole
Gehen Sie folgendermaßen vor, um die aktive Nachverfolgung Ihrer Lambda-Funktion mit der Konsole umzuschalten:
**So aktivieren Sie die aktive Nachverfolgung**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie eine Funktion aus.
1. Wählen Sie **Configuration** (Konfiguration) und dann **Monitoring and operations tools** (Überwachungs- und Produktionstools).
1. Wählen Sie unter **Zusätzliche Überwachungstools** die Option **Bearbeiten** aus.
1. Wählen Sie unter **CloudWatch Anwendungssignale und AWS X-Ray** die Option **Enable** for **Lambda Service Traces** aus.
1. Wählen Sie **Speichern**.
## Aktivieren der Nachverfolgung mit der Lambda-API
Konfigurieren Sie die Ablaufverfolgung für Ihre Lambda-Funktion mit dem AWS CLI oder AWS SDK und verwenden Sie die folgenden API-Operationen:
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
**Der folgende AWS CLI Beispielbefehl aktiviert die aktive Ablaufverfolgung für eine Funktion namens my-function.**
```
aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active
```
Der Ablaufverfolgungsmodus ist Teil der versionsspezifischen Konfiguration, wenn Sie eine Version Ihrer Funktion veröffentlichen. Sie können den Ablaufverfolgungsmodus für eine veröffentlichte Version nicht ändern.
## Die Ablaufverfolgung wird aktiviert mit CloudFormation
Um die Ablaufverfolgung für eine `AWS::Lambda::Function` Ressource in einer CloudFormation Vorlage zu aktivieren, verwenden Sie die `TracingConfig` Eigenschaft.
**Example [function-inline.yml](https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/templates/function-inline.yml) – Ablaufverfolgungskonfiguration**
```
Resources:
function:
Type: [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
Properties:
TracingConfig:
Mode: Active
...
```
Verwenden Sie für eine `AWS::Serverless::Function` Ressource AWS Serverless Application Model (AWS SAM) die `Tracing` Eigenschaft.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml) – Ablaufverfolgungskonfiguration**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
Tracing: Active
...
```
## Interpretieren einer X-Ray-Nachverfolgung
Ihre Funktion benötigt die Berechtigung zum Hochladen von Trace-Daten zu X-Ray. Wenn Sie die aktive Nachverfolgung in der Lambda-Konsole aktivieren, fügt Lambda der [Ausführungsrolle](lambda-intro-execution-role.md) Ihrer Funktion die erforderlichen Berechtigungen hinzu. Andernfalls fügen Sie die [AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess)Richtlinie der Ausführungsrolle hinzu.
Nachdem Sie die aktive Nachverfolgung konfiguriert haben, können Sie bestimmte Anfragen über Ihre Anwendung beobachten. Das [X-Ray-Service-Diagramm](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html#xray-concepts-servicegraph) zeigt Informationen über Ihre Anwendung und alle ihre Komponenten an. Das folgende Beispiel zeigt eine Anwendung mit zwei Funktionen. Die primäre Funktion verarbeitet Ereignisse und gibt manchmal Fehler zurück. Die zweite Funktion an oberster Stelle verarbeitet Fehler, die in der Protokollgruppe der ersten auftreten, und verwendet das AWS SDK, um X-Ray, Amazon Simple Storage Service (Amazon S3) und Amazon CloudWatch Logs aufzurufen.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/sample-errorprocessor-servicemap.png)
X-Ray verfolgt nicht alle Anfragen an Ihre Anwendung nach. X-Ray wendet einen Sampling-Algorithmus an, um sicherzustellen, dass die Nachverfolgung effizient ist, und stellt dennoch ein repräsentatives Beispiel aller Anfragen bereit. Die Samplingrate beträgt 1 Anforderung pro Sekunde und 5 Prozent aller weiteren Anforderungen. Sie können die X-Ray-Samplingrate nicht für Ihre Funktionen konfigurieren.
In X-Ray, zeichnet eine *Ablaufverfolgung* Informationen zu einer Anforderung auf, die von einem oder mehreren *Services* verarbeitet wird. Lambda zeichnet 2 Segmente pro Trace auf, wodurch zwei Knoten im Dienstgraphen entstehen. In der folgenden Abbildung werden diese beiden Knoten hervorgehoben:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/xray-servicemap-function.png)
Der erste Knoten auf der linken Seite stellt den Lambda-Service dar, der die Aufrufanforderung empfängt. Der zweite Knoten stellt Ihre spezifische Lambda-Funktion dar. Das folgende Beispiel zeigt eine Nachverfolgung mit diesen zwei Segmenten. Beide heißen **my-function**, aber einer hat einen Ursprung von `AWS::Lambda` und der andere hat einen Ursprung von `AWS::Lambda::Function`. Wenn das `AWS::Lambda`-Segment einen Fehler anzeigt, hatte der Lambda-Service ein Problem. Wenn das `AWS::Lambda::Function`-Segment einen Fehler anzeigt, ist bei Ihrer Funktion ein Problem aufgetreten.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)
Dieses Beispiel erweitert das `AWS::Lambda::Function`-Segment, um seine drei Untersegmente anzuzeigen.
**Anmerkung**
AWS implementiert derzeit Änderungen am Lambda-Service. Aufgrund dieser Änderungen können geringfügige Unterschiede in Struktur und Inhalt der Systemprotokollmeldungen und Trace-Segmente auftreten, die von verschiedenen Lambda-Funktionen in Ihrem AWS-Konto.
Der hier gezeigte Beispiel-Trace veranschaulicht das Funktionssegment im alten Stil. Die Unterschiede zwischen den Segmenten im alten und im neuen Stil werden in den folgenden Abschnitten beschrieben.
Diese Änderungen werden in den kommenden Wochen umgesetzt, und alle Funktionen AWS-Regionen außer China und den GovCloud Regionen werden auf die Verwendung der Protokollnachrichten und Trace-Segmente im neuen Format umgestellt.
Das Funktionssegment im alten Stil enthält die folgenden Untersegmente:
+ **Initialisierung** – Stellt die Zeit dar, die für das Laden Ihrer Funktion und das Ausführen des [Initialisierungscodes](foundation-progmodel.md) aufgewendet wurde. Dieses Untersegment erscheint nur für das erste Ereignis, das jede Instance Ihrer Funktion verarbeitet.
+ **Invocation** (Aufruf) – Stellt die Zeit dar, die beim Ausführen Ihres Handler-Codes vergeht.
+ **Overhead** (Aufwand) – Stellt die Zeit dar, die von der Lambda-Laufzeitumgebung bei der Verarbeitung des nächsten Ereignisses verbraucht wird.
Das Funktionssegment im neuen Stil enthält kein `Invocation`-Untersegment. Stattdessen werden Kundenuntersegmente direkt an das Funktionssegment angehängt. Weitere Informationen über die Struktur der alten und neuen Funktionssegmente finden Sie unter [Grundlegendes zu X-Ray-Ablaufverfolgungen](services-xray.md#services-xray-traces).
Sie können auch HTTP-Clients instrumentieren, SQL-Abfragen aufzeichnen und benutzerdefinierte Untersegmente mit Anmerkungen und Metadaten erstellen. Weitere Informationen finden Sie unter [AWS X-Ray -SDK für Go](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html) im *AWS X-Ray -Entwicklerhandbuch*.
**Preisgestaltung**
Im Rahmen des kostenlosen Kontingents können Sie X-Ray Tracing jeden Monat bis zu einem bestimmten Limit AWS kostenlos nutzen. Über den Schwellenwert hinaus berechnet X-Ray Gebühren für die Speicherung und den Abruf der Nachverfolgung. Weitere Informationen finden Sie unter [AWS X-Ray Preise](https://aws.amazon.com/xray/pricing/).