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.
# 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.