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.
# AWS Lambda Funktionen konfigurieren
Erfahren Sie, wie Sie die wichtigsten Funktionen und Optionen für Ihre Lambda-Funktion mithilfe der Lambda-API oder der Konsole konfigurieren.
**[.zip-Dateiarchive](configuration-function-zip.md) **
Erstellen Sie ein Paket zur Bereitstellung von Lambda-Funktionen, wenn Sie Abhängigkeiten, benutzerdefinierte Laufzeitebenen oder Dateien außerhalb Ihres Funktionscodes einbeziehen möchten. Das Bereitstellungspaket ist ein ZIP-Dateiarchiv, das Ihren Funktionscode und Ihre Abhängigkeiten enthält.
**[Container-Images](images-create.md) **
Verwenden Sie Container-Images, um Ihren Funktionscode und Ihre Abhängigkeiten zu verpacken, wenn Sie mehr Kontrolle über den Erstellungsprozess benötigen oder wenn Ihre Funktion benutzerdefinierte Laufzeitkonfigurationen erfordert. Mit Tools wie Docker CLI können Sie Lambda-Funktionen als Container-Images erstellen, testen und bereitstellen.
**[Arbeitsspeicher](configuration-memory.md)**
Hier erfahren Sie, wie und wann das Funktionsgedächtnis erweitert wird.
**[Flüchtiger Speicher](configuration-ephemeral-storage.md) **
Erfahren Sie, wie und wann Sie die temporäre Speicherkapazität Ihrer Funktion erhöhen können.
**[Timeout (Zeitüberschreitung)](configuration-timeout.md) **
Erfahren Sie, wie und wann Sie den Timeout-Wert Ihrer Funktion erhöhen können.
**[Dauerhafte Konfiguration](durable-configuration.md) **
Ermöglichen Sie die Ausführung Ihrer Lambda-Funktionen für längere Zeiträume — bis zu einem Jahr — und behalten Sie dabei den Status zwischen den Aufrufen bei. Konfigurieren Sie Ausführungs-Timeouts, die Beibehaltung des Status und das Versionsverwaltungsverhalten für Workflows mit langer Laufzeit und Statusinformationen. Zuverlässige Funktionen ermöglichen es Ihnen, komplexe, mehrstufige Prozesse zu erstellen, die unterbrochen und wieder aufgenommen werden können und Unterbrechungen automatisch beheben können.
** [Umgebungsvariablen](configuration-envvars.md)**
Sie können Ihren Funktionscode portabel machen und Geheimnisse aus Ihrem Code heraushalten, indem Sie sie mithilfe von Umgebungsvariablen in der Konfiguration Ihrer Funktion speichern.
**[Ausgehende Netzwerke](configuration-vpc.md) **
Sie können Ihre Lambda-Funktion mit AWS Ressourcen in einer Amazon VPC verwenden. Wenn Sie Ihre Funktion mit einer VPC verbinden, können Sie auf Ressourcen in einem privaten Subnetz wie relationale Datenbanken und Caches zugreifen.
** [Eingehende Netzwerke](configuration-vpc-endpoints.md)**
Sie können einen Schnittstellen-VPC-Endpunkt verwenden, um Ihre Lambda-Funktionen aufzurufen, ohne das öffentliche Internet zu nutzen.
**[Dateisystem](configuration-filesystem.md)**
Sie können Ihre Lambda-Funktion verwenden, um ein Amazon EFS in ein lokales Verzeichnis einzubinden. Ein Dateisystem ermöglicht es Ihrem Funktionscode, sicher und mit hoher Gleichzeitigkeit auf gemeinsam genutzte Ressourcen zuzugreifen und diese zu ändern.
**[Aliasnamen](configuration-aliases.md)**
Sie können Ihre Clients so konfigurieren, dass sie eine bestimmte Lambda-Funktionsversion aufrufen, indem Sie einen Alias verwenden, anstatt den Client zu aktualisieren.
**[Versionen](configuration-versions.md)**
Durch die Veröffentlichung einer Version Ihrer Funktion können Sie Ihren Code und Ihre Konfiguration als separate Ressource speichern, die nicht geändert werden kann.
**[Tags](configuration-tags.md)**
Verwenden Sie Tags, um die attributebasierte Zugriffskontrolle (ABAC) zu aktivieren, Ihre Lambda-Funktionen zu organisieren und Berichte über Ihre Funktionen mithilfe der Dienste AWS Cost Explorer oder AWS Billing and Cost Management zu filtern und zu generieren.
**[Antwort-Streaming](configuration-response-streaming.md)**
Sie können Ihre Lambda-Funktion so konfigurieren, dass Antwortnutzlasten zurück URLs an Clients gestreamt werden. Antwort-Streaming kann für latenzempfindliche Anwendungen von Vorteil sein, da es die Leistung in der Zeit bis zum ersten Byte (TTFB) verbessert. Dies liegt daran, dass Sie Teilantworten an den Client zurücksenden können, sobald sie verfügbar sind. Darüber hinaus können Sie Response-Streaming verwenden, um Funktionen zu erstellen, die größere Nutzlasten zurückgeben.
**[Metadaten-Endpunkt](configuration-metadata-endpoint.md)**
Verwenden Sie den Lambda-Metadaten-Endpunkt, um zu ermitteln, in welcher Availability Zone Ihre Funktion ausgeführt wird. So können Sie die Latenz optimieren, indem Sie zu Ressourcen derselben AZ weiterleiten und AZ-fähige Resilienzmuster implementieren.
# Bereitstellen von Lambda-Funktionen als ZIP-Dateiarchive
Wenn Sie eine Lambda-Funktion erstellen, verpacken Sie Ihren Funktionscode in einem Bereitstellungspaket. Lambda unterstützt zwei Arten von Bereitstellungspaketen: Container-Images und .zip-Archive. Der Workflow zum Erstellen einer Funktion hängt vom Typ des Bereitstellungspakets ab. Zur Konfiguration einer Funktion, die als Container-Image definiert ist, siehe [Erstellen einer Lambda-Funktion mit einem Container-Image](images-create.md).
Sie können die Lambda-Konsole und die Lambda-API verwenden, um eine mit einem ZIP-Dateiarchiv definierte Funktion zu erstellen. Sie können auch eine aktualisierte ZIP-Datei uploaden, um den Funktionscode zu ändern.
**Anmerkung**
Sie können den [Bereitstellungspakettyp](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip oder Container-Image) für eine vorhandene Funktion nicht ändern. Sie können zum Beispiel eine Container-Image-Funktion nicht so umwandeln, dass sie ein .zip-Archiv verwendet. Sie müssen eine neue Funktion erstellen.
**Topics**
+ [
## Erstellen der Funktion
](#configuration-function-create)
+ [
## Verwenden des Konsolencode-Editors
](#configuration-functions-console-update)
+ [
## Aktualisieren des Funktionscodes
](#configuration-function-update)
+ [
## Ändern der Laufzeit
](#configuration-function-runtime)
+ [
## Ändern der Architektur
](#configuration-function-arch)
+ [
## Verwenden der Lambda-API
](#configuration-function-api)
+ [
## Herunterladen des Funktionscodes
](#configuration-function-download)
+ [
## CloudFormation
](#configuration-function-cloudformation)
+ [
# Verschlüsselung von Lambda-.zip-Bereitstellungspaketen
](encrypt-zip-package.md)
## Erstellen der Funktion
Wenn Sie eine Funktion erstellen, die mit einem ZIP-Dateiarchiv definiert ist, wählen Sie eine Codevorlage, die Sprachversion und die Ausführungsrolle für die Funktion aus. Sie fügen Ihren Funktionscode hinzu, nachdem Lambda die Funktion erstellt hat.
**So erstellen Sie die Funktion**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie **Funktion erstellen**.
1. Wählen Sie **Von Grund auf neu erstellen** oder **Vorlage verwenden**, um Ihre Funktion zu erstellen.
1. Führen Sie unter **Basic information** (Grundlegende Informationen) die folgenden Schritte aus:
1. Geben Sie für **Funktionsname** den Funktionsnamen ein. Funktionsnamen sind auf eine Länge von 64 Zeichen beschränkt.
1. Wählen Sie für **Laufzeit** die Sprachversion aus, die für Ihre Funktion verwendet werden soll.
1. (Optional) Für**-Architektur**wählen Sie die Befehlssatz-Architektur aus, die für Ihre Funktion verwendet werden soll. Die Standardarchitektur ist x86\$164. Stellen Sie beim Erstellen des Bereitstellungspakets für Ihre Funktion sicher, dass es damit kompatibel ist[Befehlssatz-Architektur](foundation-arch.md)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. (Optional) Erweitern Sie den Abschnitt **Advanced Settings (Erweiterte Einstellungen)**. Sie können eine **Codesignatur-Konfiguration** für die Funktion wählen. Sie können auch eine (Amazon VPC) für die Funktion konfigurieren, auf die zugegriffen werden soll.
1. Wählen Sie **Funktion erstellen**.
Lambda erstellt die neue Funktion. Sie können nun die Konsole verwenden, um den Funktionscode hinzuzufügen und andere Funktionsparameter und -funktionen zu konfigurieren. Anweisungen zur Codebereitstellung finden Sie auf der Handler-Seite für die Laufzeit, die Ihre Funktion verwendet.
------
#### [ Node.js ]
[Bereitstellen von Node.js Lambda-Funktionen mit ZIP-Dateiarchiven](nodejs-package.md)
------
#### [ Python ]
[Arbeiten mit ZIP-Dateiarchiven und Python-Lambda-Funktionen](python-package.md)
------
#### [ Ruby ]
[Bereitstellen von Ruby-Lambda-Funktionen mit ZIP-Dateiarchiven](ruby-package.md)
------
#### [ Java ]
[Bereitstellen von Java-Lambda-Funktionen mit ZIP- oder JAR-Dateiarchiven](java-package.md)
------
#### [ Go ]
[Bereitstellen von Lambda-Go-Funktionen mit ZIP-Dateiarchiven](golang-package.md)
------
#### [ C\$1 ]
[Erstellen und Bereitstellen von C\$1-Lambda-Funktionen mit ZIP-Dateiarchiven](csharp-package.md)
------
#### [ PowerShell ]
[PowerShell-Lambda-Funktionen mit .zip-Dateiarchiven bereitstellen](powershell-package.md)
------
## Verwenden des Konsolencode-Editors
Die Konsole erstellt eine Lambda-Funktion mit einer einzigen Quelldatei. Bei Skriptsprachen können Sie diese Datei bearbeiten und mit dem integrierten Code-Editor weitere Dateien hinzufügen. Klicken Sie auf **Save (Speichern)**, um die Änderungen zu speichern. Um Ihren Code auszuführen, wählen Sie **Test**.
Wenn Sie Ihren Funktionscode speichern, erstellt die Lambda-Konsole ein Bereitstellungspaket für das ZIP-Dateiarchiv. Wenn Sie Ihren Funktionscode außerhalb der Konsole (mit einer IDE) entwickeln, müssen Sie [ein Bereitstellungspaket erstellen](nodejs-package.md), um Ihren Code in die Lambda-Funktion hochzuladen.
## Aktualisieren des Funktionscodes
Bei Skriptsprachen (Node.js, Python und Ruby) können Sie Ihren Funktionscode im eingebetteten Code-Editor bearbeiten. Wenn der Code größer als 3 MB ist, oder wenn Sie Bibliotheken hinzufügen müssen, oder für Sprachen, die der Editor nicht unterstützt (Java, Go, C\$1), müssen Sie Ihren Funktionscode als .zip-Archiv uploaden. Wenn das ZIP-Dateiarchiv kleiner als 50 MB ist, können Sie das ZIP-Dateiarchiv von Ihrem lokalen Computer uploaden. Wenn die Datei größer als 50 MB ist, müssen Sie die Datei aus einem Amazon S3-Bucket in die Funktion uploaden.
**So können Sie den Funktionscode als .zip-Archiv uploaden**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie die zu aktualisierende Funktion aus und wählen Sie die **Code**-Registerkarte.
1. Wählen Sie unter **Codequelle** die Option **Upload von** aus.
1. Wählen Sie **.zip-Datei** und dann **Hochladen**.
1. Wählen Sie in der Dateiauswahl die neue Image-Version aus, wählen Sie **Öffnen** und dann **Speichern**.
1. (Alternative zu Schritt 4) Wählen Sie den **Amazon-S3-Standort**.
1. Geben Sie in das Textfeld die S3-Link-URL des ZIP-Dateiarchivs ein und wählen Sie dann **Speichern**.
## Ändern der Laufzeit
Wenn Sie die Funktionskonfiguration aktualisieren, um eine neue Laufzeit zu verwenden, müssen Sie möglicherweise den Funktionscode aktualisieren, damit dieser mit der neuen Laufzeit kompatibel ist. Wenn Sie die Funktionskonfiguration aktualisieren, um eine andere Laufzeit zu verwenden,**muss**stellen Sie neuen Funktionscode bereit, der mit Laufzeit und Architektur kompatibel ist. Anweisungen zum Erstellen eines Bereitstellungspakets für den Funktionscode finden Sie auf der Handler-Seite für die Laufzeit, die die Funktion verwendet.
Die Basis-Images Node.js 20, Python 3.12, Java 21, .NET 8, Ruby 3.3 und höher basieren auf dem minimalen Container-Image von Amazon Linux 2023. Frühere Basis-Images verwenden Amazon Linux 2. AL2023 bietet mehrere Vorteile gegenüber Amazon Linux 2, darunter einen geringeren Bereitstellungsaufwand und aktualisierte Versionen von Bibliotheken wie`glibc`. Weitere Informationen finden Sie unter [Introducing the Amazon Linux 2023 runtime for AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/) im AWS -Compute-Blog.
**So ändern Sie die Laufzeit**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie die zu aktualisierende Funktion aus und wählen Sie die **Code**-Registerkarte.
1. Blättern Sie nach unten bis zum Abschnitt **Laufzeiteinstellungen**, der sich unter dem Code-Editor befindet.
1. Wählen Sie **Bearbeiten** aus.
1. Wählen Sie für **Runtime** (Laufzeit) die Laufzeit-ID aus.
1. Geben Sie im Feld **Handler** den Dateinamen und en Handler für die Funktion ein.
1. Für**-Architektur**wählen Sie die Befehlssatz-Architektur aus, die für Ihre Funktion verwendet werden soll.
1. Wählen Sie **Speichern**.
## Ändern der Architektur
Bevor Sie die Befehlssatzarchitektur ändern können, müssen Sie sicherstellen, dass der Code Ihrer Funktion mit der Zielarchitektur kompatibel ist.
Wenn Sie Node.js, Python oder Ruby verwenden und Ihren Funktionscode im eingebettetenEditorkann der vorhandene Code ohne Änderung ausgeführt werden.
Wenn Sie jedoch Ihren Funktionscode mithilfe eines Bereitstellungspakets im ZIP-Dateiarchiv angeben, müssen Sie ein neues ZIP-Dateiarchiv vorbereiten, das korrekt für die Ziel-Laufzeit- und Anleitungssatz-Architektur kompiliert und erstellt wird. Anweisungen dazu finden Sie auf der Handler-Seite für Ihre Funktions-Laufzeit.
**So ändern Sie die Befehlssatz-Architektur**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie die zu aktualisierende Funktion aus und wählen Sie die **Code**-Registerkarte.
1. Wählen Sie unter **Laufzeiteinstellungen** die Option **Bearbeiten**.
1. Für**-Architektur**wählen Sie die Befehlssatz-Architektur aus, die für Ihre Funktion verwendet werden soll.
1. Wählen Sie **Speichern**.
## Verwenden der Lambda-API
Um eine Funktion zu erstellen und zu konfigurieren, die ein ZIP-Dateiarchiv verwendet, 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)
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
## Herunterladen des Funktionscodes
Sie können die aktuelle unveröffentlichte Version (`$LATEST`) Ihres Funktionscodes (.zip) über die Lambda-Konsole herunterladen. Um dies zu tun, müssen Sie zunächst über die folgenden IAM-Berechtigungen verfügen:
+ `iam:GetPolicy`
+ `iam:GetPolicyVersion`
+ `iam:GetRole`
+ `iam:GetRolePolicy`
+ `iam:ListAttachedRolePolicies`
+ `iam:ListRolePolicies`
+ `iam:ListRoles`
**So laden Sie den Funktionscode (.zip) herunter**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie die Funktion aus, für die Sie den Funktionscode (.zip) herunterladen möchten.
1. Wählen Sie in der **Funktionsübersicht** die Schaltfläche **Herunterladen** und anschließend **Funktionscode herunterladen (.zip**).
1. Wählen Sie alternativ ** AWS SAM Datei herunterladen**, um eine SAM-Vorlage zu generieren und herunterzuladen, die auf der Konfiguration Ihrer Funktion basiert. Sie können auch **Beide herunterladen** wählen, um sowohl die ZIP-Vorlage als auch die SAM-Vorlage herunterzuladen.
## CloudFormation
Sie können CloudFormation damit eine Lambda-Funktion erstellen, die ein ZIP-Dateiarchiv verwendet. In Ihrer CloudFormation Vorlage spezifiziert die `AWS::Lambda::Function` Ressource die Lambda-Funktion. Eine Beschreibung der Eigenschaften in der `AWS::Lambda::Function` Ressource finden Sie [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)im *AWS CloudFormation Benutzerhandbuch*.
Legen Sie in der `AWS::Lambda::Function`-Ressource die folgenden Eigenschaften fest, um eine Funktion zu erstellen, die als Zip-Datei-Archiv definiert ist:
+ AWS::Lambda::Function
+ PackageType — Eingestellt auf`Zip`.
+ Code – Geben Sie den Namen des Amazon-S3-Buckets und den ZIP-Dateinamen in die Textfelder `S3Bucket` und `S3Key`. Für Node.js oder Python können Sie Inline-Quellcode Ihrer Lambda-Funktion bereitstellen.
+ Laufzeit – Legt den Laufzeitwert fest.
+ Architektur — Stellen Sie den Architekturwert auf ein, `arm64` um den AWS Graviton2-Prozessor zu verwenden. Der Standardwert ist`x86_64`aus.
# Verschlüsselung von Lambda-.zip-Bereitstellungspaketen
Lambda bietet im Ruhezustand immer serverseitige Verschlüsselung für .zip-Bereitstellungspakete und Funktionskonfigurationsdetails mit einem AWS KMS key an. Standardmäßig verwendet Lambda einen [AWS-eigener Schlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk). Wenn dieses Standardverhalten zu Ihrem Workflow passt, müssen Sie nichts anderes einrichten. AWS berechnet Ihnen keine Gebühren für die Verwendung dieses Schlüssels.
Wenn Sie möchten, können Sie stattdessen einen vom AWS KMS Kunden verwalteten Schlüssel bereitstellen. Sie können dies tun, um die Drehung des KMS-Schlüssels zu steuern oder die Anforderungen Ihrer Organisation für die Verwaltung von KMS-Schlüsseln zu erfüllen. Wenn Sie einen vom Kunden verwalteten Schlüssel verwenden, können nur Benutzer Ihres Kontos mit Zugriff auf den KMS-Schlüssel den Code oder die Konfiguration der Funktion anzeigen oder verwalten.
Für vom Kunden verwaltete Schlüssel fallen AWS KMS Standardgebühren an. Weitere Informationen finden Sie unter [AWS Key Management Service Preise](https://aws.amazon.com/kms/pricing/).
## Erstellen eines kundenseitig verwalteten Schlüssels
Sie können einen symmetrischen, vom Kunden verwalteten Schlüssel erstellen, indem Sie den AWS-Managementkonsole, oder den verwenden. AWS KMS APIs
**Einen symmetrischen kundenverwalteten Schlüssel erstellen**
Befolgen Sie die Schritte zur [Erstellung symmetrischer Verschlüsselung Erstellung symmetrischer KMS-Schlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) mit symmetrischer Verschlüsselung im *AWS Key Management Service -Entwicklerhandbuch*.
### Berechtigungen
**Schlüsselrichtlinie**
[Schlüsselrichtlinien](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) steuern den Zugriff auf den vom Kunden verwalteten Schlüssel. Jeder vom Kunden verwaltete Schlüssel muss über genau eine Schlüsselrichtlinie verfügen, die aussagt, wer den Schlüssel wie verwenden kann. Weitere Informationen finden Sie unter [So ändern Sie eine Schlüsselrichtlinie](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying.html#key-policy-modifying-how-to) im *AWS Key Management Service -Entwicklerhandbuch*.
Wenn Sie einen vom Kunden verwalteten Schlüssel verwenden, um ein .zip-Bereitstellungspaket zu verschlüsseln, fügt Lambda dem Schlüssel keinen [Zuschuss](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) hinzu. Stattdessen muss Ihre AWS KMS Schlüsselrichtlinie es Lambda ermöglichen, die folgenden AWS KMS API-Operationen in Ihrem Namen aufzurufen:
+ [km: GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)
+ [kms:Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)
Die folgende Beispielschlüsselrichtlinie ermöglicht es allen Lambda-Funktionen im Konto 111122223333, die erforderlichen AWS KMS Operationen für den angegebenen vom Kunden verwalteten Schlüssel aufzurufen:
**Example AWS KMS wichtige Richtlinie**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt"
],
"Resource": "arn:aws:kms:us-east-1:111122223333:key/key-id",
"Condition": {
"StringLike": {
"kms:EncryptionContext:aws:lambda:FunctionArn": "arn:aws:lambda:us-east-1:111122223333:function:*"
}
}
}
]
}
```
Weitere Informationen zur [Fehlerbehebung beim Schlüsselzugriff](https://docs.aws.amazon.com/kms/latest/developerguide/policy-evaluation.html#example-no-iam) finden Sie im *AWS Key Management Service -Entwicklerhandbuch*.
**Prinzipalberechtigungen**
Wenn Sie einen vom Kunden verwalteten Schlüssel verwenden, um ein .zip-Bereitstellungspaket zu verschlüsseln, können nur [Prinzipale](https://docs.aws.amazon.com/IAM/latest/UserGuide/intro-structure.html) mit Zugriff auf diesen Schlüssel auf das .zip-Bereitstellungspaket zugreifen. Principals, die keinen Zugriff auf den vom Kunden verwalteten Schlüssel haben, können beispielsweise das .zip-Paket nicht über die vorsignierte S3-URL herunterladen, die in der Antwort enthalten ist. [GetFunction](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html) Im Abschnitt `Code` der Antwort wird ein `AccessDeniedException` zurückgegeben.
**Example AWS KMS AccessDeniedException**
```
{
"Code": {
"RepositoryType": "S3",
"Error": {
"ErrorCode": "AccessDeniedException",
"Message": "KMS access is denied. Check your KMS permissions. KMS Exception: AccessDeniedException KMS Message: User: arn:aws:sts::111122223333:assumed-role/LambdaTestRole/session is not authorized to perform: kms:Decrypt on resource: arn:aws:kms:us-east-1:111122223333:key/key-id with an explicit deny in a resource-based policy"
},
"SourceKMSKeyArn": "arn:aws:kms:us-east-1:111122223333:key/key-id"
},
...
```
Weitere Informationen zu Berechtigungen für AWS KMS Schlüssel finden Sie unter [Authentifizierung und Zugriffskontrolle](https://docs.aws.amazon.com/kms/latest/developerguide/control-access.html) für. AWS KMS
## Verwenden Sie einen vom Kunden verwalteten Schlüssel für Ihr .zip-Bereitstellungspaket
Verwenden Sie die folgenden API-Parameter, um vom Kunden verwaltete Schlüssel für .zip-Bereitstellungspakete zu konfigurieren:
+ [Source KMSKey Arn](https://docs.aws.amazon.com/lambda/latest/api/API_FunctionCode.html#lambda-Type-FunctionCode-SourceKMSKeyArn): Verschlüsselt das Quell-ZIP-Bereitstellungspaket (die Datei, die Sie hochladen).
+ [KMSKeyArn](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-KMSKeyArn): Verschlüsselt [Umgebungsvariablen](configuration-envvars-encryption.md) und [Lambda-Snapshots SnapStart](snapstart.md).
Wenn `SourceKMSKeyArn` und `KMSKeyArn` beide angegeben sind, verwendet Lambda den Schlüssel `KMSKeyArn`, um die entpackte Version des Pakets zu verschlüsseln, das Lambda zum Aufrufen der Funktion verwendet. Wenn `SourceKMSKeyArn` angegeben ist, aber `KMSKeyArn` nicht, verwendet Lambda ein [Von AWS verwalteter Schlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk), um die entpackte Version des Pakets zu verschlüsseln.
------
#### [ Lambda console ]
**So fügen Sie beim Erstellen einer Funktion die kundenverwaltete Schlüsselverschlüsselung hinzu**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie **Funktion erstellen**.
1. Klicken Sie auf **Ohne Vorgabe erstellen** oder **Container-Image**.
1. Führen Sie unter **Basic information** (Grundlegende Informationen) die folgenden Schritte aus:
1. Geben Sie für **Funktionsname** den Funktionsnamen ein.
1. Wählen Sie für **Laufzeit** die Sprachversion aus, die für Ihre Funktion verwendet werden soll.
1. Erweitern Sie **Erweiterte Einstellungen** und wählen Sie dann **Verschlüsselung mit einem vom AWS KMS Kunden verwalteten Schlüssel aktivieren** aus.
1. Wählen Sie einen kundenverwalteten Schlüssel.
1. Wählen Sie **Funktion erstellen**.
Um die vom Kunden verwaltete Schlüsselverschlüsselung zu entfernen oder einen anderen Schlüssel zu verwenden, müssen Sie das .zip-Bereitstellungspaket erneut hochladen.
**So fügen Sie einer bestehenden Funktion eine vom Kunden verwaltete Schlüsselverschlüsselung hinzu**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie den Namen einer Funktion aus.
1. Wählen Sie im Bereich **Codequelle** die Option **Hochladen von** aus.
1. Wählen Sie eine **.zip-Datei** oder einen **Amazon-S3-Speicherort**.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/upload-zip.png)
1. Laden Sie die Datei hoch oder geben Sie den Amazon-S3-Speicherort ein.
1. Wählen Sie **Verschlüsselung mit einem vom AWS KMS Kunden verwalteten Schlüssel aktivieren** aus.
1. Wählen Sie einen kundenverwalteten Schlüssel.
1. Wählen Sie **Speichern**.
------
#### [ AWS CLI ]
**So fügen Sie beim Erstellen einer Funktion die kundenverwaltete Schlüsselverschlüsselung hinzu**
Im folgenden Beispiel wird [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) erstellt:
+ `--code`: Gibt den lokalen Pfad zum ZIP-Bereitstellungspaket (`ZipFile`) und den vom Kunden verwalteten Schlüssel zur Verschlüsselung an (`SourceKMSKeyArn`).
+ `--kms-key-arn`: Gibt den vom Kunden verwalteten Schlüssel zur Verschlüsselung der Umgebungsvariablen und der entpackten Version des Bereitstellungspakets an.
```
aws lambda create-function \
--function-name myFunction \
--runtime nodejs24.x \
--handler index.handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code ZipFile=fileb://myFunction.zip,SourceKMSKeyArn=arn:aws:kms:us-east-1:111122223333:key/key-id \
--kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key2-id
```
Im folgenden Beispiel wird [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) erstellt:
+ `--code`: Gibt den Speicherort der .zip-Datei in einem Amazon S3 S3-Bucket (`S3Bucket`,`S3Key`,`S3ObjectVersion`) und den vom Kunden verwalteten Schlüssel zur Verschlüsselung an (`SourceKMSKeyArn`).
+ `--kms-key-arn`: Gibt den vom Kunden verwalteten Schlüssel zur Verschlüsselung der Umgebungsvariablen und der entpackten Version des Bereitstellungspakets an.
```
aws lambda create-function \
--function-name myFunction \
--runtime nodejs24.x --handler index.handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion,SourceKMSKeyArn=arn:aws:kms:us-east-1:111122223333:key/key-id \
--kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key2-id
```
**So fügen Sie einer bestehenden Funktion eine vom Kunden verwaltete Schlüsselverschlüsselung hinzu**
Im folgenden Beispiel: [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)
+ `--zip-file`: Gibt den lokalen Pfad zum .zip-Bereitstellungspaket an.
+ `--source-kms-key-arn`: Gibt den vom Kunden verwalteten Schlüssel zum Verschlüsseln der komprimierten Version des Bereitstellungspakets an. Lambda verwendet einen AWS eigenen Schlüssel, um das entpackte Paket für Funktionsaufrufe zu verschlüsseln. Wenn Sie einen vom Kunden verwalteten Schlüssel verwenden möchten, um die entpackte Version des Pakets zu verschlüsseln, führen Sie den Befehl mit der Option aus. [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html)`--kms-key-arn`
```
aws lambda update-function-code \
--function-name myFunction \
--zip-file fileb://myFunction.zip \
--source-kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key-id
```
Im folgenden Beispiel: [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)
+ `--s3-bucket`: Gibt den Speicherort der .zip-Datei in einem Amazon-S3-Bucket an.
+ `--s3-key`: Gibt den Amazon-S3-Schlüssel des Bereitstellungspakets an.
+ `--s3-object-version`: Für versionierte Objekte, die Version des zu verwendenden Bereitstellungspaketobjekts.
+ `--source-kms-key-arn`: Gibt den vom Kunden verwalteten Schlüssel zum Verschlüsseln der komprimierten Version des Bereitstellungspakets an. Lambda verwendet einen AWS eigenen Schlüssel, um das entpackte Paket für Funktionsaufrufe zu verschlüsseln. Wenn Sie einen vom Kunden verwalteten Schlüssel verwenden möchten, um die entpackte Version des Pakets zu verschlüsseln, führen Sie den Befehl mit der Option aus. [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html)`--kms-key-arn`
```
aws lambda update-function-code \
--function-name myFunction \
--s3-bucket amzn-s3-demo-bucket \
--s3-key myFileName.zip \
--s3-object-version myObject Version
--source-kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key-id
```
**So entfernen Sie die vom Kunden verwaltete Schlüsselverschlüsselung aus einer bestehenden Funktion**
Im folgenden [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Beispiel wird der lokale Pfad zum ZIP-Bereitstellungspaket `--zip-file` angegeben. Wenn Sie diesen Befehl ohne die `--source-kms-key-arn` Option ausführen, verwendet Lambda einen AWS eigenen Schlüssel, um die komprimierte Version des Bereitstellungspakets zu verschlüsseln.
```
aws lambda update-function-code \
--function-name myFunction \
--zip-file fileb://myFunction.zip
```
------
# Erstellen einer Lambda-Funktion mit einem Container-Image
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.
Es gibt drei Möglichkeiten, ein Container-Image für eine Lambda-Funktion zu erstellen:
+ [Verwenden eines AWS Basis-Images für Lambda](#runtimes-images-lp)
Die [AWS -Basis-Images](#runtimes-images-lp) sind mit einer Sprachlaufzeit, einem Laufzeitschnittstellen-Client zur Verwaltung der Interaktion zwischen Lambda und Ihrem Funktionscode und einem Laufzeitschnittstellen-Emulator für lokale Tests vorinstalliert.
+ [Es wird ein AWS reines Betriebssystem-Basis-Image verwendet](#runtimes-images-provided)
[AWS Basis-Images nur für Betriebssysteme](https://gallery.ecr.aws/lambda/provided) enthalten eine Amazon Linux-Distribution und den [Runtime-Interface-Emulator](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Diese Images werden häufig verwendet, um Container-Images für kompilierte Sprachen wie [Go](go-image.md#go-image-provided) und [Rust](lambda-rust.md) sowie für eine Sprache oder Sprachversion zu erstellen, für die Lambda kein Basis-Image bereitstellt, wie Node.js 19. Sie können reine OS-Basis-Images auch verwenden, um eine [benutzerdefinierte Laufzeit](runtimes-custom.md) zu implementieren. Um das Image mit Lambda kompatibel zu machen, müssen Sie den [Laufzeitschnittstellen-Client](#images-ric) für Ihre Sprache in das Image aufnehmen.
+ [Verwenden eines AWS Nicht-Base-Images](#images-types)
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 den [Laufzeitschnittstellen-Client](#images-ric) für Ihre Sprache 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/build/building/multi-stage/). 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/).
Um eine Lambda-Funktion aus einem Container-Image zu erstellen, erstellen Sie Ihr Image lokal und laden es in ein Amazon Elastic Container Registry (Amazon ECR)-Repository hoch. Wenn Sie ein von einem [AWS Marketplace](https://docs.aws.amazon.com/marketplace/latest/userguide/container-based-products.html)-Verkäufer bereitgestelltes Container-Image verwenden, müssen Sie das Image zuerst in Ihr privates Amazon-ECR-Repository klonen. Geben Sie dann den Repository-URI an, wenn Sie die Funktion erstellen. Das Amazon ECR-Repository muss sich im selben Format AWS-Region wie die Lambda-Funktion befinden. 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](#configuration-images-xaccount-permissions).
**Anmerkung**
Lambda unterstützt Amazon-ECR-FIPS-Endpunkte für Container-Images nicht. Wenn Ihr Repository-URI ein `ecr-fips` enthält, verwenden Sie einen FIPS-Endpunkt. Beispiel: `111122223333.dkr.ecr-fips.us-east-1.amazonaws.com`.
Auf dieser Seite werden die Basis-Image-Typen und Anforderungen für die Erstellung von Lambda-kompatiblen Container-Images erläutert.
**Anmerkung**
Sie können den [Bereitstellungspakettyp](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip oder Container-Image) für eine vorhandene Funktion nicht ändern. Sie können zum Beispiel eine Container-Image-Funktion nicht so umwandeln, dass sie ein .zip-Archiv verwendet. Sie müssen eine neue Funktion erstellen.
**Topics**
+ [
## Voraussetzungen
](#images-reqs)
+ [
## Verwenden eines AWS Basis-Images für Lambda
](#runtimes-images-lp)
+ [
## Es wird ein AWS reines Betriebssystem-Basis-Image verwendet
](#runtimes-images-provided)
+ [
## Verwenden eines AWS Nicht-Base-Images
](#images-types)
+ [
## Laufzeitschnittstellen-Clients
](#images-ric)
+ [
## Amazon-ECR-Berechtigungen
](#gettingstarted-images-permissions)
+ [
## Lebenszyklus der Funktion
](#images-lifecycle)
## Voraussetzungen
Installieren Sie die [AWS CLI -Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) und die [Docker-CLI](https://docs.docker.com/get-docker). Beachten Sie außerdem die folgenden Anforderungen:
+ Das Container-Image muss die [Verwenden der Lambda-Laufzeit-API für benutzerdefinierte Laufzeiten](runtimes-api.md) implementieren. Die AWS Open-Source-[Laufzeitschnittstellen-Clients](#images-ric) implementieren die API. Sie können Ihrem bevorzugten Basis-Image einen Laufzeitschnittstellen-Client hinzufügen, damit es mit Lambda kompatibel ist.
+ Das Container-Image muss auf einem schreibgeschützten Dateisystem laufen können. Ihr Funktionscode kann auf ein beschreibbares `/tmp`-Verzeichnis mit einem Speicherplatz zwischen 512 MB bis 10 240 MB, in 1-MB-Schritten, zugreifen.
+ Der Lambda-Standardbenutzer muss in der Lage sein, alle Dateien zu lesen, die zum Ausführen Ihres Funktionscodes erforderlich sind. Lambda folgt den bewährten Methoden für die Sicherheit, indem es einen Standard-Linux-Benutzer mit den geringsten Berechtigungen definiert. Das bedeutet, dass Sie in Ihrem Dockerfile keinen [BENUTZER](https://docs.docker.com/reference/dockerfile/#user) angeben müssen. Stellen Sie sicher, dass Ihr Anwendungscode nicht auf Dateien angewiesen ist, von denen andere Linux-Benutzer nicht ausgeführt werden können.
+ Lambda unterstützt nur Linux-basierte Container-Images.
+ Lambda bietet Multi-Architektur-Basis-Images. Das Image, das Sie für Ihre Funktion erstellen, muss jedoch nur auf eine der Architekturen abzielen. Lambda unterstützt keine Funktionen, die Container-Images mit mehreren Architekturen verwenden.
## Verwenden eines AWS Basis-Images für Lambda
Sie können eines der [AWS -Basis-Images](https://gallery.ecr.aws/lambda/) für Lambda verwenden, um das Container-Image für Ihren Funktionscode zu erstellen. Die Basis-Images sind mit einer Sprachlaufzeit und anderen Komponenten vorgeladen, die zum Ausführen eines Container-Images in Lambda erforderlich sind. Sie fügen Ihren Funktionscode und Ihre Abhängigkeiten dem Basis-Image hinzu und verpacken es dann als Container-Image.
AWS stellt regelmäßig Updates für die AWS Basis-Images für Lambda bereit. Wenn Ihr Dockerfile den Image-Namen in der FROM-Eigenschaft enthält, ruft Ihr Docker-Client die aktuelle Version des Images aus dem [Amazon-ECR-Repository](https://gallery.ecr.aws/lambda/) ab.. Um das aktualisierte Basis-Image verwenden zu können, müssen Sie Ihr Container-Image neu erstellen und [den Funktionscode aktualisieren](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html).
Die Basis-Images Node.js 20, Python 3.12, Java 21, .NET 8, Ruby 3.3 und höher basieren auf dem [minimalen Container-Image von Amazon Linux 2023](https://docs.aws.amazon.com/linux/al2023/ug/minimal-container.html). Frühere Basis-Images verwenden Amazon Linux 2. AL2023 bietet mehrere Vorteile gegenüber Amazon Linux 2, darunter einen geringeren Bereitstellungsaufwand und aktualisierte Versionen von Bibliotheken wie`glibc`.
AL2023-basierte Images verwenden `microdnf` (`dnf`symbolisiert als) als Paketmanager anstelle von`yum`, dem Standard-Paketmanager in Amazon Linux 2. `microdnf`ist eine eigenständige Implementierung von. `dnf` Eine Liste der Pakete, die in AL2023 basierten Images enthalten sind, finden Sie in den Spalten **Minimal Container** unter [Comparing packages installed on Amazon Linux 2023 Container Images](https://docs.aws.amazon.com/linux/al2023/ug/al2023-container-image-types.html). Weitere Informationen zu den Unterschieden zwischen Amazon Linux 2 AL2023 und Amazon Linux 2 finden Sie unter [Einführung in die Amazon Linux 2023 Runtime for AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/) im AWS Compute-Blog.
**Anmerkung**
Um AL2023 basierte Images lokal auszuführen, auch mit AWS Serverless Application Model (AWS SAM), müssen Sie Docker-Version 20.10.10 oder höher verwenden.
Um ein Container-Image mit einem AWS Basis-Image zu erstellen, wählen Sie die Anweisungen für Ihre bevorzugte Sprache aus:
+ [Node.js](nodejs-image.md#nodejs-image-instructions)
+ [TypeScript](typescript-image.md#base-image-typescript)(verwendet ein Node.js -Basisimage)
+ [Python](python-image.md#python-image-instructions)
+ [Java](java-image.md#java-image-instructions)
+ [Go](go-image.md#go-image-provided)
+ [.NET](csharp-image.md#csharp-image-instructions)
+ [Ruby](ruby-image.md#ruby-image-instructions)
## Es wird ein AWS reines Betriebssystem-Basis-Image verwendet
[AWS Basis-Images nur für Betriebssysteme](https://gallery.ecr.aws/lambda/provided) enthalten eine Amazon Linux-Distribution und den [Runtime-Interface-Emulator](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Diese Images werden häufig verwendet, um Container-Images für kompilierte Sprachen wie [Go](go-image.md#go-image-provided) und [Rust](lambda-rust.md) sowie für eine Sprache oder Sprachversion zu erstellen, für die Lambda kein Basis-Image bereitstellt, wie Node.js 19. Sie können reine OS-Basis-Images auch verwenden, um eine [benutzerdefinierte Laufzeit](runtimes-custom.md) zu implementieren. Um das Image mit Lambda kompatibel zu machen, müssen Sie den [Laufzeitschnittstellen-Client](#images-ric) für Ihre Sprache in das Image aufnehmen.
| Tags (Markierungen) | Laufzeit | Betriebssystem | Dockerfile | Ablehnung |
| --- | --- | --- | --- | --- |
| al2023 | Reine OS-Laufzeit | Amazon Linux 2023 | [Dockerfile für reine Betriebssystem-Runtime on 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 |
Öffentliche Galerie von Amazon Elastic Container Registry: [gallery.ecr. aws/lambda/provided](https://gallery.ecr.aws/lambda/provided)
## Verwenden eines AWS Nicht-Base-Images
Lambda unterstützt jedes Image, das einem der folgenden Image-Manifestformate entspricht:
+ Docker Image Manifest V2 Schema 2 (mit Docker-Version 1.10 und neuer)
+ Open Container Initiative (OCI)-Spezifikationen (v1.0.0 und höher)
Lambda unterstützt eine maximale unkomprimierte Image-Größe von 10 GB, einschließlich aller Ebenen.
**Anmerkung**
Um das Image mit Lambda kompatibel zu machen, müssen Sie den [Laufzeitschnittstellen-Client](#images-ric) für Ihre Sprache in das Image aufnehmen.
Für eine optimale Leistung sollte die Größe Ihres Bildmanifests unter 25 400 Byte liegen. Um die Größe des Bildmanifests zu reduzieren, minimieren Sie die Anzahl der Ebenen in Ihrem Bild und reduzieren Sie Anmerkungen.
## Laufzeitschnittstellen-Clients
Wenn Sie ein [reines OS-Basis-Image](#runtimes-images-provided) oder ein alternatives Basis-Image verwenden, müssen Sie den Laufzeitschnittstellen-Client in das Image einbinden. Der Runtime-Interface-Client muss den erweitern[Verwenden der Lambda-Laufzeit-API für benutzerdefinierte Laufzeiten](runtimes-api.md), der die Interaktion zwischen Lambda und Ihrem Funktionscode verwaltet. AWS stellt Open-Source-Runtime-Interface-Clients für die folgenden Sprachen bereit:
+ [Node.js](nodejs-image.md#nodejs-image-clients)
+ [Python](python-image.md#python-image-clients)
+ [Java](java-image.md#java-image-clients)
+ [.NET](csharp-image.md#csharp-image-clients)
+ [Go](go-image.md#go-image-clients)
+ [Ruby](ruby-image.md#ruby-image-clients)
+ [Rust](lambda-rust.md) —
Wenn Sie eine Sprache verwenden, für die kein Runtime-Interface-Client AWS zur Verfügung steht, müssen Sie Ihren eigenen erstellen.
## Amazon-ECR-Berechtigungen
Bevor Sie eine Lambda-Funktion aus einem Container-Image erstellen, müssen Sie das Image lokal erstellen und es in ein Amazon-ECR-Repository hochladen. Geben Sie beim Erstellen der Funktion den URI des Amazon-ECR-Repositorys an.
Stellen Sie sicher, dass die Berechtigungen für den Benutzer oder die Rolle, die die Funktion erstellt`GetRepositoryPolicy`, `SetRepositoryPolicy``BatchGetImage`, und `GetDownloadUrlForLayer` beinhalten.
Verwenden Sie beispielsweise die IAM-Konsole, um eine Rolle mit der folgenden Richtlinie zu erstellen:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"ecr:SetRepositoryPolicy",
"ecr:GetRepositoryPolicy",
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world"
}
]
}
```
------
### Richtlinien für das Amazon-ECR-Repository
Für eine Funktion im selben Konto wie das Container-Image in Amazon ECR können Sie Ihrem Amazon-ECR-Repository die Berechtigungen `ecr:BatchGetImage` und `ecr:GetDownloadUrlForLayer` hinzufügen. Das folgende Beispiel zeigt die Mindestrichtlinie:
```
{
"Sid": "LambdaECRImageRetrievalPolicy",
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
]
}
```
Weitere Informationen zu Amazon-ECR-Repository-Berechtigungen finden Sie unter [Private Repository-Richtlinien](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policies.html) im *Benutzerhandbuch zu Amazon Elastic Container Registry*.
Wenn das Amazon-ECR-Repository diese Berechtigungen nicht enthält, versucht Lambda, sie automatisch hinzuzufügen. Lambda kann Berechtigungen nur hinzufügen, wenn der Lambda aufrufende Prinzipal über `ecr:getRepositoryPolicy`- und `ecr:setRepositoryPolicy`-Berechtigungen verfügt.
Um Ihre Repository-Berechtigungen für Amazon ECR anzuzeigen oder zu bearbeiten, befolgen Sie die Anweisungen unter [Festlegung einer privaten Repository-Richtlinienanweisung](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html) im *Benutzerhandbuch zu Amazon Elastic Container Registry*.
#### Kontoübergreifende Berechtigungen von Amazon ECR
Ein anderes Konto in derselben Region kann eine Funktion erstellen, die ein Container-Image verwendet, das Ihrem Konto gehört. Im folgenden Beispiel benötigt die [Berechtigungsrichtlinie Ihres Amazon-ECR-Repository](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html) die folgenden Anweisungen, um den Zugriff auf Kontonummer 123456789012 zu gewähren.
+ **CrossAccountPermission**— Ermöglicht dem Konto 123456789012 das Erstellen und Aktualisieren von Lambda-Funktionen, die Bilder aus diesem ECR-Repository verwenden.
+ **Lambda ECRImage CrossAccountRetrievalPolicy** — Lambda setzt den Status einer Funktion irgendwann auf inaktiv, wenn sie über einen längeren Zeitraum nicht aufgerufen wird. Diese Anweisung ist erforderlich, damit Lambda das Container-Image zur Optimierung und Zwischenspeicherung im Namen der Funktion abrufen kann, die 123456789012 besitzt.
**Example – Ihrem Repository kontoübergreifende Berechtigungen hinzufügen**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CrossAccountPermission",
"Effect": "Allow",
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Principal": {
"AWS": "arn:aws:iam::123456789012:root"
},
"Resource": "arn:aws:ecr:us-east-1:123456789012:repository/example-lambda-repository"
},
{
"Sid": "LambdaECRImageCrossAccountRetrievalPolicy",
"Effect": "Allow",
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Condition": {
"ArnLike": {
"aws:sourceARN": "arn:aws:lambda:us-east-1:123456789012:function:*"
}
},
"Resource": "arn:aws:ecr:us-east-1:123456789012:repository/example-lambda-repository"
}
]
}
```
Um Zugriff auf mehrere Konten zu gewähren, fügen Sie das Konto der IDs Principal-Liste in der `CrossAccountPermission` Policy und der Condition-Bewertungsliste in der hinzu. `LambdaECRImageCrossAccountRetrievalPolicy`
Wenn Sie mit mehreren Konten in einer AWS Organisation arbeiten, empfehlen wir, dass Sie jede Konto-ID in der ECR-Berechtigungsrichtlinie auflisten. Dieser Ansatz entspricht der bewährten AWS Sicherheitsmethode, enge Berechtigungen in IAM-Richtlinien festzulegen.
Zusätzlich zu den Lambda-Berechtigungen muss der Benutzer oder die Rolle, der/die die Funktion erstellt, auch über `BatchGetImage`- und `GetDownloadUrlForLayer`-Berechtigungen verfügen.
## Lebenszyklus der Funktion
Nachdem Sie ein neues oder aktualisiertes Container-Image hochgeladen haben, optimiert Lambda das Image, bevor die Funktion Aufrufe verarbeiten kann. Der Optimierungsprozess kann einige Sekunden dauern. Die Funktion verbleibt im Zustand `Pending`, bis der Prozess abgeschlossen ist, dann geht der Zustand in `Active` über. Sie können die Funktion erst dann aufrufen, wenn sie den `Active`-Zustand erreicht hat.
Wenn eine Funktion mehrere Wochen lang nicht aufgerufen wird, gewinnt Lambda seine optimierte Version zurück und die Funktion wechselt in den `Inactive`-Zustand. Um die Funktion wieder zu aktivieren, müssen Sie sie aufrufen. Lambda lehnt den ersten Aufruf ab und die Funktion tritt in den `Pending`-Zustand, bis Lambda das Image neu optimiert. Die Funktion kehrt dann zum `Active`-Zustand zurück.
Lambda ruft regelmäßig das zugehörige Container-Image aus dem Amazon ECR Repository ab. Wenn das entsprechende Container-Image in Amazon ECR nicht mehr vorhanden ist oder Berechtigungen widerrufen werden, wechselt die Funktion in den `Failed`-Zustand und Lambda gibt einen Fehler für alle Funktionsaufrufe zurück.
Sie können die Lambda-API verwenden, um Informationen über den Zustand einer Funktion abzurufen. Weitere Informationen finden Sie unter [Lambda-Funktionszustände](functions-states.md).
# Konfigurieren Sie den Speicher der Lambda-Funktion
Lambda weist die Rechenleistung proportional zur Menge des konfigurierten Arbeitsspeichers zu. *Arbeitsspeicher* ist die Menge an Arbeitsspeicher, die Ihrer Lambda-Funktion zur Laufzeit zur Verfügung steht. Sie können den Arbeitsspeicher und die CPU-Leistung, die Ihrer Funktion zugewiesen sind, mit der Einstellung **Arbeitsspeicher** erhöhen oder verringern. Sie können Speicher zwischen 128 MB und 10 240 MB in 1-MB-Schritten konfigurieren. Bei 1.769 MB weist eine Funktion das Äquivalent einer vCPU auf (eine vCPU-Sekunde Guthaben pro Sekunde).
Auf dieser Seite wird beschrieben, wie und wann die Speichereinstellung für eine Lambda-Funktion aktualisiert werden muss.
**Topics**
+ [
## Ermitteln der geeigneten Speichereinstellung für eine Lambda-Funktion
](#configuration-memory-use-cases)
+ [
## Konfigurieren des Funktionsspeichers (Konsole)
](#configuration-memory-console)
+ [
## Konfiguration des Funktionsspeichers (AWS CLI)
](#configuration-memory-cli)
+ [
## Konfiguration des Funktionsspeichers (AWS SAM)
](#configuration-memory-sam)
+ [
## Akzeptieren von Empfehlungen für den Funktionsspeicher (Konsole)
](#configuration-memory-optimization-accept)
## Ermitteln der geeigneten Speichereinstellung für eine Lambda-Funktion
Der Speicher ist der wichtigste Hebel zur Steuerung der Ausführung einer Funktion. Die Standardeinstellung, 128 MB, ist die niedrigste mögliche Einstellung. Wir empfehlen, nur 128 MB für einfache Lambda-Funktionen zu verwenden, z. B. solche, die Ereignisse transformieren und an andere AWS -Dienste weiterleiten. Eine höhere Speicherzuweisung kann die Leistung von Funktionen verbessern, die importierte Bibliotheken, [Lambda-Ebenen](chapter-layers.md), Amazon Simple Storage Service (Amazon S3) oder Amazon Elastic File System (Amazon EFS) verwenden. Durch die Erweiterung des Arbeitsspeichers erhöht sich proportional die Anzahl der CPUs, wodurch die verfügbare Rechenleistung insgesamt steigt. Wenn eine Funktion an die CPU, das Netzwerk oder den Speicher gebunden ist, kann eine Erhöhung der Speichereinstellung die Leistung erheblich verbessern.
Um die richtige Speicherkonfiguration zu finden, überwachen Sie Ihre Funktionen mit Amazon CloudWatch und stellen Sie Alarme ein, wenn sich der Speicherverbrauch den konfigurierten Höchstwerten nähert. Dies kann helfen, speichergebundene Funktionen zu identifizieren. Bei CPU-gebundenen und IO-gebundenen Funktionen kann die Überwachung der Dauer auch zu Erkenntnissen führen. In diesen Fällen kann eine Erhöhung des Speichers dazu beitragen, die Rechen- oder Netzwerkengpässe zu beheben.
Sie können auch die Verwendung des Open-Source-Tools [AWS Lambda Power Tuning](https://github.com/alexcasalboni/aws-lambda-power-tuning) in Betracht ziehen. Dieses Tool verwendet AWS Step Functions , um mehrere gleichzeitige Versionen einer Lambda-Funktion an unterschiedlichen Speicherzuweisungen auszuführen und die Leistung zu messen. Die Eingabefunktion wird in Ihrem AWS Konto ausgeführt und führt Live-HTTP-Aufrufe und SDK-Interaktionen durch, um die wahrscheinliche Leistung in einem Live-Produktionsszenario zu messen. Sie können auch einen CI/CD Prozess implementieren, um dieses Tool zur automatischen Messung der Leistung neuer Funktionen zu verwenden, die Sie bereitstellen.
## Konfigurieren des Funktionsspeichers (Konsole)
Sie können den Speicher Ihrer Funktion in der Lambda-Konsole konfigurieren.
**So aktualisieren Sie den Speicher einer Funktion**
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 **General configuration** (Allgemeine Konfiguration).
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/configuration-tab.png)
1. Wählen Sie unter **General configuration** (allgemeine Konfiguration) **Bearbeiten**.
1. Legen Sie für **Arbeitsspeicher** einen Wert von 128 MB bis 10.240 MB fest.
1. Wählen Sie **Speichern**.
## Konfiguration des Funktionsspeichers (AWS CLI)
Sie können den [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html)Befehl verwenden, um den Speicher Ihrer Funktion zu konfigurieren.
**Example**
```
aws lambda update-function-configuration \
--function-name my-function \
--memory-size 1024
```
## Konfiguration des Funktionsspeichers (AWS SAM)
Sie können den [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) verwenden, um den Speicher für Ihre Funktion zu konfigurieren. Aktualisieren Sie die [MemorySize](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-memorysize)Eigenschaft in Ihrer `template.yaml` Datei und führen Sie dann [sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) aus.
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 1024
# Other function properties...
```
## Akzeptieren von Empfehlungen für den Funktionsspeicher (Konsole)
Wenn Sie Administratorrechte in AWS Identity and Access Management (IAM) haben, können Sie sich dafür entscheiden, Empfehlungen für Lambda-Funktionsspeichereinstellungen von zu erhalten. AWS Compute Optimizer Anweisungen dazu, wie Sie Speicherempfehlungen für Ihr Konto oder Ihr Unternehmen aktivieren, finden Sie unter [Aktivieren Ihres Kontos](https://docs.aws.amazon.com/compute-optimizer/latest/ug/getting-started.html#account-opt-in) im *AWS Compute Optimizer -Benutzerhandbuch*.
**Anmerkung**
Compute Optimizer unterstützt nur Funktionen, die die x86\$164-Architektur verwenden.
Wenn Sie sich angemeldet haben und Ihre [Lambda-Funktion die Anforderungen von Compute Optimizer erfüllt](https://docs.aws.amazon.com/compute-optimizer/latest/ug/requirements.html#requirements-lambda-functions), können Sie Empfehlungen zum Funktionsspeicher von Compute Optimizer in der Lambda-Konsole unter **Allgemeine Konfiguration** anzeigen und akzeptieren.
# Flüchtiger Speicher für Lambda-Funktionen konfigurieren
Lambda bietet flüchtigen Speicher für Funktionen im `/tmp`-Verzeichnis. Dieser Speicher ist temporär und für jede Ausführungsumgebung einzigartig. Sie können die Menge des flüchtigen Speichers, der Ihrer Funktion zugewiesen ist, mithilfe der Einstellung **Flüchtiger Speicher** steuern. Sie können den flüchtigen Speicher zwischen 512 MB und 10.240 MB in 1-MB-Schritten konfigurieren. Alle in `/tmp` gespeicherten Daten werden im Ruhezustand mit einem von AWS-verwalteten Schlüssel verschlüsselt.
Auf dieser Seite werden allgemeine Anwendungsfälle und die Aktualisierung des kurzlebigen Speichers für eine Lambda-Funktion beschrieben.
**Topics**
+ [
## Häufige Anwendungsfälle für flüchtiger Speicher
](#configuration-ephemeral-storage-use-cases)
+ [
## Flüchtigen Speicher konfigurieren (Konsole)
](#configuration-ephemeral-storage-console)
+ [
## Konfigurierbarer flüchtiger Speicher (AWS CLI)
](#configuration-ephemeral-storage-cli)
+ [
## Konfigurierbarer flüchtiger Speicher (AWS SAM)
](#configuration-ephemeral-storage-sam)
## Häufige Anwendungsfälle für flüchtiger Speicher
Im Folgenden sind einige häufig vorkommende Anwendungsfälle aufgeführt, die von einem erhöhten flüchtigen Speicher profitieren:
+ **Extract-transform-load (ETL-) Jobs:** Erhöhen Sie den temporären Speicher, wenn Ihr Code Zwischenberechnungen durchführt oder andere Ressourcen herunterlädt, um die Verarbeitung abzuschließen. Mehr temporärer Speicherplatz ermöglicht die Ausführung komplexerer ETL-Jobs in Lambda-Funktionen.
+ **Inferenz durch Machine Learning(ML):** Viele Inferenzaufgaben basieren auf großen Referenzdatendateien, einschließlich Bibliotheken und Modellen. Mit mehr ephemerem Speicher können Sie größere Modelle vom Amazon Simple Storage Service (Amazon S3) auf `/tmp` herunterladen und in Ihrer Verarbeitung verwenden.
+ **Datenverarbeitung:** Bei Workloads, die Objekte von Amazon S3 als Reaktion auf S3-Ereignisse herunterladen, ermöglicht mehr `/tmp`-Speicherplatz die Verarbeitung größerer Objekte ohne In-Memory-Verarbeitung. Workloads, bei denen Medien erstellt PDFs oder verarbeitet werden, profitieren ebenfalls von kurzlebiger Speicherung.
+ **Grafikverarbeitung:** Die Bildverarbeitung ist ein häufiger Anwendungsfall für Lambda-basierte Anwendungen. Bei Workloads, die große TIFF-Dateien oder Satellitenbilder verarbeiten, erleichtert ein kurzlebigerer Speicher die Verwendung von Bibliotheken und die Durchführung der Berechnung in Lambda.
## Flüchtigen Speicher konfigurieren (Konsole)
Flüchtiger Speicher können Sie in der Lambda-Konsole konfigurieren.
**So ändern Sie den flüchtigen Speicher für eine Funktion**
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 **General configuration** (Allgemeine Konfiguration).
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/configuration-tab.png)
1. Wählen Sie unter **General configuration** (allgemeine Konfiguration) **Bearbeiten**.
1. Legen Sie für den **flüchtigen Speicher** einen Wert zwischen 512 MB und 10.240 MB fest, in 1-MB-Schritten.
1. Wählen Sie **Speichern**.
## Konfigurierbarer flüchtiger Speicher (AWS CLI)
Sie können den [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html)Befehl verwenden, um kurzlebigen Speicher zu konfigurieren.
**Example**
```
aws lambda update-function-configuration \
--function-name my-function \
--ephemeral-storage '{"Size": 1024}'
```
## Konfigurierbarer flüchtiger Speicher (AWS SAM)
Sie können den [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) verwenden, um den flüchtigen Speicher für Ihre Funktion zu konfigurieren. Aktualisieren Sie die [EphemeralStorage](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-ephemeralstorage)Eigenschaft in Ihrer `template.yaml` Datei und führen Sie dann [sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) aus.
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 128
Timeout: 120
Handler: index.handler
Runtime: nodejs22.x
Architectures:
- x86_64
EphemeralStorage:
Size: 10240
# Other function properties...
```
# Auswahl und Konfiguration einer Befehlssatzarchitektur für Ihre Lambda-Funktion
Die*-Befehlssatz-Architektur*einer Lambda-Funktion bestimmt den Typ des Computerprozessors, den Lambda zum Ausführen der Funktion verwendet. Lambda bietet eine Auswahl an Befehlssatz-Architekturen:
+ arm64 — 64-Bit-ARM-Architektur für den AWS Graviton2-Prozessor.
+ x86\$164 — 64-Bit-x86-Architektur für x86-basierte Prozessoren.
**Anmerkung**
Die arm64-Architektur ist in den meisten Versionen verfügbar. AWS-Regionen Weitere Informationen finden Sie unter [AWS Lambda – Preise](https://aws.amazon.com//lambda/pricing/#aws-element-9ccd9262-b656-4d9c-8a72-34ee6b662135). Wählen Sie in der Tabelle mit den Speicherpreisen die Registerkarte **Arm-Preis** aus und öffnen Sie dann die Dropdownliste **Region**, um zu sehen, welche Produkte arm64 mit Lambda AWS-Regionen unterstützen.
Ein Beispiel für die Erstellung einer Funktion mit der Arm64-Architektur finden Sie unter [AWS Lambda Funktionen, die vom Graviton2-Prozessor unterstützt werden](https://aws.amazon.com/blogs/aws/aws-lambda-functions-powered-by-aws-graviton2-processor-run-your-functions-on-arm-and-get-up-to-34-better-price-performance/). AWS
**Topics**
+ [
## Vorteile der Verwendung von arm64-Architektur
](#foundation-arch-adv)
+ [
## Anforderungen für die Migration zur arm64-Architektur
](#foundation-arch-consider)
+ [
## Funktionscode-Kompatibilität mit arm64-Architektur
](#foundation-arch-considerations)
+ [
## Migration zur arm64-Architektur
](#foundation-arch-steps)
+ [
## Konfigurieren der Befehlssatz-Architektur
](#foundation-arch-config)
## Vorteile der Verwendung von arm64-Architektur
Lambda-Funktionen, die die Arm64-Architektur (AWS Graviton2-Prozessor) verwenden, können einen deutlich besseren Preis und eine deutlich bessere Leistung erzielen als die entsprechende Funktion, die auf der x86\$164-Architektur ausgeführt wird. Erwägen Sie, arm64 für rechenintensive Anwendungen wie Hochleistungsrechnen, Videocodierung und Simulations-Workloads zu verwenden.
Die Graviton2-CPU verwendet den Neoverse N1-Kern und unterstützt Armv8.2 (einschließlich CRC- und Krypto-Erweiterungen) sowie mehrere andere architektonische Erweiterungen.
Graviton2 reduziert die Lesezeit des Speichers, indem es einen größeren L2-Cache pro vCPU bereitstellt, was die Latenzleistung von Web- und Mobile-Backends, Microservices und Datenverarbeitungssystemen verbessert. Graviton2 bietet auch eine verbesserte Verschlüsselungsleistung und unterstützt Befehlssätze, die die Latenz von CPU-basierten Inferenzen für Machine Learning verbessern.
[Weitere Informationen zu Graviton2 finden Sie unter Graviton Processor. AWSAWS](https://aws.amazon.com/ec2/graviton)
## Anforderungen für die Migration zur arm64-Architektur
Wenn Sie eine Lambda-Funktion für die Migration zur arm64-Architektur auswählen, stellen Sie sicher, dass Ihre Funktion die folgenden Anforderungen erfüllt, um eine reibungslose Migration zu gewährleisten:
+ Das Bereitstellungspaket enthält nur Open-Source-Komponenten und Quellcode, die Sie steuern, sodass Sie alle notwendigen Updates für die Migration vornehmen können.
+ Wenn der Funktionscode Abhängigkeiten von Drittanbietern enthält, bietet jede Bibliothek oder jedes Paket eine arm64-Version.
## Funktionscode-Kompatibilität mit arm64-Architektur
Ihr Lambda-Funktionscode muss mit der Befehlssatz-Architektur der Funktion kompatibel sein. Bevor Sie eine Funktion zur arm64-Architektur migrieren, beachten Sie die folgenden Punkte zum aktuellen Funktionscode:
+ Wenn Sie Ihren Funktionscode mit dem eingebetteten Code-Editor hinzugefügt haben, läuft Ihr Code wahrscheinlich auf beiden Architekturen ohne Änderung.
+ Nach dem Upload Ihres Funktionscodes, müssen Sie neuen Code uploaden, der mit Ihrer Zielarchitektur kompatibel ist.
+ Wenn Ihre Funktion Layer verwendet, müssen Sie[überprüfe jede Ebene](adding-layers.md#finding-layer-information)um sicherzustellen, dass es mit der neuen Architektur kompatibel ist. Wenn ein Layer nicht kompatibel ist, bearbeiten Sie die Funktion, um die aktuelle Layer-Version durch eine kompatible Layer-Version zu ersetzen.
+ Wenn Ihre Funktion Lambda-Erweiterungen verwendet, müssen Sie jede Erweiterung überprüfen, um sicherzustellen, dass sie mit der neuen Architektur kompatibel ist.
+ Wenn Ihre Funktion einen Container-Image-Bereitstellungspakettyp verwendet, müssen Sie ein neues Container-Image erstellen, das mit der Architektur der Funktion kompatibel ist.
## Migration zur arm64-Architektur
Um eine Lambda-Funktion auf die arm64-Architektur zu migrieren, empfehlen wir die folgenden Schritte:
1. Erstellen Sie die Liste der Abhängigkeiten für Ihre Anwendung oder Ihren Workload. Häufige Abhängigkeiten sind unter anderem:
+ Alle Bibliotheken und Pakete, die die Funktion verwendet.
+ Die Tools, mit denen Sie die Funktion erstellen, bereitstellen und testen, wie Compiler, Test-Suites, Pipelines für Continuous Integration und Continuous Delivery (CI/CD), Bereitstellungstools und Skripte.
+ Die Lambda-Erweiterungen und Tools von Drittanbietern, mit denen Sie die Funktion in der Produktion überwachen.
1. Überprüfen Sie für jede der Abhängigkeiten die Version und prüfen Sie dann, ob arm64-Versionen verfügbar sind.
1. Erstellen Sie eine Umgebung, um Ihre Anwendung zu migrieren.
1. Bootstrap die Anwendung.
1. Testen und debuggen Sie die Anwendung.
1. Testen Sie die Leistung der arm64-Funktion. Vergleichen Sie die Leistung mit der x86\$164-Version.
1. Aktualisieren Sie Ihre Infrastruktur-Pipeline, um arm64 Lambda-Funktionen zu unterstützen.
1. Stufen Sie Ihre Bereitstellung in die Produktion ein.
Verwenden Sie zum Beispiel [Alias-Routing-Konfiguration](configuring-alias-routing.md) um den Datenverkehr zwischen den Versionen x86 und arm64 der Funktion aufzuteilen und die Leistung und Latenz zu vergleichen.
Weitere Informationen zum Erstellen einer Codeumgebung für die arm64-Architektur, einschließlich sprachspezifischer Informationen für Java, Go, .NET und Python, finden Sie im Repository [Erste Schritte mit AWS](https://github.com/aws/aws-graviton-getting-started) Graviton. GitHub
## Konfigurieren der Befehlssatz-Architektur
Sie können die Befehlssatzarchitektur für neue und bestehende Lambda-Funktionen mithilfe der Lambda-Konsole, AWS SDKs, AWS Command Line Interface (AWS CLI) oder konfigurieren. CloudFormation Führen Sie die folgenden Schritte aus, um die Befehlssatzarchitektur für eine vorhandene Lambda-Funktion von der Konsole aus zu ändern.
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Klicken Sie auf den Namen der Funktion, für die Sie die Befehlssatzarchitektur konfigurieren möchten.
1. Wählen Sie auf der Registerkarte **Code** für den Abschnitt **Laufzeiteinstellungen** die Option **Bearbeiten** aus.
1. Unter **Architecture (Architektur)** wählen Sie die Befehlssatzarchitektur aus, die Ihre Funktion verwenden soll.
1. Wählen Sie **Speichern**.
# Zeitüberschreitung der Lambda-Funktion konfigurieren
Lambda führt Ihren Code für eine festgelegte Zeitspanne aus, bevor ein Timeout erfolgt. Beim *Timeout* handelt es sich um die maximale Zeitspanne in Sekunden, die eine Lambda-Funktion ausgeführt werden kann. Der Standardwert für diese Einstellung ist 3 Sekunden. Sie können ihn jedoch in Schritten von 1 Sekunde bis zu einem Höchstwert von 900 Sekunden (15 Minuten) anpassen.
Auf dieser Seite wird beschrieben, wie und wann die Timeout-Einstellung für eine Lambda-Funktion aktualisiert werden muss.
**Topics**
+ [
## Ermitteln des geeigneten Timeout-Werts für eine Lambda-Funktion
](#configuration-timeout-use-cases)
+ [
## Konfigurieren des Timeouts (Konsole)
](#configuration-timeout-console)
+ [
## Timeout konfigurieren (AWS CLI)
](#configuration-timeout-cli)
+ [
## Timeout konfigurieren (AWS SAM)
](#configuration-timeout-sam)
## Ermitteln des geeigneten Timeout-Werts für eine Lambda-Funktion
Wenn der Timeout-Wert nahe an der durchschnittlichen Dauer einer Funktion liegt, besteht ein höheres Risiko, dass die Funktion unerwartet beendet wird. Die Dauer einer Funktion kann je nach Umfang der Datenübertragung und -verarbeitung sowie der Latenz aller Dienste, mit denen die Funktion interagiert, variieren. Zu den häufigsten Ursachen für Timeouts gehören:
+ Downloads von Amazon Simple Storage Service (Amazon S3) sind größer oder dauern länger als der Durchschnitt.
+ Eine Funktion sendet eine Anfrage an einen anderen Service, dessen Beantwortung länger dauert.
+ Die einer Funktion zur Verfügung gestellten Parameter erfordern eine höhere Rechenkomplexität in der Funktion, wodurch der Aufruf länger dauert.
Stellen Sie beim Testen Ihrer Anwendung sicher, dass Ihre Tests die Größe und Menge der Daten sowie realistische Parameterwerte genau wiedergeben. Tests verwenden aus Gründen der Benutzerfreundlichkeit häufig kleine Stichproben. Sie sollten jedoch Datensätze verwenden, die sich an der Obergrenze dessen befinden, was für Ihren Workload vernünftigerweise zu erwarten ist.
## Konfigurieren des Timeouts (Konsole)
Sie können das Funktions-Timeout in der Lambda-Konsole konfigurieren.
**So ändern Sie das Timeout für eine Funktion**
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 **General configuration** (Allgemeine Konfiguration).
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/configuration-tab.png)
1. Wählen Sie unter **General configuration** (allgemeine Konfiguration) **Bearbeiten**.
1. Für **Timeout** stellen Sie einen Wert zwischen 1 und 900 Sekunden (15 Minuten) ein.
1. Wählen Sie **Speichern**.
## Timeout konfigurieren (AWS CLI)
Sie können den [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html)Befehl verwenden, um den Timeout-Wert in Sekunden zu konfigurieren. Der folgende Beispielbefehl erhöht das Funktions-Timeout auf 120 Sekunden (2 Minuten).
**Example**
```
aws lambda update-function-configuration \
--function-name my-function \
--timeout 120
```
## Timeout konfigurieren (AWS SAM)
Sie können den [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) verwenden, um den Timeout-Wert in Sekunden zu konfigurieren. Aktualisieren Sie die Eigenschaft [Timeout](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-timeout) in Ihrer `template.yaml`-Datei und führen Sie dann [sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) aus.
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 128
Timeout: 120
# Other function properties...
```
# Dauerhafte Lambda-Funktionen konfigurieren
Um eine dauerhafte Ausführung Ihrer Lambda-Funktion zu ermöglichen, müssen Sie spezifische Einstellungen konfigurieren, die steuern, wie lange Ihre Funktion ausgeführt werden kann, wie lange Statusdaten aufbewahrt werden und welche Berechtigungen erforderlich sind.
## Ermöglichen Sie eine dauerhafte Ausführung
Um eine dauerhafte Ausführung für Ihre Lambda-Funktion zu ermöglichen, konfigurieren Sie die `DurableConfig` in Ihrer Funktionskonfiguration. Diese Einstellung steuert das Ausführungstimeout, die Beibehaltung des Status und das Versionsverhalten.
------
#### [ AWS CLI ]
```
aws lambda update-function-configuration \
--function-name my-durable-function \
--durable-config '{
"ExecutionTimeout": 3600,
"RetentionPeriodInDays": 30,
"AllowInvokeLatest": true
}'
```
------
#### [ CloudFormation ]
```
Resources:
MyDurableFunction:
Type: AWS::Lambda::Function
Properties:
FunctionName: my-durable-function
Runtime: nodejs18.x
Handler: index.handler
Code:
ZipFile: |
// Your durable function code
DurableConfig:
ExecutionTimeout: 3600
RetentionPeriodInDays: 30
AllowInvokeLatest: true
```
------
**Konfigurationsparameter:**
+ `ExecutionTimeout`- Maximale Ausführungszeit in Sekunden (bis zu 31.536.000 für ein Jahr)
+ `RetentionPeriodInDays`- Wie lange sollen der Ausführungsstatus und der Ausführungsverlauf beibehalten werden (1—365 Tage)
+ `AllowInvokeLatest`- Ob der Aufruf der \$1LATEST-Version für eine dauerhafte Ausführung zulässig sein soll
## IAM-Berechtigungen für dauerhafte Funktionen
Dauerhafte Funktionen erfordern zusätzliche IAM-Berechtigungen, die über die standardmäßigen Lambda-Ausführungsrollen hinausgehen. Die Ausführungsrolle Ihrer Funktion muss Berechtigungen für die Statusverwaltung und die dauerhafte Ausführung beinhalten. APIs
**Erforderliche Mindestberechtigungen:**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction",
"lambda:GetFunction",
"lambda:ManageDurableState",
"lambda:GetDurableExecution",
"lambda:ListDurableExecutions"
],
"Resource": "arn:aws:lambda:*:*:function:*"
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:*"
}
]
}
```
**CloudFormation Beispiel für eine Ausführungsrolle:**
```
DurableFunctionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: sts:AssumeRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Policies:
- PolicyName: DurableFunctionPolicy
PolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Action:
- lambda:ManageDurableState
- lambda:GetDurableExecution
- lambda:ListDurableExecutions
Resource: '*'
```
## Bewährte Methoden für die Konfiguration
Folgen Sie diesen bewährten Methoden, wenn Sie langlebige Funktionen für den Produktionseinsatz konfigurieren:
+ **Legen Sie geeignete Ausführungszeitlimits** fest — Konfigurieren Sie sie auf der `ExecutionTimeout` Grundlage der maximal zu erwartenden Dauer Ihres Workflows. Legen Sie keine unnötig langen Timeouts fest, da sich diese auf die Kosten und die Ressourcenzuweisung auswirken.
+ Sorgen Sie für ein **ausgewogenes Verhältnis zwischen Aufbewahrung und Speicherkosten** — Legen Sie diese auf der `RetentionPeriodInDays` Grundlage Ihrer Debugging- und Prüfanforderungen fest. Längere Aufbewahrungsfristen erhöhen die Speicherkosten.
+ **Versionierung in der Produktion verwenden** — Wählen Sie `AllowInvokeLatest` diese Option `false` in Produktionsumgebungen aus und verwenden Sie spezifische Funktionsversionen oder Aliase für dauerhafte Ausführungen.
+ **Statusgröße überwachen** — Große Zustandsobjekte erhöhen die Speicherkosten und können die Leistung beeinträchtigen. Halten Sie den Status minimal und verwenden Sie externen Speicher für große Datenmengen.
+ **Konfigurieren Sie die entsprechende Protokollierung** — Aktivieren Sie die detaillierte Protokollierung zur Fehlerbehebung bei lang andauernden Workflows, achten Sie dabei jedoch auf das Protokollvolumen und die Kosten.
**Beispiel für eine Produktionskonfiguration:**
```
{
"ExecutionTimeout": 86400,
"RetentionPeriodInDays": 7,
"AllowInvokeLatest": false
}
```
# Arbeiten mit Lambda-Umgebungsvariablen
Sie können Umgebungsvariablen verwenden, um das Verhalten Ihrer Funktion anzupassen, ohne Code zu aktualisieren. Eine Umgebungsvariable ist ein Zeichenfolgenpaar, das in der versionsspezifischen Konfiguration einer Funktion gespeichert ist. Die Lambda-Laufzeit stellt Umgebungsvariablen für den Code zur Verfügung und legt zusätzliche Umgebungsvariablen mit Informationen über die Funktion und die Aufrufanforderung fest.
**Anmerkung**
Um die Sicherheit zu erhöhen, empfehlen wir, AWS Secrets Manager anstelle von Umgebungsvariablen Datenbankanmeldedaten und andere vertrauliche Informationen wie API-Schlüssel oder Autorisierungstoken zu speichern. Weitere Informationen finden Sie unter [Verwenden von Secrets-Manager-Secrets in Lambda-Funktionen](with-secrets-manager.md).
Umgebungsvariablen werden vor dem Funktionsaufruf nicht ausgewertet. Jeder von Ihnen definierte Wert wird als Literalzeichenfolge betrachtet und nicht erweitert. Führen Sie die Variablenauswertung in Ihrem Funktionscode durch.
## Erstellen von Lambda-Umgebungsvariablen
Sie können Umgebungsvariablen in Lambda mithilfe der Lambda-Konsole, der AWS Command Line Interface (AWS CLI), AWS Serverless Application Model (AWS SAM) oder mithilfe eines AWS SDK konfigurieren.
------
#### [ Console ]
Sie definieren Umgebungsvariablen für die unveröffentlichte Version Ihrer Funktion. Wenn Sie eine Version veröffentlichen, werden die Umgebungsvariablen für diese Version zusammen mit anderen [versionsspezifischen Konfigurationseinstellungen](configuration-versions.md) gesperrt.
Sie erstellen eine Umgebungsvariable für Ihre Funktion, indem Sie einen Schlüssel und einen Wert definieren. Ihre Funktion verwendet den Namen des Schlüssels, um den Wert der Umgebungsvariablen abzurufen.
**So legen Sie Umgebungsvariablen in der Lambda-Konsole fest**
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 den Tab **Configuration (Konfiguration)** und dann **Environment variables (Umgebungsvariablen)** aus.
1. Wählen Sie unter **Environment variables (Umgebungsvariablen)** die Option **Edit (Bearbeiten)**.
1. Wählen Sie **Umgebungsvariablen hinzufügen** aus.
1. Geben Sie einen Schlüssel und einen Wert ein.
**Voraussetzungen**
+ Schlüssel beginnen mit einem Buchstaben und bestehen aus mindestens zwei Zeichen.
+ Schlüssel enthalten nur Buchstaben, Zahlen und den Unterstrich (`_`).
+ Schlüssel sind nicht [Lambda](#configuration-envvars-runtime) vorbehalten.
+ Die Gesamtgröße aller Umgebungsvariablen überschreitet nicht 4 KB.
1. Wählen Sie **Speichern**.
**Generieren einer Liste von Umgebungsvariablen im Konsolen-Code-Editor**
Sie können im Lambda-Code-Editor eine Liste von Umgebungsvariablen generieren. So können Sie beim Programmieren schnell auf Ihre Umgebungsvariablen verweisen.
1. Wählen Sie die Registerkarte **Code**.
1. Scrollen Sie im Code-Editor nach unten zum Abschnitt **UMGEBUNGSVARIABLEN**. Bestehende Umgebungsvariablen sind hier aufgelistet:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/env-var.png)
1. Um neue Umgebungsvariablen zu erstellen, wählen Sie das Pluszeichen (![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/add-plus.png)):
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/create-env-var.png)
Umgebungsvariablen bleiben verschlüsselt, wenn sie im Code-Editor der Konsole aufgeführt werden. Wenn Sie Verschlüsselungshilfen für die Verschlüsselung während der Übertragung aktiviert haben, bleiben diese Einstellungen unverändert. Weitere Informationen finden Sie unter [Sicherung von Lambda-Umgebungsvariablen](configuration-envvars-encryption.md).
Die Liste der Umgebungsvariablen ist schreibgeschützt und nur auf der Lambda-Konsole verfügbar. Diese Datei ist nicht enthalten, wenn Sie das ZIP-Dateiarchiv der Funktion herunterladen, und Sie können keine Umgebungsvariablen hinzufügen, indem Sie diese Datei hochladen.
------
#### [ AWS CLI ]
Im folgenden Beispiel werden zwei Umgebungsvariablen für eine Funktion mit dem Namen festgeleg `my-function`.
```
aws lambda update-function-configuration \
--function-name my-function \
--environment "Variables={BUCKET=amzn-s3-demo-bucket,KEY=file.txt}"
```
Wenn Sie Umgebungsvariablen mit dem `update-function-configuration`-Befehl anwenden, wird der gesamte Inhalt der `Variables`-Struktur ersetzt. Um vorhandene Umgebungsvariablen beibehalten, wenn Sie eine neue hinzufügen, schließen Sie alle vorhandenen Werte in Ihre Anforderung ein.
Mit dem `get-function-configuration`-Befehl können Sie die aktuelle Konfiguration abrufen.
```
aws lambda get-function-configuration \
--function-name my-function
```
Die Ausgabe sollte folgendermaßen aussehen:
```
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:111122223333:function:my-function",
"Runtime": "nodejs24.x",
"Role": "arn:aws:iam::111122223333:role/lambda-role",
"Environment": {
"Variables": {
"BUCKET": "amzn-s3-demo-bucket",
"KEY": "file.txt"
}
},
"RevisionId": "0894d3c1-2a3d-4d48-bf7f-abade99f3c15",
...
}
```
Sie können die Revisions-ID aus der Ausgabe von `get-function-configuration` als Parameter an `update-function-configuration` übergeben. Dadurch wird sichergestellt, dass sich die Werte zwischen dem Lesen und dem Aktualisieren der Konfiguration nicht ändern.
Um den Verschlüsselungsschlüssel einer Funktion zu konfigurieren, legen Sie die `KMSKeyARN`-Option fest.
```
aws lambda update-function-configuration \
--function-name my-function \
--kms-key-arn arn:aws:kms:us-east-2:111122223333:key/055efbb4-xmpl-4336-ba9c-538c7d31f599
```
------
#### [ AWS SAM ]
Sie können das [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) verwenden, um Umgebungsvariablen für Ihre Funktion zu konfigurieren. Aktualisieren Sie die Eigenschaften [Umgebung](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-environment) und [Variablen](https://docs.aws.amazon.com//AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-environment.html#cfn-lambda-function-environment-variables) in Ihrer `template.yaml`-Datei und führen Sie dann [sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) aus.
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 128
Timeout: 120
Handler: index.handler
Runtime: nodejs24.x
Architectures:
- x86_64
EphemeralStorage:
Size: 10240
Environment:
Variables:
BUCKET: amzn-s3-demo-bucket
KEY: file.txt
# Other function properties...
```
------
#### [ AWS SDKs ]
Verwenden Sie die folgenden API-Operationen, um Umgebungsvariablen mithilfe eines AWS SDK zu verwalten.
+ [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)
Weitere Informationen finden Sie in der [AWS -SDK-Dokumentation](https://aws.amazon.com/developer/tools/) für Ihre bevorzugte Programmiersprache.
------
## Beispielszenario für Umgebungsvariablen
Sie können Umgebungsvariablen verwenden, um das Funktionsverhalten in Ihrer Testumgebung und Produktionsumgebung anzupassen. Zum Beispiel können Sie zwei Funktionen mit demselben Code aber mit unterschiedlichen Konfigurationen erstellen. Die eine Funktion stellt eine Verbindung mit einer Testdatenbank und die andere mit einer Produktionsdatenbank her. In diesem Fall verwenden Sie Umgebungsvariablen, um den Hostnamen und andere Verbindungsdetails für die Datenbank an die Funktion zu übergeben.
Das folgende Beispiel zeigt, wie der Datenbankhost und der Datenbankname als Umgebungsvariablen definiert werden.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/console-env.png)
Wenn Ihre Testumgebung mehr Debugging-Informationen generieren soll als die Produktionsumgebung, können Sie eine Umgebungsvariable festlegen, um Ihre Testumgebung so zu konfigurieren, dass eine ausführlichere Protokollierung oder eine detailliertere Ablaufverfolgung verwendet wird.
Beispielsweise könnten Sie in Ihrer Testumgebung eine Umgebungsvariable mit dem Schlüssel `LOG_LEVEL` und einem Wert festlegen, der die Protokollstufe „Debug“ oder „Trace“ angibt. Im Code Ihrer Lambda-Funktion können Sie dann diese Umgebungsvariable verwenden, um die Protokollstufe festzulegen.
Die folgenden Codebeispiele in Python und Node.js veranschaulichen, wie Sie dies erreichen können. In diesen Beispielen wird davon ausgegangen, dass Ihre Umgebungsvariable den Wert `DEBUG` in Python oder `debug` in Node.js hat.
------
#### [ Python ]
**Example Python-Code zum Festlegen der Protokollstufe**
```
import os
import logging
# Initialize the logger
logger = logging.getLogger()
# Get the log level from the environment variable and default to INFO if not set
log_level = os.environ.get('LOG_LEVEL', 'INFO')
# Set the log level
logger.setLevel(log_level)
def lambda_handler(event, context):
# Produce some example log outputs
logger.debug('This is a log with detailed debug information - shown only in test environment')
logger.info('This is a log with standard information - shown in production and test environments')
```
------
#### [ Node.js (ES module format) ]
**Example Node.js-Code zum Festlegen der Protokollstufe**
In diesem Beispiel wird die `winston`-Protokollierungsbibliothek verwendet. Verwenden Sie npm, um diese Bibliothek dem Bereitstellungspaket Ihrer Funktion hinzuzufügen. Weitere Informationen finden Sie unter [ZIP-Bereitstellungspakets mit Abhängigkeiten erstellen](nodejs-package.md#nodejs-package-create-dependencies).
```
import winston from 'winston';
// Initialize the logger using the log level from environment variables, defaulting to INFO if not set
const logger = winston.createLogger({
level: process.env.LOG_LEVEL || 'info',
format: winston.format.json(),
transports: [new winston.transports.Console()]
});
export const handler = async (event) => {
// Produce some example log outputs
logger.debug('This is a log with detailed debug information - shown only in test environment');
logger.info('This is a log with standard information - shown in production and test environment');
};
```
------
## Abrufen von Lambda-Umgebungsvariablen
Umgebungsvariablen in Ihrem Funktionscode können Sie mit der Standardmethode für Ihre Programmiersprache abrufen.
------
#### [ Node.js ]
```
let region = process.env.AWS_REGION
```
------
#### [ Python ]
```
import os
region = os.environ['AWS_REGION']
```
**Anmerkung**
In einigen Fällen müssen Sie möglicherweise das folgende Format verwenden:
```
region = os.environ.get('AWS_REGION')
```
------
#### [ Ruby ]
```
region = ENV["AWS_REGION"]
```
------
#### [ Java ]
```
String region = System.getenv("AWS_REGION");
```
------
#### [ Go ]
```
var region = os.Getenv("AWS_REGION")
```
------
#### [ C\$1 ]
```
string region = Environment.GetEnvironmentVariable("AWS_REGION");
```
------
#### [ PowerShell ]
```
$region = $env:AWS_REGION
```
------
Lambda speichert Umgebungsvariablen sicher, indem sie im Ruhezustand verschlüsselt werden. Sie können [Lambda so konfigurieren, dass es einen anderen Verschlüsselungsschlüssel verwendet](configuration-envvars-encryption.md), Umgebungsvariablenwerte auf der Clientseite verschlüsselt oder Umgebungsvariablen in einer CloudFormation Vorlage mit festlegen. AWS Secrets Manager
## Definierte Laufzeitumgebungsvariablen
Lambda [Laufzeiten](lambda-runtimes.md) setzen mehrere Umgebungsvariablen während der Initialisierung. Die meisten Umgebungsvariablen stellen Informationen über die Funktion oder Laufzeit bereit. Die Schlüssel für diese Umgebungsvariablen sind *reserviert* und können nicht in der Funktionskonfiguration gesetzt werden.
**Reservierte Umgebungsvariablen**
+ `_HANDLER` – Der für die Funktion konfigurierte Handler-Speicherort.
+ `_X_AMZN_TRACE_ID` – Die [X-Ray-Tracing-Header](services-xray.md). Diese Umgebungsvariable ändert sich bei jedem Aufruf.
+ Diese Umgebungsvariable ist nicht für reine OS-Laufzeiten (die `provided`-Laufzeitfamilie) definiert. Sie können `_X_AMZN_TRACE_ID` für benutzerdefinierte Laufzeiten einstellen, indem Sie den Antwort-Header `Lambda-Runtime-Trace-Id` der [Nächster Aufruf](runtimes-api.md#runtimes-api-next) verwenden.
+ Für die Java-Laufzeit-Versionen 17 und höher wird diese Umgebungsvariable nicht verwendet. Stattdessen speichert Lambda Ablaufverfolgungsinformationen in der Systemeigenschaft `com.amazonaws.xray.traceHeader`.
+ `AWS_DEFAULT_REGION`— Die Standardeinstellung AWS-Region , in der die Lambda-Funktion ausgeführt wird.
+ `AWS_REGION`— Der AWS-Region Ort, an dem die Lambda-Funktion ausgeführt wird. Wenn eingegeben, überschreibt dieser Wert die `AWS_DEFAULT_REGION`.
+ Weitere Informationen zur Verwendung der AWS-Region Umgebungsvariablen mit AWS SDKs finden Sie unter [AWS Region](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html#feature-region-sdk-compat) im *Referenzhandbuch für Tools AWS SDKs und Tools.*
+ `AWS_EXECUTION_ENV` – [Die Laufzeit-Kennung](lambda-runtimes.md) mit dem Präfix `AWS_Lambda_` z. B. `AWS_Lambda_java8`. Diese Umgebungsvariable ist nicht für reine OS-Laufzeiten (die `provided`-Laufzeitfamilie) definiert.
+ `AWS_LAMBDA_FUNCTION_NAME` – Der Name der Funktion.
+ `AWS_LAMBDA_FUNCTION_MEMORY_SIZE` – Die Menge des für die Funktion verfügbaren Speichers in MB.
+ `AWS_LAMBDA_FUNCTION_VERSION` – Die Version der Funktion, die gerade ausgeführt wird.
+ `AWS_LAMBDA_INITIALIZATION_TYPE`— Der Initialisierungstyp der Funktion,`on-demand`, `provisioned-concurrency``snap-start`, oder`lambda-managed-instances`. Weitere Informationen finden Sie unter [Konfiguration der bereitgestellten Parallelität,, [Verbesserung der Startleistung mit Lambda SnapStart](snapstart.md) oder](provisioned-concurrency.md). [Von Lambda verwaltete Instances](lambda-managed-instances.md)
+ `AWS_LAMBDA_LOG_GROUP_NAME`, `AWS_LAMBDA_LOG_STREAM_NAME` — Der Name der Amazon CloudWatch Logs-Gruppe und des Streams für die Funktion. Die `AWS_LAMBDA_LOG_STREAM_NAME` [Umgebungsvariablen `AWS_LAMBDA_LOG_GROUP_NAME`](#configuration-envvars-runtime) und sind in SnapStart Lambda-Funktionen nicht verfügbar.
+ `AWS_ACCESS_KEY`, `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN` – Die Zugriffsschlüssel, die über die [Ausführungsrolle](lambda-intro-execution-role.md) der Funktion bezogen wurden.
+ `AWS_LAMBDA_RUNTIME_API` – ([Benutzerdefinierte Laufzeit](runtimes-custom.md)) Host und Port der [Laufzeit-API](runtimes-api.md).
+ `LAMBDA_TASK_ROOT` – Der Pfad zu Ihrem Lambda-Funktionscode.
+ `LAMBDA_RUNTIME_DIR` – Der Pfad zu Laufzeitbibliotheken.
+ `AWS_LAMBDA_MAX_CONCURRENCY`— (Nur Lambda Managed Instances) Die maximale Anzahl gleichzeitiger Aufrufe, die Lambda an eine Ausführungsumgebung sendet.
+ `AWS_LAMBDA_METADATA_API`— Die [Metadaten-Endpunkt-Serveradresse](configuration-metadata-endpoint.md) im Format `{ipv4_address}:{port}` (z. B.). `169.254.100.1:9001`
+ `AWS_LAMBDA_METADATA_TOKEN`— Ein eindeutiges Authentifizierungstoken für die aktuelle Ausführungsumgebung, das zur Authentifizierung von Anfragen an den [Metadaten-Endpunkt](configuration-metadata-endpoint.md) verwendet wird. Lambda generiert dieses Token automatisch bei der Initialisierung.
Die folgenden zusätzlichen Umgebungsvariablen sind nicht vorbehalten und können in Ihrer Funktionskonfiguration erweitert werden.
**Nicht reservierte Umgebungsvariablen**
+ `LANG` – Das Gebietsschema der Laufzeit (`en_US.UTF-8`).
+ `PATH` – Der Ausführungspfad (`/usr/local/bin:/usr/bin/:/bin:/opt/bin`).
+ `LD_LIBRARY_PATH` – Der Pfad der Systembibliothek (`/var/lang/lib:/lib64:/usr/lib64:$LAMBDA_RUNTIME_DIR:$LAMBDA_RUNTIME_DIR/lib:$LAMBDA_TASK_ROOT:$LAMBDA_TASK_ROOT/lib:/opt/lib`).
+ `NODE_PATH` – ([Node.js](lambda-nodejs.md)) Der Node.js-Bibliothekspfad (`/opt/nodejs/node12/node_modules/:/opt/nodejs/node_modules:$LAMBDA_RUNTIME_DIR/node_modules`).
+ `NODE_OPTIONS` – ([Node.js](lambda-nodejs.md)) Für Node.js-Laufzeiten können Sie `NODE_OPTIONS` verwenden, um experimentelle Features wieder zu aktivieren, die Lambda standardmäßig deaktiviert.
+ `PYTHONPATH` – ([Python](lambda-python.md)) Der Python-Bibliothekspfad (`$LAMBDA_RUNTIME_DIR`).
+ `GEM_PATH` – ([Ruby](lambda-ruby.md)) Der Pfad der Ruby-Bibliothek (`$LAMBDA_TASK_ROOT/vendor/bundle/ruby/3.3.0:/opt/ruby/gems/3.3.0`).
+ `AWS_XRAY_CONTEXT_MISSING` – Für die X-Ray-Ablaufverfolgung legt Lambda dies auf `LOG_ERROR` fest, um Laufzeitfehler aus dem X-Ray-SDK zu vermeiden.
+ `AWS_XRAY_DAEMON_ADDRESS` – Die IP-Adresse und der Port des X-Ray-Daemons.
+ `AWS_LAMBDA_DOTNET_PREJIT` – ([.NET](lambda-csharp.md)) Legen Sie für die .NET-Laufzeitumgebung diese Variable so fest, dass sie .NET-spezifische Laufzeitoptimierungen aktiviert oder deaktiviert. Zu den Werten gehören `always`, `never` und `provisioned-concurrency`. Weitere Informationen finden Sie unter [Konfigurieren von Provisioned Concurrency für eine Funktion](provisioned-concurrency.md).
+ `TZ` – Die Zeitzone der Umgebung (`:UTC`). Die Ausführungsumgebung verwendet NTP, um die Systemuhr zu synchronisieren.
Die angezeigten Beispielwerte spiegeln die neuesten Laufzeiten wider. Das Vorhandensein bestimmter Variablen oder deren Werte kann je nach früheren Laufzeiten unterschiedlich sein.
# Sicherung von Lambda-Umgebungsvariablen
Sie können Ihre Umgebungsvariablen sichern, können Sie eine serverseitige Verschlüsselung nutzen, um Ihre Data-at-Rest zu schützen und eine clientseitige Verschlüsselung, um Ihre Daten während der Übertragung zu schützen.
**Anmerkung**
Um die Datenbanksicherheit zu erhöhen, empfehlen wir, AWS Secrets Manager anstelle von Umgebungsvariablen zum Speichern von Datenbankanmeldeinformationen zu verwenden. Weitere Informationen finden Sie unter [Verwenden von Secrets-Manager-Secrets in Lambda-Funktionen](with-secrets-manager.md).
**Sicherheit im Ruhezustand**
Lambda bietet im Ruhezustand immer serverseitiger Verschlüsselung mit einem AWS KMS key an. Standardmäßig verwendet Lambda einen Von AWS verwalteter Schlüssel. Wenn dieses Standardverhalten Ihrem Workflow entspricht, müssen Sie nichts anderes einrichten. Lambda erstellt das Von AWS verwalteter Schlüssel in Ihrem Konto und verwaltet die Berechtigungen für Sie. AWS berechnet Ihnen keine Gebühren für die Verwendung dieses Schlüssels.
Wenn Sie möchten, können Sie stattdessen einen vom AWS KMS Kunden verwalteten Schlüssel bereitstellen. Sie können dies tun, um die Drehung des KMS-Schlüssels zu steuern oder die Anforderungen Ihrer Organisation für die Verwaltung von KMS-Schlüsseln zu erfüllen. Wenn Sie einen vom Kunden verwalteten Schlüssel verwenden, können nur Benutzer in Ihrem Konto mit Zugriff auf den KMS-Schlüssel Umgebungsvariablen für die Funktion anzeigen oder verwalten.
Für vom Kunden verwaltete Schlüssel fallen AWS KMS Standardgebühren an. Weitere Informationen finden Sie unter [AWS Key Management Service Preise](https://aws.amazon.com/kms/pricing/).
**Sicherheit während der Übertragung**
Für zusätzliche Sicherheit können Sie Helfer für die Verschlüsselung bei der Übertragung aktivieren, wodurch sichergestellt wird, dass Ihre Umgebungsvariablen clientseitig verschlüsselt sind, um sie während der Übertragung zu schützen.
**So konfigurieren Sie die Verschlüsselung für Ihre Umgebungsvariablen**
1. Verwenden Sie AWS Key Management Service (AWS KMS), um alle vom Kunden verwalteten Schlüssel für Lambda zu erstellen, die für die serverseitige und clientseitige Verschlüsselung verwendet werden sollen. Weitere Informationen finden Sie unter [Erstellen von Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) im *AWS Key Management Service -Entwicklerhandbuch*.
1. Navigieren Sie mithilfe der Lambda-Konsole zur Seite **Umgebungsvariablen bearbeiten**.
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 **Konfiguration** und dann **Umgebungsvariablen** aus der linken Navigationsleiste.
1. Wählen Sie im Abschnitt **Umgebungsvariablen** **Bearbeiten** aus.
1. Erweitern Sie **Encryption configuration (Verschlüsselungskonfiguration)**.
1. (Optional) Aktivieren Sie Konsolenverschlüsselungshelfer, um die clientseitige Verschlüsselung zu verwenden, um Ihre Daten während der Übertragung zu schützen.
1. Wählen Sie unter **Verschlüsselung während der Übertragung** die Option **Helfer für die Verschlüsselung während der Übertragung aktivieren** aus.
1. Wählen Sie für jede Umgebungsvariable, für die Sie Konsolenverschlüsselungshilfen aktivieren möchten, neben der Umgebungsvariablen die Option **Encrypt (Verschlüsseln)** aus.
1. Wählen AWS KMS key Sie unter Verschlüsselung bei der Übertragung einen vom Kunden verwalteten Schlüssel aus, den Sie zu Beginn dieses Verfahrens erstellt haben.
1. Wählen Sie **Ausführungsrollenrichtlinie** und kopieren Sie die Richtlinie. Diese Richtlinie gewährt der Ausführungsrolle Ihrer Funktion die Berechtigung zum Entschlüsseln der Umgebungsvariablen.
Speichern Sie diese Richtlinie zur Verwendung im letzten Schritt dieses Verfahrens.
1. Fügen Sie Ihrer Funktion Code hinzu, der die Umgebungsvariablen entschlüsselt. Wählen Sie **Geheimnisausschnitt entschlüsseln**, um ein Beispiel anzuzeigen.
1. (Optional) Geben Sie Ihren kundenverwalteten Schlüssel zur Verschlüsselung im Ruhezustand an.
1. Wählen Sie **Kundenmasterschlüssel verwenden** aus.
1. Wählen Sie einen vom Kunden verwalteten Schlüssel aus, den Sie zu Beginn dieses Verfahrens erstellt haben.
1. Wählen Sie **Speichern**.
1. Richten Sie Berechtigungen ein.
Wenn Sie einen vom Kunden verwalteten Schlüssel mit serverseitiger Verschlüsselung verwenden, erteilen Sie allen Benutzern oder Rollen Berechtigungen zum Anzeigen oder Verwalten von Umgebungsvariablen für die Funktion. Weitere Informationen finden Sie unter [Verwalten von Berechtigungen für den serverseitigen Verschlüsselungs-KMS-Schlüssel](#managing-permissions-to-your-server-side-encryption-key).
Wenn Sie die clientseitige Verschlüsselung für die Sicherheit während der Übertragung aktivieren, benötigt Ihre Funktion die Berechtigung zum Aufrufen der `kms:Decrypt`-API-Operation. Fügen Sie die Richtlinie, die Sie zuvor in diesem Verfahren gespeichert haben, zur [Ausführungsrolle](lambda-intro-execution-role.md) der Funktion hinzu.
## Verwalten von Berechtigungen für den serverseitigen Verschlüsselungs-KMS-Schlüssel
Für Ihren Benutzer oder die Ausführungsrolle der Funktion sind keine AWS KMS Berechtigungen erforderlich, um den Standard-Verschlüsselungsschlüssel zu verwenden. Um einen vom kundenverwalteten Schlüssel verwenden zu können, benötigen Sie eine Berechtigungen zur Verwendung des Schlüssels. Lambda erstellt anhand Ihrer Berechtigungen eine Berechtigungserteilung für den Schlüssel. So wird es Lambda ermöglicht, diesen für die Verschlüsselung zu verwenden.
+ `kms:ListAliases` – Zur Ansicht von Schlüssel in der Lambda-Konsole.
+ `kms:CreateGrant`, `kms:Encrypt` – Zum Konfigurieren eines vom Kunden verwalteten Schlüssels für eine Funktion.
+ `kms:Decrypt` – Zum Anzeigen und Verwalten von Umgebungsvariablen, die mit einem vom Kunden verwalteten Schlüssel verschlüsselt sind.
Sie können diese Berechtigungen über Ihre AWS-Konto oder über die ressourcenbasierte Berechtigungsrichtlinie eines Schlüssels erhalten. `ListAliases`wird durch die [verwalteten Richtlinien für Lambda](access-control-identity-based.md) bereitgestellt. Schlüsselrichtlinien gewähren Benutzern in der Gruppe **Key users (Schlüsselbenutzer)** die verbleibenden Berechtigungen.
Benutzer ohne `Decrypt`-Berechtigungen können Funktionen weiterhin verwalten, aber sie können keine Umgebungsvariablen anzeigen oder in der Lambda-Konsole verwalten. Um zu verhindern, dass ein Benutzer Umgebungsvariablen anzeigen kann, fügen Sie den Berechtigungen des Benutzers eine Anweisung hinzu, die den Zugriff auf den Standardschlüssel, einen vom Kunden verwalteten Schlüssel oder alle Schlüssel verweigert.
**Example IAM-Richtlinie – Verweigern des Zugriffs nach Schlüssel-ARN**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Deny",
"Action": [
"kms:Decrypt"
],
"Resource": "arn:aws:kms:us-east-2:111122223333:key/3be10e2d-xmpl-4be4-bc9d-0405a71945cc"
}
]
}
```
Details zum Verwalten von Schlüsselberechtigungen finden Sie unter [Key policies in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) im *AWS Key Management Service -Entwicklerhandbuch*.
# Lambda-Funktionen Zugriff auf Ressourcen in einer Amazon VPC gewähren
Mit Amazon Virtual Private Cloud (Amazon VPC) können Sie private Netzwerke in Ihren AWS-Konto Host-Ressourcen wie Amazon Elastic Compute Cloud (Amazon EC2) -Instances, Amazon Relational Database Service (Amazon RDS) -Instances und Amazon-Instances erstellen. ElastiCache Sie können Ihrer Lambda-Funktion Zugriff auf Ressourcen geben, die in einer Amazon VPC gehostet werden, indem Sie Ihre Funktion über die privaten Subnetze, die die Ressourcen enthalten, mit der VPC verbinden. Folgen Sie den Anweisungen in den folgenden Abschnitten, um eine Lambda-Funktion über die Lambda-Konsole, die AWS Command Line Interface (AWS CLI) oder an eine Amazon VPC anzuhängen. AWS SAM
**Anmerkung**
Jede Lambda-Funktion läuft in einer VPC, die dem Lambda-Dienst gehört und von diesem verwaltet wird. Diese VPCs werden automatisch von Lambda verwaltet und sind für Kunden nicht sichtbar. Die Konfiguration Ihrer Funktion für den Zugriff auf andere AWS Ressourcen in einer Amazon VPC hat keine Auswirkungen auf die von Lambda verwaltete VPC, in der Ihre Funktion ausgeführt wird.
**Topics**
+ [
## Erforderliche IAM-Berechtigungen
](#configuration-vpc-permissions)
+ [
## Hinzufügen von Lambda-Funktionen zu einer Amazon VPC in Ihrem AWS-Konto
](#configuration-vpc-attaching)
+ [
## Internetzugang bei Verbindung mit einer VPC
](#configuration-vpc-internet-access)
+ [
## IPv6 Unterstützung
](#configuration-vpc-ipv6)
+ [
## Bewährte Methoden für die Verwendung von Lambda mit Amazon VPCs
](#configuration-vpc-best-practice)
+ [
## Grundlegendes zu elastischen Hyperplane-Netzwerkschnittstellen () ENIs
](#configuration-vpc-enis)
+ [
## Verwenden von IAM-Bedingungsschlüsseln für VPC-Einstellungen
](#vpc-conditions)
+ [
## VPC-Tutorials
](#vpc-tutorials)
## Erforderliche IAM-Berechtigungen
Um eine Lambda-Funktion an eine Amazon-VPC in Ihrer anzuhängen AWS-Konto, benötigt Lambda Berechtigungen zum Erstellen und Verwalten der Netzwerkschnittstellen, die es verwendet, um Ihrer Funktion Zugriff auf die Ressourcen in der VPC zu gewähren.
Die von Lambda erstellten Netzwerkschnittstellen werden als Hyperplane Elastic Network Interfaces oder Hyperplane bezeichnet. ENIs Weitere Informationen zu diesen Netzwerkschnittstellen finden Sie unter [Grundlegendes zu elastischen Hyperplane-Netzwerkschnittstellen () ENIs](#configuration-vpc-enis).
Sie können Ihrer Funktion die erforderlichen Berechtigungen erteilen, indem Sie die AWS verwaltete Richtlinie [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html)an die Ausführungsrolle Ihrer Funktion anhängen. Wenn Sie eine neue Funktion in der Lambda-Konsole erstellen und sie an eine VPC anhängen, fügt Lambda diese Berechtigungsrichtlinie automatisch für Sie hinzu.
Wenn Sie es vorziehen, Ihre eigene IAM-Berechtigungsrichtlinie zu erstellen, stellen Sie sicher, dass Sie alle der folgenden Berechtigungen hinzufügen und sie auf allen Ressourcen erlauben (`"Resource": "*"`):
+ ec2: CreateNetworkInterface
+ ec2: DescribeNetworkInterfaces
+ ec2: DescribeSubnets
+ ec2: DeleteNetworkInterface
+ ec2: AssignPrivateIpAddresses
+ ec2: UnassignPrivateIpAddresses
Beachten Sie, dass die Rolle Ihrer Funktion diese Berechtigungen nur benötigt, um die Netzwerkschnittstellen zu erstellen, nicht aber, um Ihre Funktion aufzurufen. Sie können Ihre Funktion weiterhin erfolgreich aufrufen, wenn sie an eine Amazon VPC angefügt ist, selbst wenn Sie diese Berechtigungen aus der Ausführungsrolle Ihrer Funktion entfernen.
Um Ihre Funktion an eine VPC anzuhängen, muss Lambda auch Netzwerkressourcen mithilfe Ihrer IAM-Benutzerrolle verifizieren. Stellen Sie sicher, dass Ihre Benutzerrolle über die folgenden IAM-Berechtigungen verfügt:
+ **ec2: DescribeSecurityGroups**
+ **ec2: DescribeSubnets**
+ **ec2: DescribeVpcs**
+ **ec2: GetSecurityGroupsForVpc**
**Anmerkung**
Die Amazon-EC2-Berechtigungen, die Sie der Ausführungsrolle Ihrer Funktion gewähren, werden vom Lambda-Service verwendet, um Ihre Funktion an eine VPC anzuhängen. Sie gewähren diese Berechtigungen jedoch auch implizit für den Code Ihrer Funktion. Das bedeutet, dass Ihr Funktionscode diese Amazon-EC2-API-Aufrufe ausführen kann. Ratschläge zur Einhaltung bewährter Sicherheitsverfahren finden Sie unter [Bewährte Methoden für die Gewährleistung der Sicherheit](#configuration-vpc-best-practice-security).
## Hinzufügen von Lambda-Funktionen zu einer Amazon VPC in Ihrem AWS-Konto
Verbinden Sie Ihre Funktion mit einer Amazon-VPC in Ihrem, AWS-Konto indem Sie die Lambda-Konsole verwenden, oder. AWS CLI AWS SAM Wenn Sie das AWS CLI oder verwenden oder AWS SAM eine bestehende Funktion mithilfe der Lambda-Konsole an eine VPC anhängen, stellen Sie sicher, dass die Ausführungsrolle Ihrer Funktion über die erforderlichen Berechtigungen verfügt, die im vorherigen Abschnitt aufgeführt sind.
Lambda-Funktionen können keine direkte Verbindung mit einer VPC mit [Dedicated-Instance-Tenancy](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-instance.html) herstellen. Zum Herstellen einer Verbindung mit Ressourcen in einer dedizierten VPC [verbinden Sie sie mit einer zweiten VPC mit Standard-Tenancy](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-dedicated-vpc/).
------
#### [ Lambda console ]
**So hängen Sie eine Funktion an eine Amazon VPC an, wenn Sie sie erstellen**
1. Öffnen Sie die Seite [Functions (Funktionen)](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole und wählen Sie **Create function (Funktion erstellen)** aus.
1. Geben Sie unter **Basic information (Grundlegende Informationen)** bei **Function name (Funktionsname)** einen Namen für Ihre Funktion ein.
1. Konfigurieren Sie die VPC-Einstellungen für die Funktion, indem Sie wie folgt vorgehen:
1. Erweiterten Sie **Advanced settings (Erweiterte Einstellungen)**.
1. Wählen Sie **VPC aktivieren** und wählen Sie dann den VPC, dem Sie die Funktion zuordnen möchten.
1. (Optional) Um [ausgehenden IPv6 Datenverkehr zuzulassen, wählen Sie Traffic für Dual-Stack-Subnetze](#configuration-vpc-ipv6) **zulassen IPv6 ** aus.
1. Wählen Sie die Teilnetze und Sicherheitsgruppen aus, für die die Netzwerkschnittstelle erstellt werden soll. Wenn Sie ** IPv6 Datenverkehr für Dual-Stack-Subnetze zulassen ausgewählt haben, müssen alle ausgewählten Subnetze** über einen CIDR-Block und einen IPv4 CIDR-Block verfügen. IPv6
**Anmerkung**
Verbinden Sie Ihre Funktion für den Zugriff auf private Ressourcen mit privaten Subnetzen. Wenn Ihre Funktion Internetzugang benötigt, siehe [Aktivieren Sie den Internetzugang für VPC-verbundene Lambda-Funktionen](configuration-vpc-internet.md). Durch die Verbindung einer Funktion mit einem öffentlichen Subnetz erhält sie weder Internetzugang noch eine öffentliche IP-Adresse.
1. Wählen Sie **Create function (Funktion erstellen)**.
**So hängen Sie eine vorhandene Funktion an eine Amazon VPC an**
1. Öffnen Sie die [Funktionsseite](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole und wählen Sie Ihre Funktion aus.
1. Wählen Sie die Registerkarte **Konfiguration** und anschließend **VPC** aus.
1. Wählen Sie **Bearbeiten** aus.
1. Wählen Sie unter **VPC** die Amazon VPC aus, an die Sie Ihre Funktion anhängen möchten.
1. **(Optional) Um [ausgehenden IPv6 Datenverkehr zuzulassen, wählen Sie Datenverkehr](#configuration-vpc-ipv6) für Dual-Stack-Subnetze zulassen aus. IPv6 **
1. Wählen Sie die Teilnetze und Sicherheitsgruppen aus, für die die Netzwerkschnittstelle erstellt werden soll. Wenn Sie ** IPv6 Datenverkehr für Dual-Stack-Subnetze zulassen ausgewählt haben, müssen alle ausgewählten Subnetze** über einen CIDR-Block und einen IPv4 CIDR-Block verfügen. IPv6
**Anmerkung**
Verbinden Sie Ihre Funktion für den Zugriff auf private Ressourcen mit privaten Subnetzen. Wenn Ihre Funktion Internetzugang benötigt, siehe [Aktivieren Sie den Internetzugang für VPC-verbundene Lambda-Funktionen](configuration-vpc-internet.md). Durch die Verbindung einer Funktion mit einem öffentlichen Subnetz erhält sie weder Internetzugang noch eine öffentliche IP-Adresse.
1. Wählen Sie **Speichern**.
------
#### [ AWS CLI ]
**So hängen Sie eine Funktion an eine Amazon VPC an, wenn Sie sie erstellen**
+ Um eine Lambda-Funktion zu erstellen und sie mit einer VPC zu verbinden, führen Sie den folgenden CLI `create-function`-Befehl aus.
```
aws lambda create-function --function-name my-function \
--runtime nodejs24.x --handler index.js --zip-file fileb://function.zip \
--role arn:aws:iam::123456789012:role/lambda-role \
--vpc-config Ipv6AllowedForDualStack=true,SubnetIds=subnet-071f712345678e7c8,subnet-07fd123456788a036,SecurityGroupIds=sg-085912345678492fb
```
Geben Sie Ihre eigenen Subnetze und Sicherheitsgruppen an und setzen Sie `Ipv6AllowedForDualStack` je nach Anwendungsfall auf `true` oder `false`.
**So hängen Sie eine vorhandene Funktion an eine Amazon VPC an**
+ Um eine vorhandene Funktion an eine VPC anzuhängen, führen Sie den folgenden CLI `update-function-configuration`-Befehl aus.
```
aws lambda update-function-configuration --function-name my-function \
--vpc-config Ipv6AllowedForDualStack=true, SubnetIds=subnet-071f712345678e7c8,subnet-07fd123456788a036,SecurityGroupIds=sg-085912345678492fb
```
**So trennen Sie Ihre Funktion von einer VPC**
+ Um Ihre Funktion von einer VPC zu trennen, führen Sie den folgenden `update-function-configuration`-CLI-Befehl mit einer leeren Liste der VPC-Subnetze und Sicherheitsgruppen aus.
```
aws lambda update-function-configuration --function-name my-function \
--vpc-config SubnetIds=[],SecurityGroupIds=[]
```
------
#### [ AWS SAM ]
**So verbinden Sie Ihre Funktion mit einer VPC**
+ Um eine Lambda-Funktion an eine Amazon VPC anzuhängen, fügen Sie die `VpcConfig`-Eigenschaft zu Ihrer Funktionsdefinition hinzu, wie in der folgenden Beispielvorlage gezeigt. Weitere Informationen zu dieser Eigenschaft finden Sie unter [AWS: :Lambda: :Function VpcConfig](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-vpcconfig.html) im *CloudFormation Benutzerhandbuch* (die AWS SAM `VpcConfig` Eigenschaft wird direkt an die `VpcConfig` Eigenschaft einer CloudFormation `AWS::Lambda::Function` Ressource übergeben).
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./lambda_function/
Handler: lambda_function.handler
Runtime: python3.12
VpcConfig:
SecurityGroupIds:
- !Ref MySecurityGroup
SubnetIds:
- !Ref MySubnet1
- !Ref MySubnet2
Policies:
- AWSLambdaVPCAccessExecutionRole
MySecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: Security group for Lambda function
VpcId: !Ref MyVPC
MySubnet1:
Type: AWS::EC2::Subnet
Properties:
VpcId: !Ref MyVPC
CidrBlock: 10.0.1.0/24
MySubnet2:
Type: AWS::EC2::Subnet
Properties:
VpcId: !Ref MyVPC
CidrBlock: 10.0.2.0/24
MyVPC:
Type: AWS::EC2::VPC
Properties:
CidrBlock: 10.0.0.0/16
```
*Weitere Informationen zur Konfiguration Ihrer VPC in AWS SAM finden Sie unter [AWS: :EC2: :VPC](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html) im Benutzerhandbuch.CloudFormation *
------
## Internetzugang bei Verbindung mit einer VPC
Standardmäßig haben Lambda-Funktionen Zugriff auf das öffentliche Internet. Wenn Sie Ihre Funktion an eine VPC anhängen, kann sie nur auf Ressourcen zugreifen, die in dieser VPC verfügbar sind. Um Ihrer Funktion Zugriff auf das Internet zu gewähren, müssen Sie die VPC auch für den Internetzugang konfigurieren. Weitere Informationen hierzu finden Sie unter [Aktivieren Sie den Internetzugang für VPC-verbundene Lambda-Funktionen](configuration-vpc-internet.md).
## IPv6 Unterstützung
Ihre Funktion kann über eine Verbindung zu Ressourcen in Dual-Stack-VPC-Subnetzen eine Verbindung herstellen. IPv6 Diese Option ist standardmäßig deaktiviert. [Um ausgehenden IPv6 Datenverkehr zuzulassen, verwenden Sie die Konsole oder die `--vpc-config Ipv6AllowedForDualStack=true` Option mit der Create-Funktion oder dem Befehl. [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html)](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html)
**Anmerkung**
Um ausgehenden IPv6 Verkehr in einer VPC zuzulassen, müssen alle Subnetze, die mit der Funktion verbunden sind, Dual-Stack-Subnetze sein. Lambda unterstützt keine ausgehenden IPv6 Verbindungen für IPv6 reine Subnetze in einer VPC oder ausgehende IPv6 Verbindungen für Funktionen, die nicht mit einer VPC verbunden sind.
Sie können Ihren Funktionscode aktualisieren, um explizit eine Verbindung zu Subnetzressourcen herzustellen. IPv6 Das folgende Python-Beispiel öffnet einen Socket und stellt eine Verbindung zu einem IPv6 Server her.
**Example — Connect zum IPv6 Server herstellen**
```
def connect_to_server(event, context):
server_address = event['host']
server_port = event['port']
message = event['message']
run_connect_to_server(server_address, server_port, message)
def run_connect_to_server(server_address, server_port, message):
sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM, 0)
try:
# Send data
sock.connect((server_address, int(server_port), 0, 0))
sock.sendall(message.encode())
BUFF_SIZE = 4096
data = b''
while True:
segment = sock.recv(BUFF_SIZE)
data += segment
# Either 0 or end of data
if len(segment) < BUFF_SIZE:
break
return data
finally:
sock.close()
```
## Bewährte Methoden für die Verwendung von Lambda mit Amazon VPCs
Um sicherzustellen, dass Ihre Lambda-VPC-Konfiguration den Best-Practice-Richtlinien entspricht, befolgen Sie die Hinweise in den folgenden Abschnitten.
### Bewährte Methoden für die Gewährleistung der Sicherheit
Um Ihre Lambda-Funktion an eine VPC anzuhängen, müssen Sie der Ausführungsrolle Ihrer Funktion eine Reihe von Amazon-EC2-Berechtigungen erteilen. Diese Berechtigungen sind erforderlich, um die Netzwerkschnittstellen zu erstellen, die Ihre Funktion für den Zugriff auf die Ressourcen in der VPC verwendet. Diese Berechtigungen werden jedoch auch implizit für den Code Ihrer Funktion gewährt. Das bedeutet, dass Ihr Funktionscode die Erlaubnis hat, diese Amazon-EC2-API-Aufrufe zu tätigen.
Um dem Prinzip des Zugriffs mit den geringsten Rechten zu folgen, fügen Sie der Ausführungsrolle Ihrer Funktion eine Verweigerungsrichtlinie wie das folgende Beispiel hinzu. Diese Richtlinie verhindert, dass Ihr Funktionscode Amazon EC2 aufruft APIs, ermöglicht es dem Lambda-Service dennoch, VPC-Ressourcen in Ihrem Namen zu verwalten. Die Richtlinie verwendet den `lambda:SourceFunctionArn`-Bedingungsschlüssel, der nur für API-Aufrufe gilt, die während der Ausführung von Ihrem Funktionscode getätigt werden. Weitere Informationen finden Sie unter [Verwendung der Quellfunktion ARN zur Steuerung des Funktionszugriffsverhaltens](permissions-source-function-arn.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DeleteNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeSubnets",
"ec2:DetachNetworkInterface",
"ec2:AssignPrivateIpAddresses",
"ec2:UnassignPrivateIpAddresses"
],
"Resource": [ "*" ],
"Condition": {
"ArnEquals": {
"lambda:SourceFunctionArn": [
"arn:aws:lambda:us-west-2:123456789012:function:my_function"
]
}
}
}
]
}
```
------
AWS stellt *[Sicherheitsgruppen](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html)* und *[Netzwerk-Zugriffskontrolllisten (ACLs)](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html)* bereit, um die Sicherheit in Ihrer VPC zu erhöhen. Sicherheitsgruppen kontrollieren den ein- und ausgehenden Datenverkehr für Ihre Ressourcen, und das Netzwerk ACLs steuert den ein- und ausgehenden Datenverkehr für Ihre Subnetze. Sicherheitsgruppen bieten ausreichend Zugriffskontrolle für die meisten Subnetze. Sie können das Netzwerk verwenden ACLs , wenn Sie eine zusätzliche Sicherheitsebene für Ihre VPC wünschen. Allgemeine Richtlinien zu bewährten Sicherheitsmethoden bei der Nutzung von Amazon VPCs finden Sie unter [Bewährte Sicherheitsmethoden für Ihre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-security-best-practices.html) im *Amazon Virtual Private Cloud Cloud-Benutzerhandbuch*.
### Bewährte Methoden zur Leistungssteigerung
Wenn Sie Ihre Funktion an eine VPC anhängen, prüft Lambda, ob es eine verfügbare Netzwerkressource (Hyperplane ENI) gibt, mit der es eine Verbindung herstellen kann. Hyperplane ENIs sind einer bestimmten Kombination von Sicherheitsgruppen und VPC-Subnetzen zugeordnet. Wenn Sie bereits eine Funktion an eine VPC angeschlossen haben, bedeutet die Angabe derselben Subnetze und Sicherheitsgruppen beim Anschließen einer weiteren Funktion, dass Lambda die Netzwerkressourcen gemeinsam nutzen kann und keine neue Hyperplane ENI erstellt werden muss. Weitere Informationen zu Hyperplane ENIs und ihrem Lebenszyklus finden Sie unter. [Grundlegendes zu elastischen Hyperplane-Netzwerkschnittstellen () ENIs](#configuration-vpc-enis)
## Grundlegendes zu elastischen Hyperplane-Netzwerkschnittstellen () ENIs
Eine Hyperplane ENI ist eine verwaltete Ressource, die als Netzwerkschnittstelle zwischen Ihrer Lambda-Funktion und den Ressourcen fungiert, mit denen Sie Ihre Funktion verbinden möchten. Der Lambda-Service erstellt und verwaltet diese ENIs automatisch, wenn Sie Ihre Funktion an eine VPC anhängen.
Hyperplane ENIs sind für Sie nicht direkt sichtbar, und Sie müssen sie nicht konfigurieren oder verwalten. Wenn Sie jedoch wissen, wie sie funktionieren, können Sie besser verstehen, wie sich Ihre Funktion verhält, wenn Sie sie an eine VPC anhängen.
Wenn Sie zum ersten Mal eine Funktion mithilfe einer bestimmten Kombination aus Subnetz und Sicherheitsgruppe an eine VPC anfügen, erstellt Lambda eine Hyperplane-ENI. Andere Funktionen in Ihrem Konto, die dieselbe Kombination aus Subnetz und Sicherheitsgruppe verwenden, können diese ENI ebenfalls verwenden. Wo immer möglich, verwendet Lambda Bestehendes, ENIs um die Ressourcennutzung zu optimieren und die Entstehung neuer Ressourcen zu minimieren. ENIs Jede Hyperplane ENI unterstützt bis zu 65.000 Verbindungen/Ports. Wenn die Anzahl der Verbindungen diesen Grenzwert überschreitet, skaliert Lambda die Anzahl der Verbindungen ENIs automatisch auf der Grundlage des Netzwerkverkehrs und der Parallelitätsanforderungen.
Bei neuen Funktionen bleibt Ihre Funktion, während Lambda eine Hyperplane-ENI erstellt, im Status Ausstehend und Sie können sie nicht aufrufen. Ihre Funktion wechselt erst in den Status Aktiv, wenn die Hyperplane ENI bereit ist, was mehrere Minuten dauern kann. Bei vorhandenen Funktionen können Sie keine zusätzlichen Operationen durchführen, die auf die Funktion abzielen, wie z. B. das Erstellen von Versionen oder das Aktualisieren des Funktionscodes, aber Sie können weiterhin frühere Versionen der Funktion aufrufen.
Im Rahmen der Verwaltung des ENI-Lebenszyklus kann Lambda Daten löschen und neu erstellen, um den Netzwerkverkehr ENIs zu verteilen ENIs oder um Probleme zu beheben, die bei ENI-Integritätsprüfungen festgestellt wurden. Wenn eine Lambda-Funktion 14 Tage lang inaktiv bleibt, fordert Lambda außerdem alle ungenutzten Hyperplanen zurück ENIs und setzt den Funktionsstatus auf. `Inactive` Der nächste Aufrufversuch schlägt fehl, und die Funktion geht wieder in den Zustand „Ausstehend“ über, bis Lambda die Erstellung oder Zuweisung einer Hyperplane-ENI abgeschlossen hat. Wir empfehlen, dass Ihr Design nicht auf der Persistenz von basiert. ENIs
Wenn Sie eine Funktion aktualisieren, um ihre VPC-Konfiguration zu entfernen, benötigt Lambda bis zu 20 Minuten, um die angehängte Hyperplane-ENI zu löschen. Lambda löscht die ENI nur, wenn keine andere Funktion (oder veröffentlichte Funktionsversion) diese Hyperplane ENI verwendet.
Lambda verwendet Berechtigungen in der [Ausführungsrolle](lambda-intro-execution-role.md) der Funktion, um die Hyperplane ENI zu löschen. Wenn Sie die Ausführungsrolle löschen, bevor Lambda die Hyperplane ENI löscht, kann Lambda die Hyperplane ENI nicht löschen. Sie können den Löschvorgang manuell durchführen.
## Verwenden von IAM-Bedingungsschlüsseln für VPC-Einstellungen
Sie können Lambda-spezifische Bedingungsschlüssel für VPC-Einstellungen verwenden, um zusätzliche Berechtigungssteuerungen für Ihre Lambda-Funktionen bereitzustellen. Sie können beispielsweise festlegen, dass alle Funktionen in Ihrer Organisation mit einer VPC sein müssen. Sie können auch die Subnetze und Sicherheitsgruppen angeben, die die Benutzer der Funktion verwenden können bzw. nicht verwenden können.
Lambda unterstützt die folgenden IAM-Bedingungsschlüssel:
+ **lambda: VpcIds** — Erlaube oder verbiete eine oder mehrere. VPCs
+ **lambda: SubnetIds** — Erlaubt oder verweigert ein oder mehrere Subnetze.
+ **lambda: SecurityGroupIds** — Erlaubt oder verweigert eine oder mehrere Sicherheitsgruppen.
Die Lambda-API funktioniert [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)und [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)unterstützt diese Bedingungsschlüssel. Weitere Informationen zur Verwendung von Bedingungsschlüsseln in [IAM-Richtlinien finden Sie unter IAM-JSON-Richtlinienelemente: Bedingung](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) im *IAM-Benutzerhandbuch*.
**Tipp**
Wenn Ihre Funktion bereits eine VPC-Konfiguration aus einer früheren API-Anforderung enthält, können Sie eine `UpdateFunctionConfiguration`-Anforderung ohne die VPC-Konfiguration senden.
### Beispielrichtlinien mit Bedingungsschlüsseln für VPC-Einstellungen
In den folgenden Beispielen wird gezeigt, wie Bedingungsschlüssel für VPC-Einstellungen verwendet werden. Nachdem Sie eine Richtlinienanweisung mit den gewünschten Einschränkungen erstellt haben, fügen Sie die Richtlinienanweisung für den -Zielbenutzer oder die Zielrolle an.
#### Stellen Sie sicher, dass Benutzer nur VPC-verbundene Funktionen bereitstellen
Um sicherzustellen, dass alle Benutzer nur VPC-verbundene Funktionen bereitstellen, können Sie Erstellungs- und Aktualisierungsoperationen von Funktionen verweigern, die keine gültige VPC-ID enthalten.
Beachten Sie, dass die VPC-ID kein Eingabeparameter für die `CreateFunction`- oder `UpdateFunctionConfiguration` -Anforderung ist. Lambda ruft den VPC-ID-Wert basierend auf den Subnetz- und Sicherheitsgruppenparametern ab.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EnforceVPCFunction",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"Null": {
"lambda:VpcIds": "true"
}
}
}
]
}
```
------
#### Verweigern Sie Benutzern den Zugriff auf bestimmte VPCs Subnetze oder Sicherheitsgruppen
Um Benutzern den Zugriff auf bestimmte Bereiche zu verweigern VPCs, verwenden Sie diese Option, `StringEquals` um den Wert der `lambda:VpcIds` Bedingung zu überprüfen. Im folgenden Beispiel wird Benutzern der Zugriff auf `vpc-1` und `vpc-2` verweigert.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EnforceOutOfVPC",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"StringEquals": {
"lambda:VpcIds": [
"vpc-1",
"vpc-2"
]
}
}
}
]
}
```
------
Um Benutzern den Zugriff auf bestimmte Subnetze zu verweigern, verwenden Sie `StringEquals`, um den Wert der `lambda:SubnetIds` Bedingung zu überprüfen. Im folgenden Beispiel wird Benutzern der Zugriff auf `subnet-1` und `subnet-2` verweigert.
```
{
"Sid": "EnforceOutOfSubnet",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"lambda:SubnetIds": ["subnet-1", "subnet-2"]
}
}
}
```
Um Benutzern den Zugriff auf bestimmte Sicherheitsgruppen zu verweigern, verwenden Sie `StringEquals`, um den Wert der `lambda:SecurityGroupIds`-Bedingung zu überprüfen. Im folgenden Beispiel wird Benutzern der Zugriff auf `sg-1` und `sg-2` verweigert.
```
{
"Sid": "EnforceOutOfSecurityGroups",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"lambda:SecurityGroupIds": ["sg-1", "sg-2"]
}
}
}
]
}
```
#### Benutzern das Erstellen und Aktualisieren von Funktionen mit bestimmten VPC-Einstellungen ermöglichen
Um Benutzern den Zugriff auf bestimmte Bedingungen zu ermöglichen VPCs, verwenden Sie diese Option, `StringEquals` um den Wert der `lambda:VpcIds` Bedingung zu überprüfen. Im folgenden Beispiel können Benutzer auf `vpc-1` und `vpc-2` zugreifen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EnforceStayInSpecificVpc",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"lambda:VpcIds": [
"vpc-1",
"vpc-2"
]
}
}
}
]
}
```
------
Um Benutzern den Zugriff auf bestimmte Subnetze zu ermöglichen, verwenden Sie `StringEquals`, um den Wert der `lambda:SubnetIds`-Bedingung zu überprüfen. Im folgenden Beispiel können Benutzer auf `subnet-1` und `subnet-2` zugreifen.
```
{
"Sid": "EnforceStayInSpecificSubnets",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"ForAllValues:StringEquals": {
"lambda:SubnetIds": ["subnet-1", "subnet-2"]
}
}
}
```
Um Benutzern den Zugriff auf bestimmte Sicherheitsgruppen zu ermöglichen, verwenden Sie `StringEquals`, um den Wert der `lambda:SecurityGroupIds`-Bedingung zu überprüfen. Im folgenden Beispiel können Benutzer auf `sg-1` und `sg-2` zugreifen.
```
{
"Sid": "EnforceStayInSpecificSecurityGroup",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"ForAllValues:StringEquals": {
"lambda:SecurityGroupIds": ["sg-1", "sg-2"]
}
}
}
]
}
```
## VPC-Tutorials
In den folgenden Tutorials verbinden Sie eine Lambda-Funktion mit Ressourcen in Ihrer VPC.
+ [Tutorial: Verwenden einer Lambda-Funktion für den Zugriff auf Amazon RDS in einer Amazon VPC](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-lambda-tutorial.html)
+ [Tutorial: Konfiguration einer Lambda-Funktion für den Zugriff auf Amazon ElastiCache in einer Amazon VPC](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/LambdaRedis.html)
# Lambda-Funktionen Zugriff auf eine Ressource in einer Amazon VPC in einem anderen Konto gewähren
Sie können Ihrer AWS Lambda Funktion Zugriff auf eine Ressource in einer Amazon VPC in Amazon Virtual Private Cloud gewähren, die von einem anderen Konto verwaltet wird, ohne dass eine der VPC dem Internet ausgesetzt wird. Dieses Zugriffsmuster ermöglicht es Ihnen, Daten mit anderen Organisationen gemeinsam zu nutzen. AWS Mithilfe dieses Zugriffsmusters können Sie Daten VPCs mit einem höheren Sicherheits- und Leistungsniveau austauschen als über das Internet. Konfigurieren Sie Ihre Lambda-Funktion so, dass sie eine Amazon VPC-Peering-Verbindung für den Zugriff auf diese Ressourcen verwendet.
**Warnung**
Wenn Sie den Zugriff zwischen Konten zulassen oder überprüfen Sie VPCs, ob Ihr Tarif die Sicherheitsanforderungen der jeweiligen Organisationen erfüllt, die diese Konten verwalten. Wenn Sie die Anweisungen in diesem Dokument befolgen, wirkt sich dies auf die Sicherheitslage Ihrer Ressourcen aus.
In diesem Tutorial verbinden Sie zwei Konten über eine Peering-Verbindung mit IPv4. Sie konfigurieren eine Lambda-Funktion, die noch nicht mit einer Amazon VPC verbunden ist. Sie konfigurieren die DNS-Auflösung, um Ihre Funktion mit Ressourcen zu verbinden, die keine statischen IPs Daten bereitstellen. Informationen zur Anpassung dieser Anweisungen an andere Peering-Szenarien finden Sie im [VPC Peering Guide](https://docs.aws.amazon.com//vpc/latest/peering/what-is-vpc-peering.html).
## Voraussetzungen
Um einer Lambda-Funktion Zugriff auf eine Ressource in einem anderen Konto zu gewähren, benötigen Sie:
+ Eine Lambda-Funktion, die so konfiguriert ist, dass sie sich mit Ihrer Ressource authentifiziert und dann aus ihr liest.
+ Eine Ressource in einem anderen Konto, z. B. einem Amazon-RDS-Cluster, ist über Amazon VPC verfügbar.
+ Anmeldeinformationen für das Konto Ihrer Lambda-Funktion und das Konto Ihrer Ressource. Wenn Sie nicht berechtigt sind, das Konto Ihrer Ressource zu verwenden, wenden Sie sich an einen autorisierten Benutzer, um dieses Konto einzurichten.
+ Berechtigung zum Erstellen und Aktualisieren einer VPC (und zur Unterstützung von Amazon-VPC-Ressourcen), die mit Ihrer Lambda-Funktion verknüpft werden soll.
+ Berechtigung zum Aktualisieren der Ausführungsrolle und der VPC-Konfiguration für Ihre Lambda-Funktion.
+ Berechtigung zum Erstellen einer VPC-Peering-Verbindung im Konto Ihrer Lambda-Funktion.
+ Berechtigung zum Annehmen einer VPC-Peering-Verbindung im Konto Ihrer Ressource.
+ Erlaubnis, die Konfiguration der VPC Ihrer Ressource (und der Unterstützung von Amazon-VPC-Ressourcen) zu aktualisieren.
+ Berechtigung zum Aufrufen Ihrer Lambda-Funktion.
## Erstellen Sie eine Amazon VPC im Konto Ihrer Funktion
Erstellen Sie eine Amazon VPC, Subnetze, Routing-Tabellen und eine Sicherheitsgruppe im Konto Ihrer Lambda-Funktion.
**So erstellen Sie eine VPC, Subnetze und weitere VPC-Ressourcen mit der Konsole**
1. Öffnen Sie die Amazon-VPC-Konsole unter [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Wählen Sie auf dem VPC-Dashboard **VPC erstellen** aus.
1. Geben Sie für den **IPv4 CIDR-Block** einen privaten CIDR-Block an. Ihr CIDR-Block darf sich nicht mit Blöcken überlappen, die in der VPC Ihrer Ressource verwendet werden. Wählen Sie keinen Block aus, den die VPC Ihrer Ressourcen verwendet, um sie Ressourcen IPs zuzuweisen, oder einen Block, der bereits in den Routentabellen in Ihrer Ressourcen-VPC definiert ist. Weitere Informationen zur Definition geeigneter CIDR-Blöcke finden Sie unter [VPC CIDR-Blöcke](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html).
1. Wählen Sie **Anpassen AZs** aus.
1. Wählen Sie dasselbe AZs wie Ihre Ressource aus.
1. Wählen Sie für **Number of public subnets** (Anzahl der öffentlichen Subnetze) **0** aus.
1. Wählen Sie für **VPC endpoints** (VPC-Endpunkte) **None** (Keine) aus.
1. Wählen Sie **VPC erstellen** aus.
## Gewährung von VPC-Berechtigungen für die Ausführungsrolle Ihrer Funktion
Hängen Sie es [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html)an die Ausführungsrolle Ihrer Funktion an, damit sie eine Verbindung herstellen kann VPCs.
**So gewähren Sie der Ausführungsrolle Ihrer Funktion VPC-Berechtigungen**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie den Namen Ihrer Funktion aus.
1. Wählen Sie **Konfiguration**.
1. Wählen Sie **Berechtigungen**.
1. Wählen Sie unter **Rollenname** die Ausführungsrolle.
1. Wählen Sie im Abschnitt **Berechtigungsrichtlinien** die Option **Berechtigungen hinzufügen**.
1. Wählen Sie in der Dropdown-Liste **Richtlinien anhängen**.
1. Geben Sie in das Suchfeld `AWSLambdaVPCAccessExecutionRole` ein.
1. Aktivieren Sie links neben dem Richtliniennamen das Kontrollkästchen.
1. Wählen Sie **Add permissions** (Berechtigungen hinzufügen) aus.
**Um Ihre Funktion an Ihre Amazon VPC anzuhängen**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie den Namen Ihrer Funktion aus.
1. Wählen Sie die Registerkarte **Konfiguration** und anschließend **VPC** aus.
1. Wählen Sie **Bearbeiten** aus.
1. Wählen Sie unter **VPC** Ihre VPC aus
1. Wählen Sie unter **Subnetze** Ihre Subnetze aus.
1. Wählen Sie unter **Sicherheitsgruppen** die Standardsicherheitsgruppe für Ihre VPC.
1. Wählen Sie **Speichern**.
## Erstellen Sie eine VPC-Peering-Verbindungsanfrage
Erstellen Sie eine VPC-Peering-Verbindungsanforderung von der VPC Ihrer Funktion (der VPC des Anforderers) zur VPC Ihrer Ressource (der Akzepter-VPC).
**So erstellen Sie eine VPC-Peering-Verbindung von der VPC Ihrer Funktion**
1. Öffnen Sie die [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Wählen Sie im Navigationsbereich **Peering connections** (Peering-Verbindungen) aus.
1. Wählen Sie **Create peering connection** (Peering-Verbindung erstellen).
1. Wählen Sie für **VPC-ID (Requester)** die VPC Ihrer Funktion aus.
1. Geben Sie unter **Konto-ID** die ID des Kontos Ihrer Ressource ein.
1. Geben Sie für **VPC ID (Accepter)** die VPC Ihrer Ressource ein.
## Bereiten Sie das Konto Ihrer Ressource vor
Um Ihre Peering-Verbindung herzustellen und die VPC Ihrer Ressource für die Verwendung der Verbindung vorzubereiten, melden Sie sich beim Konto Ihrer Ressource mit einer Rolle an, die die in den Voraussetzungen aufgeführten Berechtigungen besitzt. Die Schritte zur Anmeldung können je nachdem, wie das Konto gesichert ist, unterschiedlich sein. Weitere Informationen zur Anmeldung bei einem AWS Konto finden Sie im [AWS Anmelde-Benutzerhandbuch](https://docs.aws.amazon.com//signin/latest/userguide/what-is-sign-in.html). Führen Sie im Konto Ihrer Ressource die folgenden Verfahren aus.
**So akzeptieren Sie die VPC-Peering-Verbindungsanfrage**
1. Öffnen Sie die [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Wählen Sie im Navigationsbereich **Peering connections** (Peering-Verbindungen) aus.
1. Wählen Sie erst die ausstehende VPC-Peering-Verbindung (der Status lautet pending-acceptance) aus.
1. Wählen Sie **Aktionen**.
1. Wählen Sie in der Dropdown-Liste die Option **Anfrage annehmen** aus.
1. Wenn Sie zur Bestätigung aufgefordert werden, wählen Sie **Akzeptieren** aus.
1. Wählen Sie **Meine Routing-Tabellen jetzt ändern**, um der Haupt-Routing-Tabelle für Ihre VPC eine Route hinzuzufügen, sodass Sie Traffic über die Peering-Verbindung senden und empfangen können.
Untersuchen Sie die Routentabellen für die VPC der Ressource. Die von Amazon VPC generierte Route stellt möglicherweise keine Konnektivität her, je nachdem, wie die VPC Ihrer Ressource eingerichtet ist. Suchen Sie nach Konflikten zwischen der neuen Route und der vorhandenen Konfiguration für die VPC. Weitere Informationen zur Fehlerbehebung finden Sie unter [Problembehandlung bei einer VPC-Peering-Verbindung](https://docs.aws.amazon.com/vpc/latest/peering/troubleshoot-vpc-peering-connections.html) im *Amazon Virtual Private Cloud VPC Peering Guide*.
**So aktualisieren Sie die Sicherheitsgruppe für Ihre Ressource**
1. Öffnen Sie die [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Wählen Sie im Navigationsbereich **Sicherheitsgruppen** aus.
1. Wählen Sie die Sicherheitsgruppe für Ihre Ressource aus.
1. Wählen Sie **Aktionen**.
1. Wählen Sie in der Dropdownliste die Option **Regeln für eingehenden Datenverkehr bearbeiten** aus.
1. Wählen Sie **Regel hinzufügen** aus.
1. Geben Sie im Feld **Quelle** die Konto-ID und die Sicherheitsgruppen-ID Ihrer Funktion ein, getrennt durch einen Schrägstrich (z. B. 111122223333/sg-1a2b3c4d).
1. Wählen Sie **Edit outbound rules** (Regeln für ausgehenden Datenverkehr bearbeiten).
1. Prüfen Sie, ob der ausgehende Verkehr eingeschränkt ist. Die VPC-Standardeinstellungen gestatten allen ausgehenden Datenverkehr. Wenn der ausgehende Datenverkehr eingeschränkt ist, fahren Sie mit dem nächsten Schritt fort.
1. Wählen Sie **Regel hinzufügen** aus.
1. Geben Sie im Feld **Ziel** die Konto-ID und die Sicherheitsgruppen-ID Ihrer Funktion ein, getrennt durch einen Schrägstrich (z. B. 111122223333/sg-1a2b3c4d).
1. Wählen Sie **Regeln speichern** aus.
**Aktivieren einer DNS-Auflösung für Ihre Peering-Verbindung**
1. Öffnen Sie die [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Wählen Sie im Navigationsbereich **Peering connections** (Peering-Verbindungen) aus.
1. Wählen Sie Ihre Peering-Verbindung aus.
1. Wählen Sie **Aktionen**.
1. Wählen Sie **DNS-Einstellungen ändern** aus.
1. Wählen Sie unter **Akzepter-DNS-Auflösung** die Option **Erlauben Sie dem anfragenden VPC, DNS von akzeptierenden VPC-Hosts in private IP aufzulösen** aus.
1. Wählen Sie **Änderungen speichern ** aus.
## Aktualisieren Sie die VPC-Konfiguration im Konto Ihrer Funktion
Melden Sie sich beim Konto Ihrer Funktion an und aktualisieren Sie die VPC-Konfiguration.
**So fügen Sie Ihrer VPC-Peering-Verbindung eine Route hinzu**
1. Öffnen Sie die [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Wählen Sie im Navigationsbereich **Route Tables** (Routing-Tabellen) aus.
1. Aktivieren Sie das Kontrollkästchen neben dem Namen der Routentabelle für das Teilnetz, das Sie mit Ihrer Funktion verknüpft haben.
1. Wählen Sie **Aktionen**.
1. Wählen Sie **Routen bearbeiten** aus.
1. Wählen Sie **Route hinzufügen** aus.
1. Geben Sie unter **Ziel** den CIDR-Block für die VPC Ihrer Ressource ein.
1. Wählen Sie als **Ziel** Ihre VPC-Peering-Verbindung aus.
1. Wählen Sie **Änderungen speichern ** aus.
Weitere Informationen zu den Überlegungen, auf die Sie bei der Aktualisierung Ihrer Routing-Tabellen stoßen können, finden Sie unter [Aktualisieren der Routing-Tabellen für eine VPC-Peering-Verbindung](https://docs.aws.amazon.com//vpc/latest/peering/vpc-peering-routing.html).
**Um die Sicherheitsgruppe für Ihre Lambda-Funktion zu aktualisieren**
1. Öffnen Sie die [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Wählen Sie im Navigationsbereich **Sicherheitsgruppen** aus.
1. Wählen Sie **Aktionen**.
1. Wählen Sie **Edit inbound rules** (Regeln für eingehenden Datenverkehr bearbeiten) aus.
1. Wählen Sie **Regel hinzufügen** aus.
1. Geben Sie im Feld **Quelle** die Konto-ID und die Sicherheitsgruppen-ID Ihrer Ressource ein, getrennt durch einen Schrägstrich (z. B. 111122223333/sg-1a2b3c4d).
1. Wählen Sie **Regeln speichern** aus.
**Aktivieren einer DNS-Auflösung für Ihre Peering-Verbindung**
1. Öffnen Sie die [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Wählen Sie im Navigationsbereich **Peering connections** (Peering-Verbindungen) aus.
1. Wählen Sie Ihre Peering-Verbindung aus.
1. Wählen Sie **Aktionen**.
1. Wählen Sie **DNS-Einstellungen ändern** aus.
1. Wählen Sie unter **DNS-Auflösung des Antragstellers** die Option **Zulassen, dass der akzeptierende VPC die DNS von VPC-Hosts des Antragstellers in eine private IP auflöst** aus.
1. Wählen Sie **Änderungen speichern ** aus.
## Testen der -Funktion
**So erstellen Sie ein Testereignis und überprüfen die Ausgabe Ihrer Funktion**
1. Wählen Sie im Bereich **Codequelle** die Option **Testen** aus.
1. Wählen Sie **Neues Ereignis erstellen**.
1. Ersetzen Sie im Bereich **Event JSON** die Standardwerte durch eine Eingabe, die für Ihre Lambda-Funktion geeignet ist.
1. Wählen Sie ** aufrufen** aus.
1. Vergewissern Sie sich auf der Registerkarte **Ausführungsergebnisse**, dass die **Antwort** Ihre erwartete Ausgabe enthält.
Darüber hinaus können Sie die Protokolle Ihrer Funktion überprüfen, um sicherzustellen, dass die Protokolle Ihren Erwartungen entsprechen.
**Um die Aufrufaufzeichnungen Ihrer Funktion in CloudWatch Logs anzuzeigen**
1. Wählen Sie den Tab **Überwachung**.
1. Wählen Sie ** CloudWatch Protokolle anzeigen** aus.
1. Wählen Sie auf der Registerkarte **Protokollstreams** den Protokollstream für den Aufruf Ihrer Funktion aus.
1. Vergewissern Sie sich, dass Ihre Protokolle Ihren Erwartungen entsprechen.
# Aktivieren Sie den Internetzugang für VPC-verbundene Lambda-Funktionen
Standardmäßig werden Lambda-Funktionen in einer von Lambda verwalteten VPC mit Internetzugang ausgeführt. Um auf Ressourcen in einer VPC in Ihrem Konto zuzugreifen, können Sie einer Funktion eine VPC-Konfiguration hinzufügen. Dadurch wird die Funktion auf Ressourcen innerhalb dieser VPC beschränkt, es sei denn, die VPC hat Internetzugang. Auf dieser Seite wird erklärt, wie Sie den Internetzugang für mit VPN verbundene Lambda-Funktionen bereitstellen.
## Ich habe noch keine VPC
### Erstellen Sie die VPC
Der **VPC-Workflow erstellen** erstellt alle VPC-Ressourcen, die für eine Lambda-Funktion für den Zugriff auf das öffentliche Internet von einem privaten Subnetz aus erforderlich sind, einschließlich Subnetzen, NAT-Gateways, Internet-Gateways und Routing-Tabelleneinträgen.
**So erstellen Sie die VPC**
1. Öffnen Sie die Amazon-VPC-Konsole unter [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Wählen Sie auf dem VPC-Dashboard **VPC erstellen** aus.
1. Wählen Sie unter **Zu erstellende Ressourcen** die Option **VPC und mehr** aus.
1. **Konfigurieren Sie die VPC**
1. Geben Sie unter **Name tag auto-generation** (Automatische Generierung des Namens-Tags) einen Namen für die VPC ein.
1. Für den **IPv4 CIDR-Block** können Sie den Standardvorschlag beibehalten oder alternativ den CIDR-Block eingeben, der für Ihre Anwendung oder Ihr Netzwerk erforderlich ist.
1. Wenn Ihre Anwendung über IPv6 Adressen kommuniziert, wählen Sie **IPv6CIDR-Block, von Amazon bereitgestellter CIDR-Block****. IPv6 **
1. **Konfiguration der Subnetze**
1. Wählen Sie für **Anzahl der Availability Zones** **2** aus. Für eine hohe Verfügbarkeit empfehlen wir mindestens zwei. AZs
1. Wählen Sie für **Number of public subnets** (Anzahl der öffentlichen Subnetze) **2** aus.
1. Wählen Sie für **Number of private subnets** (Anzahl der privaten Subnetze) **2** aus.
1. Sie können die standardmäßigen CIDR-Blöcke für die Subnetze beibehalten oder alternativ **CIDR-Blöcke des Subnetzes anpassen** erweitern und einen CIDR-Block eingeben. Weitere Informationen finden Sie unter [CIDR-Blöcke für das Subnetz](https://docs.aws.amazon.com/vpc/latest/userguide/subnet-sizing.html).
1. Wählen Sie für **NAT-Gateways** **1 pro AZ** aus, um die Resilienz zu verbessern.
1. Wählen Sie für ein **Internet-Gateway nur für ausgehenden** Datenverkehr **Ja** aus, wenn Sie sich dafür entschieden haben, einen IPv6 CIDR-Block einzubeziehen.
1. Behalten Sie für **VPC-Endpunkte** den Standardwert (**S3-Gateway**) bei. Für diese Option fallen keine Kosten an. Weitere Informationen finden Sie unter [Arten von VPC-Endpunkten für Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/privatelink-interface-endpoints.html#types-of-vpc-endpoints-for-s3).
1. Behalten Sie für die **DNS-Optionen** die Standardeinstellungen bei.
1. Wählen Sie **VPC erstellen** aus.
### Konfigurieren der Lambda-Funktion
**So konfigurieren Sie eine VPC bei der Funktionserstellung**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie **Create function (Funktion erstellen)**.
1. Geben Sie unter **Basic information (Grundlegende Informationen)** bei **Function name (Funktionsname)** einen Namen für Ihre Funktion ein.
1. Erweiterten Sie **Advanced settings (Erweiterte Einstellungen)**.
1. Wählen Sie **VPC aktivieren** und wählen Sie dann eine VPC aus.
1. (Optional) Um [ausgehenden IPv6 Datenverkehr zuzulassen, wählen Sie IPv6 Datenverkehr](configuration-vpc.md#configuration-vpc-ipv6) **für Dual-Stack-Subnetze zulassen** aus.
1. Wählen Sie für **Subnetze** alle privaten Subnetze aus. Die privaten Subnetze können über die NAT-Gateway auf das Internet zugreifen. Durch die Verbindung einer Funktion mit einem öffentlichen Subnetz erhält sie keinen Internetzugang.
**Anmerkung**
Wenn Sie ** IPv6 Datenverkehr für Dual-Stack-Subnetze zulassen ausgewählt haben, müssen alle ausgewählten Subnetze** über einen CIDR-Block und einen IPv4 CIDR-Block verfügen. IPv6
1. Wählen Sie für **Sicherheitsgruppen** eine Sicherheitsgruppe aus, die ausgehenden Datenverkehr zulässt.
1. Wählen Sie **Funktion erstellen**.
Lambda erstellt automatisch eine Ausführungsrolle mit der [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) AWS verwalteten Richtlinie. Die Berechtigungen in dieser Richtlinie sind nur zum Erstellen von Elastic Network-Schnittstellen für die VPC-Konfiguration und nicht zum Aufrufen Ihrer Funktion erforderlich. Um Berechtigungen mit den geringsten Rechten anzuwenden, können Sie die **AWSLambdaVPCAccessExecutionRole**Richtlinie aus Ihrer Ausführungsrolle entfernen, nachdem Sie die Funktion und die VPC-Konfiguration erstellt haben. Weitere Informationen finden Sie unter [Erforderliche IAM-Berechtigungen](configuration-vpc.md#configuration-vpc-permissions).
**So konfigurieren Sie eine VPC für eine vorhandene Funktion**
Um einer vorhandenen Funktion eine VPC-Konfiguration hinzuzufügen, muss die Ausführungsrolle der Funktion über die [Berechtigung verfügen, elastische Netzwerkschnittstellen zu erstellen und zu verwalten](configuration-vpc.md#configuration-vpc-permissions). Die [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) AWS verwaltete Richtlinie umfasst die erforderlichen Berechtigungen. Um Berechtigungen mit den geringsten Rechten anzuwenden, können Sie die **AWSLambdaVPCAccessExecutionRole**Richtlinie aus Ihrer Ausführungsrolle entfernen, nachdem Sie die VPC-Konfiguration erstellt haben.
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 die Registerkarte **Konfiguration** und anschließend **VPC** aus.
1. Wählen Sie unter **VPC** die Option **Edit (Bearbeiten)** aus.
1. Wählen Sie die VPC aus.
1. (Optional) Um [ausgehenden IPv6 Datenverkehr zuzulassen, wählen Sie Datenverkehr für Dual-Stack-Subnetze](configuration-vpc.md#configuration-vpc-ipv6) **zulassen IPv6 ** aus.
1. Wählen Sie für **Subnetze** alle privaten Subnetze aus. Die privaten Subnetze können über die NAT-Gateway auf das Internet zugreifen. Durch die Verbindung einer Funktion mit einem öffentlichen Subnetz erhält sie keinen Internetzugang.
**Anmerkung**
Wenn Sie ** IPv6 Datenverkehr für Dual-Stack-Subnetze zulassen ausgewählt haben, müssen alle ausgewählten Subnetze** über einen CIDR-Block und einen IPv4 CIDR-Block verfügen. IPv6
1. Wählen Sie für **Sicherheitsgruppen** eine Sicherheitsgruppe aus, die ausgehenden Datenverkehr zulässt.
1. Wählen Sie **Speichern**.
### Testen der Funktion
Verwenden Sie den folgenden Beispielcode, um zu bestätigen, dass Ihre VPC-verbundene Funktion das öffentliche Internet erreichen kann. Bei Erfolg gibt der Code einen `200`-Statuscode zurück. Ist dies nicht der Fall, wird die Funktion abgebrochen.
------
#### [ Node.js ]
1. Fügen Sie im Bereich **Codequelle** der Lambda-Konsole den folgenden Code in die Datei **index.mjs** ein. Die Funktion stellt eine HTTP-GET-Anfrage an einen öffentlichen Endpunkt und gibt den HTTP-Antwortcode zurück, um zu prüfen, ob die Funktion Zugang zum öffentlichen Internet hat.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/code-source-nodejs.png)
**Example – HTTP-Anforderung mit async/await**
```
const url = "https://aws.amazon.com/";
export const handler = async(event) => {
try {
const res = await fetch(url);
console.info("status", res.status);
return res.status;
}
catch (e) {
console.error(e);
return 500;
}
};
```
1. Wählen Sie im Abschnitt **BEREITSTELLEN** die Option **Bereitstellen** aus, um den Code Ihrer Funktion zu aktualisieren:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. Wählen Sie die Registerkarte **Test**.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/test-tab.png)
1. Wählen Sie **Test** aus.
1. Die Funktion gibt einen `200`-Statuscode zurück. Das bedeutet, dass die Funktion über einen ausgehenden Internetzugang verfügt.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/test-successful-200.png)
Wenn die Funktion das öffentliche Internet nicht erreichen kann, erhalten Sie eine Fehlermeldung wie die folgende:
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
#### [ Python ]
1. Fügen Sie im Bereich **Codequelle** der Lambda-Konsole den folgenden Code in die Datei **lambda\$1function.py** ein. Die Funktion stellt eine HTTP-GET-Anfrage an einen öffentlichen Endpunkt und gibt den HTTP-Antwortcode zurück, um zu prüfen, ob die Funktion Zugang zum öffentlichen Internet hat.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/code-source-python.png)
```
import urllib.request
def lambda_handler(event, context):
try:
response = urllib.request.urlopen('https://aws.amazon.com')
status_code = response.getcode()
print('Response Code:', status_code)
return status_code
except Exception as e:
print('Error:', e)
raise e
```
1. Wählen Sie im Abschnitt **BEREITSTELLEN** die Option **Bereitstellen** aus, um den Code Ihrer Funktion zu aktualisieren:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. Wählen Sie die Registerkarte **Test**.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/test-tab.png)
1. Wählen Sie **Test** aus.
1. Die Funktion gibt einen `200`-Statuscode zurück. Das bedeutet, dass die Funktion über einen ausgehenden Internetzugang verfügt.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/test-successful-200.png)
Wenn die Funktion das öffentliche Internet nicht erreichen kann, erhalten Sie eine Fehlermeldung wie die folgende:
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
## Ich habe bereits eine VPC
Wenn Sie bereits über eine VPC verfügen, aber den öffentlichen Internetzugang für eine Lambda-Funktion konfigurieren müssen, gehen Sie wie folgt vor. Bei diesem Verfahren wird davon ausgegangen, dass Ihre VPC mindestens zwei Subnetze hat. Wenn Sie nicht über zwei Subnetze verfügen, finden Sie weitere Informationen unter [Erstellen eines Subnetzes](https://docs.aws.amazon.com/vpc/latest/userguide/create-subnets.html) im *Amazon-VPC-Benutzerhandbuch*.
### Überprüfen der Routing-Tabellen
1. Öffnen Sie die Amazon-VPC-Konsole unter [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Wählen Sie die **VPC ID** aus.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/vpc-id.png)
1. Scrollen Sie nach unten zum Abschnitt **Ressourcenkarte**. Beachten Sie die Zuordnungen in den Routing-Tabellen. Öffnen Sie jede Routing-Tabelle, die einem Subnetz zugeordnet ist.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/route-table-associations.png)
1. Scrollen Sie nach unten zur Registerkarte **Routen**. Überprüfen Sie die Routen, um festzustellen, ob Ihre VPC über die beiden folgenden Routing-Tabellen verfügt. Jede dieser Anforderungen muss durch eine separate Routing-Tabelle erfüllt werden.
+ Internetdatenverkehr (`0.0.0.0/0`für IPv4, `::/0` für IPv6) wird an ein Internet-Gateway () weitergeleitet. `igw-xxxxxxxxxx` Das bedeutet, dass das der Routing-Tabelle zugeordnete Subnetz ein öffentliches Subnetz ist.
**Anmerkung**
Wenn Ihr Subnetz keinen IPv6 CIDR-Block hat, sehen Sie nur die Route (). IPv4 `0.0.0.0/0`
**Example öffentliche Subnetz-Routing-Tabelle**
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/routes-public.png)
+ Internetdatenverkehr für IPv4 (`0.0.0.0/0`) wird an ein NAT-Gateway (`nat-xxxxxxxxxx`) weitergeleitet, das einem öffentlichen Subnetz zugeordnet ist. Dies bedeutet, dass das Subnetz ein privates Subnetz ist, das über das NAT-Gateway auf das Internet zugreifen kann.
**Anmerkung**
Wenn Ihr Subnetz über einen IPv6 CIDR-Block verfügt, muss die Routing-Tabelle auch internetgebundenen IPv6 Verkehr (`::/0`) an ein Internet-Gateway () weiterleiten, das nur für ausgehenden Datenverkehr bestimmt ist. `eigw-xxxxxxxxxx` Wenn Ihr Subnetz keinen IPv6 CIDR-Block hat, wird Ihnen nur die Route () angezeigt. IPv4 `0.0.0.0/0`
**Example Routing-Tabelle für private Subnetze**
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/routes-private.png)
1. Wiederholen Sie den vorherigen Schritt, bis Sie alle Routing-Tabellen überprüft haben, die einem Subnetz in Ihrer VPC zugeordnet sind, und bestätigt haben, dass Sie über eine Routing-Tabelle mit einem Internet-Gateway und eine Routing-Tabelle mit einem NAT-Gateway verfügen.
Wenn Sie nicht über zwei Routing-Tabellen verfügen, eine mit einer Route zu einem Internet-Gateway und eine mit einer Route zu einem NAT-Gateway, gehen Sie wie folgt vor, um die fehlenden Ressourcen und Routing-Tabelleneinträge zu erstellen.
### Erstellen einer Routing-Tabelle
Gehen Sie wie folgt vor, um eine Routing-Tabelle zu erstellen und diese mit einem Subnetz zu verknüpfen.
**Erstellen einer benutzerdefinierten Routing-Tabelle mithilfe der Amazon-VPC-Konsole**
1. Öffnen Sie die Amazon-VPC-Konsole unter [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Wählen Sie im Navigationsbereich **Route Tables** (Routing-Tabellen) aus.
1. Klicken Sie auf **Create Route Table (Routing-Tabelle erstellen)**.
1. (Optional) Geben Sie bei **Name** einen Namen für Ihre Routing-Tabelle ein.
1. Wählen Sie unter **VPC** Ihre VPC aus.
1. (Optional) Sie fügen ein Tag hinzu, indem Sie **Add new tag** (Neuen Tag hinzufügen) auswählen und den Tag-Schlüssel und -Wert eingeben.
1. Klicken Sie auf **Create Route Table (Routing-Tabelle erstellen)**.
1. Wählen Sie auf der Registerkarte **Subnet associations (Subnetzzuordnungen)** die Option **Edit subnet associations (Subnetzzuordnungen bearbeiten)** aus.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/route-table-subnet.png)
1. Aktivieren Sie das Kontrollkästchen für das Subnetz, um es der Routing-Tabelle zuzuordnen.
1. Klicken Sie auf **Save associations** (Zuordnungen speichern).
### Ein Internet-Gateway erstellen
Gehen Sie wie folgt vor, um ein Internet-Gateway zu erstellen, es an Ihre VPC anzuhängen und es der Routing-Tabelle Ihres öffentlichen Subnetzes hinzuzufügen.
**So erstellen Sie ein Internet-Gateway**
1. Öffnen Sie die Amazon-VPC-Konsole unter [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Wählen Sie im Navigationsbereich **Internet Gateways** (Internet-Gateways) aus.
1. Wählen Sie **Create internet gateway (Internet-Gateway erstellen)** aus.
1. (Optional) Geben Sie einen Namen für Ihr Internet-Gateway ein.
1. (Optional) Um ein Tag hinzuzufügen, wählen Sie **Add new tag** (Neuen Tag hinzufügen) aus und geben Sie den Schlüssel und den Wert für den Tag ein.
1. Wählen Sie **Create internet gateway (Internet-Gateway erstellen)** aus.
1. Wählen Sie im Banner oben auf dem Bildschirm die Option **An eine VPC anhängen**, wählen Sie eine verfügbare VPC aus und wählen Sie dann **Internet-Gateway anhängen**.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/igw-attach-vpc.png)
1. Wählen Sie die **VPC ID** aus.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/igw-subnet-1.png)
1. Wählen Sie die **VPC ID**, um die VPC-Detailseite zu öffnen.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/igw-your-vpcs.png)
1. Blättern Sie nach unten zum Abschnitt **Ressourcenzuordnung** und wählen Sie dann ein Subnetz aus. Die Subnetzdetails werden auf der neuen Registerkarte angezeigt.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/vpc-subnets.png)
1. Wählen Sie den Link unter **Routing-Tabelle** aus.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/subnet-route-table.png)
1. Wählen Sie die **Routing-Tabellen-ID**, um die Detailseite der Routing-Tabelle zu öffnen.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/route-table-id.png)
1. Wählen Sie unter **Routes** (Routen) **Routen bearbeiten** aus.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/edit-routes.png)
1. Wählen Sie **Route hinzufügen** und geben Sie sie dann `0.0.0.0/0` in das Feld **Ziel** ein.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/create-route-1.png)
1. Wählen Sie für **Target** **Internet-Gateway** und dann das Internet-Gateway aus, das Sie zuvor erstellt haben. Wenn Ihr Subnetz über einen IPv6 CIDR-Block verfügt, müssen Sie auch eine Route für `::/0` dasselbe Internet-Gateway hinzufügen.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/create-route-2.png)
1. Wählen Sie **Änderungen speichern ** aus.
### Erstellen eines NAT-Gateways
Gehen Sie wie folgt vor, um ein NAT-Gateway zu erstellen, es einem öffentlichen Subnetz zuzuordnen und es dann der Routing-Tabelle Ihres privaten Subnetzes hinzuzufügen.
**Um ein NAT-Gateway zu erstellen und es einem öffentlichen Subnetz zuzuordnen**
1. Klicken Sie im Navigationsbereich auf **NAT-Gateways**.
1. Wählen Sie **NAT-Gateway erstellen** aus.
1. (Optional) Geben Sie einen Namen für Ihr NAT-Gateway ein.
1. Wählen Sie unter **Subnetz** ein öffentliches Subnetz in Ihrer VPC. (Ein öffentliches Subnetz ist ein Subnetz, das eine direkte Route zu einem Internet-Gateway in seiner Routing-Tabelle hat).
**Anmerkung**
NAT-Gateways sind einem öffentlichen Subnetz zugeordnet, der Eintrag in der Routing-Tabelle befindet sich jedoch im privaten Subnetz.
1. Wählen Sie als **Elastische IP-Zuweisungs-ID** eine elastische IP-Adresse oder **Elastische IP zuweisen** aus.
1. Wählen Sie **NAT-Gateway erstellen** aus.
**So fügen Sie eine Route zum NAT-Gateway in der Routentabelle des privaten Subnetzes hinzu**
1. Wählen Sie im Navigationsbereich **Subnetze** aus.
1. Wählen Sie ein privates Subnetz in Ihrer VPC. (Ein privates Subnetz ist ein Subnetz, das keine Route zu einem Internet-Gateway in seiner Routing-Tabelle hat).
1. Wählen Sie den Link unter **Routing-Tabelle** aus.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/subnet-route-table.png)
1. Wählen Sie die **Routing-Tabellen-ID**, um die Detailseite der Routing-Tabelle zu öffnen.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/route-table-id.png)
1. Scrollen Sie nach unten und wählen Sie die Registerkarte **Routes (Routen)** auf **Edit routes (Routen bearbeiten)**.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/route-table-edit-routes.png)
1. Wählen Sie **Route hinzufügen** und geben Sie sie dann `0.0.0.0/0` in das Feld **Ziel** ein.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/create-route-1.png)
1. Wählen Sie für **Target** **NAT-Gateway** und dann das NAT-Gateway aus, das Sie zuvor erstellt haben.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/create-route-nat.png)
1. Wählen Sie **Änderungen speichern ** aus.
### Erstellen Sie ein Internet-Gateway nur für ausgehenden Datenverkehr (nur) IPv6
Führen Sie die folgenden Schritte aus, um ein reines Egress-Internet-Gateway zu erstellen und es zur Routing-Tabelle Ihres privaten Subnetzes hinzuzufügen.
**So erstellen Sie ein Internet-Gateway nur für ausgehenden Verkehr**
1. Wählen Sie im Navigationsbereich **Internet-Gateways für ausgehenden Datenverkehr**.
1. Klicken Sie auf **Internet-Gateway für ausgehenden Datenverkehr erstellen**.
1. (Optional) Geben Sie einen Name ein.
1. Wählen Sie die VPC aus, in der Sie das Internet-Gateway für ausgehenden Verkehr erstellen möchten.
1. Klicken Sie auf **Internet-Gateway für ausgehenden Datenverkehr erstellen**.
1. Wählen Sie den Link unter **Angehängte VPC-ID** aus.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/eigw-details.png)
1. Wählen Sie den Link unter **VPC ID**, um die VPC-Detailseite zu öffnen.
1. Blättern Sie nach unten zum Abschnitt **Ressourcenzuordnung** und wählen Sie dann ein privates Subnetz aus. (Ein privates Subnetz ist ein Subnetz, das keine Route zu einem Internet-Gateway in seiner Routing-Tabelle hat). Die Subnetzdetails werden auf der neuen Registerkarte angezeigt.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/vpc-subnet-private.png)
1. Wählen Sie den Link unter **Routing-Tabelle** aus.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/private-subnet-route-table.png)
1. Wählen Sie die **Routing-Tabellen-ID**, um die Detailseite der Routing-Tabelle zu öffnen.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/route-table-id.png)
1. Wählen Sie unter **Routes** (Routen) **Routen bearbeiten** aus.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/edit-routes.png)
1. Wählen Sie **Route hinzufügen** und geben Sie sie dann `::/0` in das Feld **Ziel** ein.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/create-route-1.png)
1. Wählen Sie für **Target** **Nur Internet-Gateway für den Ausgang** und dann das Internet-Gateway aus, das Sie zuvor erstellt haben.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/eigw-route.png)
1. Wählen Sie **Änderungen speichern ** aus.
### Konfigurieren der Lambda-Funktion
**So konfigurieren Sie eine VPC bei der Funktionserstellung**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie **Create function (Funktion erstellen)**.
1. Geben Sie unter **Basic information (Grundlegende Informationen)** bei **Function name (Funktionsname)** einen Namen für Ihre Funktion ein.
1. Erweiterten Sie **Advanced settings (Erweiterte Einstellungen)**.
1. Wählen Sie **VPC aktivieren** und wählen Sie dann eine VPC aus.
1. (Optional) Um [ausgehenden IPv6 Datenverkehr zuzulassen, wählen Sie Datenverkehr für Dual-Stack-Subnetze](configuration-vpc.md#configuration-vpc-ipv6) **zulassen IPv6 ** aus.
1. Wählen Sie für **Subnetze** alle privaten Subnetze aus. Die privaten Subnetze können über die NAT-Gateway auf das Internet zugreifen. Durch die Verbindung einer Funktion mit einem öffentlichen Subnetz erhält sie keinen Internetzugang.
**Anmerkung**
Wenn Sie ** IPv6 Datenverkehr für Dual-Stack-Subnetze zulassen ausgewählt haben, müssen alle ausgewählten Subnetze** über einen CIDR-Block und einen IPv4 CIDR-Block verfügen. IPv6
1. Wählen Sie für **Sicherheitsgruppen** eine Sicherheitsgruppe aus, die ausgehenden Datenverkehr zulässt.
1. Wählen Sie **Funktion erstellen**.
Lambda erstellt automatisch eine Ausführungsrolle mit der [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) AWS verwalteten Richtlinie. Die Berechtigungen in dieser Richtlinie sind nur zum Erstellen von Elastic Network-Schnittstellen für die VPC-Konfiguration und nicht zum Aufrufen Ihrer Funktion erforderlich. Um Berechtigungen mit den geringsten Rechten anzuwenden, können Sie die **AWSLambdaVPCAccessExecutionRole**Richtlinie aus Ihrer Ausführungsrolle entfernen, nachdem Sie die Funktion und die VPC-Konfiguration erstellt haben. Weitere Informationen finden Sie unter [Erforderliche IAM-Berechtigungen](configuration-vpc.md#configuration-vpc-permissions).
**So konfigurieren Sie eine VPC für eine vorhandene Funktion**
Um einer vorhandenen Funktion eine VPC-Konfiguration hinzuzufügen, muss die Ausführungsrolle der Funktion über die [Berechtigung verfügen, elastische Netzwerkschnittstellen zu erstellen und zu verwalten](configuration-vpc.md#configuration-vpc-permissions). Die [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) AWS verwaltete Richtlinie umfasst die erforderlichen Berechtigungen. Um Berechtigungen mit den geringsten Rechten anzuwenden, können Sie die **AWSLambdaVPCAccessExecutionRole**Richtlinie aus Ihrer Ausführungsrolle entfernen, nachdem Sie die VPC-Konfiguration erstellt haben.
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 die Registerkarte **Konfiguration** und anschließend **VPC** aus.
1. Wählen Sie unter **VPC** die Option **Edit (Bearbeiten)** aus.
1. Wählen Sie die VPC aus.
1. (Optional) Um [ausgehenden IPv6 Datenverkehr zuzulassen, wählen Sie Datenverkehr für Dual-Stack-Subnetze](configuration-vpc.md#configuration-vpc-ipv6) **zulassen IPv6 ** aus.
1. Wählen Sie für **Subnetze** alle privaten Subnetze aus. Die privaten Subnetze können über die NAT-Gateway auf das Internet zugreifen. Durch die Verbindung einer Funktion mit einem öffentlichen Subnetz erhält sie keinen Internetzugang.
**Anmerkung**
Wenn Sie ** IPv6 Datenverkehr für Dual-Stack-Subnetze zulassen ausgewählt haben, müssen alle ausgewählten Subnetze** über einen CIDR-Block und einen IPv4 CIDR-Block verfügen. IPv6
1. Wählen Sie für **Sicherheitsgruppen** eine Sicherheitsgruppe aus, die ausgehenden Datenverkehr zulässt.
1. Wählen Sie **Speichern**.
### Testen der Funktion
Verwenden Sie den folgenden Beispielcode, um zu bestätigen, dass Ihre VPC-verbundene Funktion das öffentliche Internet erreichen kann. Bei Erfolg gibt der Code einen `200`-Statuscode zurück. Ist dies nicht der Fall, wird die Funktion abgebrochen.
------
#### [ Node.js ]
1. Fügen Sie im Bereich **Codequelle** der Lambda-Konsole den folgenden Code in die Datei **index.mjs** ein. Die Funktion stellt eine HTTP-GET-Anfrage an einen öffentlichen Endpunkt und gibt den HTTP-Antwortcode zurück, um zu prüfen, ob die Funktion Zugang zum öffentlichen Internet hat.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/code-source-nodejs.png)
**Example – HTTP-Anforderung mit async/await**
```
const url = "https://aws.amazon.com/";
export const handler = async(event) => {
try {
const res = await fetch(url);
console.info("status", res.status);
return res.status;
}
catch (e) {
console.error(e);
return 500;
}
};
```
1. Wählen Sie im Abschnitt **BEREITSTELLEN** die Option **Bereitstellen** aus, um den Code Ihrer Funktion zu aktualisieren:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. Wählen Sie die Registerkarte **Test**.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/test-tab.png)
1. Wählen Sie **Test** aus.
1. Die Funktion gibt einen `200`-Statuscode zurück. Das bedeutet, dass die Funktion über einen ausgehenden Internetzugang verfügt.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/test-successful-200.png)
Wenn die Funktion das öffentliche Internet nicht erreichen kann, erhalten Sie eine Fehlermeldung wie die folgende:
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
#### [ Python ]
1. Fügen Sie im Bereich **Codequelle** der Lambda-Konsole den folgenden Code in die Datei **lambda\$1function.py** ein. Die Funktion stellt eine HTTP-GET-Anfrage an einen öffentlichen Endpunkt und gibt den HTTP-Antwortcode zurück, um zu prüfen, ob die Funktion Zugang zum öffentlichen Internet hat.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/code-source-python.png)
```
import urllib.request
def lambda_handler(event, context):
try:
response = urllib.request.urlopen('https://aws.amazon.com')
status_code = response.getcode()
print('Response Code:', status_code)
return status_code
except Exception as e:
print('Error:', e)
raise e
```
1. Wählen Sie im Abschnitt **BEREITSTELLEN** die Option **Bereitstellen** aus, um den Code Ihrer Funktion zu aktualisieren:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. Wählen Sie die Registerkarte **Test**.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/test-tab.png)
1. Wählen Sie **Test** aus.
1. Die Funktion gibt einen `200`-Statuscode zurück. Das bedeutet, dass die Funktion über einen ausgehenden Internetzugang verfügt.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/test-successful-200.png)
Wenn die Funktion das öffentliche Internet nicht erreichen kann, erhalten Sie eine Fehlermeldung wie die folgende:
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
# Verbinden von VPC-Endpunkten von eingehenden Schnittstellen für Lambda
Wenn Sie Amazon Virtual Private Cloud (Amazon VPC) zum Hosten Ihrer AWS-Ressourcen verwenden, können Sie eine Verbindung zwischen Ihrer VPC und Lambda herstellen. Sie können mit dieser Verbindung Ihre Lambda-Funktion aufrufen, ohne das öffentliche Internet überqueren.
Um eine private Verbindung zwischen Ihrer VPC und Lambda herzustellen, erstellen Sie einen [Schnittstellen-VPC-Endpunkt](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html). Schnittstellenendpunkte werden von [AWS PrivateLink](https://aws.amazon.com/privatelink) betrieben, sodass Sie privat ohne Internet-Gateway, NAT-Gerät, VPN-Verbindung oder AWS Direct Connect-Verbindung auf Lambda-APIs zugreifen können. Die Instances in Ihrer VPC benötigen für die Kommunikation mit Lambda-APIs keine öffentlichen IP-Adressen. Datenverkehr zwischen Ihrer VPC und Lambda verlässt das AWS-Netzwerk nicht.
Jeder Schnittstellenendpunkt wird durch eine oder mehrere [Elastic Network-Schnittstellen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) in Ihren Subnetzen dargestellt. Eine Netzwerkschnittstelle stellt eine private IP-Adresse bereit, die als Einstiegspunkt für den Datenverkehr zu Lambda dient.
**Topics**
+ [
## Überlegungen für Lambda-Schnittstellenendpunkte
](#vpc-endpoint-considerations)
+ [
## Erstellen eines Schnittstellenendpunkts für Lambda
](#vpc-endpoint-create)
+ [
## Erstellen einer Richtlinie des Schnittstellenendpunkts für Lambda
](#vpc-endpoint-policy)
## Überlegungen für Lambda-Schnittstellenendpunkte
Bevor Sie einen Schnittstellenendpunkt für Lambda einrichten, lesen Sie unbedingt die [Eigenschaften und Einschränkungen des Schnittstellenendpunkts](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#vpce-interface-limitations) im *Amazon-VPC-Benutzerhandbuch*.
Sie können alle Lambda-API-Operationen von Ihrer VPC aus aufrufen. Sie können die Lambda-Funktion beispielsweise aufrufen, indem Sie die `Invoke`-API aus Ihrer VPC aufrufen. Die vollständige Liste der Lambda-APIs finden Sie unter [Aktionen](https://docs.aws.amazon.com/lambda/latest/dg/API_Operations.html) in der Lambda-API-Referenz.
`use1-az3` ist eine Region mit begrenzter Kapazität für Lambda-VPC-Funktionen. Sie sollten in dieser Availability Zone keine Subnetze für Ihre Lambda-Funktionen verwenden, da dies im Falle eines Ausfalls zu einer verringerten zonalen Redundanz führen kann.
### Keep-Alive für persistente Verbindungen
Lambda löscht Leerlaufverbindungen im Laufe der Zeit. Daher müssen Sie eine Keep-Alive-Direktive verwenden, um dauerhafte Verbindungen zu pflegen. 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) im *AWS SDK für JavaScript-Entwicklerhandbuch*.
### Überlegungen zur Abrechnung
Es fallen keine zusätzlichen Kosten für den Zugriff auf eine Lambda-Funktion über einen Schnittstellen-Endpunkt an. Weitere Informationen über Lambda-Preise finden Sie unter [AWS Lambda-Preise](https://aws.amazon.com/lambda/pricing/).
Die Standardpreise für AWS PrivateLink gelten für Schnittstellenendpunkte für Lambda. IhremAWS -Konto wird jede Stunde in Rechnung gestellt, die ein Schnittstellenendpunkt in jeder Availability Zone bereitgestellt wird und für Daten, die über den Schnittstellenendpunkt verarbeitet werden. Weitere Informationen zu Preisen für Schnittstellenendpunkte finden Sie unter [AWS PrivateLink-Preise](https://aws.amazon.com/privatelink/pricing/).
### Überlegungen zu VPC Peering
Sie können andere VPCs mit Schnittstellenendpunkten über [VPC-Peering](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) mit der VPC verbinden. VPC-Peering ist eine Netzwerkverbindung zwischen zwei VPCs. Sie können eine VPC-Peering-Verbindung zwischen Ihren eigenen beiden VPCs oder mit einer VPC in einem anderen AWS-Konto herstellen. Die VPCs können sich auch in zwei verschiedenen AWS-Regionen befinden.
Der Datenverkehr zwischen über Peering verbundenen VPCs bleibt im AWS-Netzwerk und wird nicht über das öffentliche Internet übertragen. Sobald VPCs per Peering verbunden sind, können Ressourcen wie Amazon-Elastic-Compute-Cloud-(Amazon-EC2)-Instances, Amazon-Relational-Database-Service-(Amazon-RDS)-Instances oder VPC-fähige Lambda-Funktionen in beiden VPCs über Schnittstellenendpunkte, die in einem der VPCs erstellt wurden, auf die Lambda-API zugreifen.
## Erstellen eines Schnittstellenendpunkts für Lambda
Sie können einen Schnittstellenendpunkt für Lambda entweder über die Amazon-VPC-Konsole oder die AWS Command Line Interface (AWS CLI) erstellen. Weitere Informationen finden Sie unter [Erstellung eines Schnittstellenendpunkts](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#create-interface-endpoint) im *Amazon VPC Benutzerhandbuch*.
**So erstellen Sie einen Schnittstellenendpunkt für Lambda (Konsole)**
1. Öffnen Sie die Seite [Endpunkte](https://console.aws.amazon.com/vpc/home?#Endpoints) der Amazon-VPC-Konsole.
1. Klicken Sie auf **Create Endpoint**.
1. Stellen Sie sicher, dass für **Service-Kategorie** die Option **AWS-Services** ausgewählt ist.
1. Wählen Sie als **Service Name (Servicename)** **com.amazonaws.*region*.lambda** aus. Stellen Sie sicher, dass als **Typ** die Option **Schnittstelle** gewählt ist.
1. Auswählen von VPC und Subnetzen
1. Um ein privates DNS für den Schnittstellenendpunkt zu aktivieren, aktivieren Sie das Kontrollkästchen für **Name eines DNS aktivieren**. Wir empfehlen die Aktivierung privater DNS-Namen für Ihren VPC-Endpunkt für AWS-Services. Dadurch wird sichergestellt, dass Anfragen, die die Endpunkte des öffentlichen Dienstes verwenden, z. B. Anfragen, die über ein AWS-SDK gestellt wurden, an Ihren VPC-Endpunkt weitergeleitet werden.
1. Wählen Sie unter **Security group (Sicherheitsgruppe)** eine oder mehrere Sicherheitsgruppen aus.
1. Wählen Sie **Create endpoint**.
Um die private DNS-Option verwenden zu können, müssen Sie `enableDnsHostnames` und `enableDnsSupportattributes` Ihrer VPC festlegen. Weitere Informationen finden Sie unter [Anzeigen und Aktualisieren der DNS-Unterstützung für Ihre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-updating) im *Amazon-VPC-Benutzerhandbuch*. Wenn Sie einen privaten DNS für den Schnittstellenendpunkt aktivieren, können Sie mittels seines standardmäßigen DNS-Namen für die Region, beispielsweise , API-Anforderungen an Lambda senden., `lambda.us-east-1.amazonaws.com`. Weitere Service-Endpunkte finden Sie unter [Service-Endpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) im *Allgemeine AWS-Referenz*.
Weitere Informationen finden Sie unter [Zugriff auf einen Service über einen Schnittstellenendpunkt](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#access-service-though-endpoint) im *Amazon VPC Benutzerhandbuch*.
Informationen zum Erstellen und Konfigurieren eines Endpunkts mit CloudFormation finden Sie in der [AWS::EC2::VPCEndpoint](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html)-Ressource im *AWS CloudFormation-Benutzerhandbuch*.
**So erstellen Sie einen Schnittstellen-Endpunkt für Lambda (AWS CLI)**
Verwenden Sie den [create-vpc-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html)-Befehl und geben Sie die VPC-ID an, den VPC-Endpunkttyp (Schnittstelle), den Servicenamen, die Subnetze, die den Endpunkt verwenden sollen, sowie die Sicherheitsgruppen, die den Endpunktnetzwerkschnittstellen zugeordnet werden sollen. Zum Beispiel:
```
aws ec2 create-vpc-endpoint
--vpc-id vpc-ec43eb89
--vpc-endpoint-type Interface
--service-name com.amazonaws.us-east-1.lambda
--subnet-id subnet-abababab
--security-group-id sg-1a2b3c4d
```
## Erstellen einer Richtlinie des Schnittstellenendpunkts für Lambda
Wenn Sie steuern möchten, wer Ihren Schnittstellenendpunkt verwenden kann und auf welche Lambda-Funktionen der Benutzer zugreifen kann, können Sie eine Endpunktrichtlinie an Ihren Endpunkt anfügen. Die Richtlinie gibt die folgenden Informationen an:
+ Prinzipal, der die Aktionen ausführen kann
+ Die Aktionen, die der Prinzipal ausführen kann.
+ Die Ressourcen, auf denen der Prinzipal Aktionen ausführen kann.
Weitere Informationen finden Sie unter [Steuerung des Zugriffs auf Services mit VPC-Endpunkten](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html) im *Amazon VPC Benutzerhandbuch*.
**Beispiel: Schnittstellenendpunktrichtlinie für Lambda-Aktionen**
Im Folgenden finden Sie ein Beispiel für eine Endpunktrichtlinie für Lambda. Bei Anfügung an einen Endpunkt ermöglicht diese Richtlinie dem Benutzer `MyUser` die Funktion `my-function` aufzurufen.
**Anmerkung**
Sie müssen sowohl den qualifizierten als auch den nicht qualifizierten Funktions-ARN in die Ressource aufnehmen.
```
{
"Statement":[
{
"Principal":
{
"AWS": "arn:aws:iam::111122223333:user/MyUser"
},
"Effect":"Allow",
"Action":[
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:us-east-2:123456789012:function:my-function",
"arn:aws:lambda:us-east-2:123456789012:function:my-function:*"
]
}
]
}
```
# Konfigurieren des Dateisystemzugriffs für Lambda-Funktionen
Sie können eine Funktion konfigurieren, um eine Bindungsbereitstellung für ein Amazon-Elastic-File-System-(Amazon-EFS)-Dateisystem in einem lokalen Verzeichnis zu erstellen. Mit Amazon EFS kann Ihr Funktionscode auf freigegebene Ressourcen sicher und mit hoher Nebenläufigkeit zugreifen und diese ändern.
## Unterstützte Regionen
Amazon EFS für Lambda ist in allen [kommerziellen Regionen](https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#region) außer Asien-Pazifik (Neuseeland), Asien-Pazifik (Taipeh), Asien-Pazifik (Malaysia), Mexiko (Zentral), Asien-Pazifik (Thailand) und Kanada West (Calgary) verfügbar.
**Topics**
+ [
## Unterstützte Regionen
](#configuration-filesystem-supported-regions)
+ [
## Ausführungsrolle und Benutzerberechtigungen
](#configuration-filesystem-permissions)
+ [
## Konfigurieren eines Dateisystems und eines Zugriffspunkts
](#configuration-filesystem-setup)
+ [
## Herstellen einer Verbindung mit einem Dateisystem (Konsole)
](#configuration-filesystem-config)
## Ausführungsrolle und Benutzerberechtigungen
Wenn das Dateisystem keine benutzerkonfigurierte AWS Identity and Access Management (IAM)-Richtlinie hat, verwendet EFS eine Standardrichtlinie, die jedem Client, der über ein Dateisystem-Mounting-Ziel eine Verbindung zum Dateisystem herstellen kann, vollen Zugriff gewährt. Wenn das Dateisystem eine benutzerkonfigurierte IAM-Richtlinie hat, muss die Ausführungsrolle Ihrer Funktion die richtigen `elasticfilesystem`-Berechtigungen besitzen.
**Berechtigungen für die Ausführungsrolle**
+ **ElasticFileSystem:ClientMount**
+ **ElasticFileSystem:ClientWrite (nicht für schreibgeschützte Verbindungen erforderlich)**
Diese Berechtigungen sind in der verwalteten Richtlinie **AmazonElasticFileSystemClientReadWriteAccess** enthalten. Darüber hinaus muss Ihre Ausführungsrolle die [Berechtigungen, die für die Verbindung mit der VPC des Dateisystems erforderlich sind,](configuration-vpc.md#configuration-vpc-permissions) besitzen.
Wenn Sie ein Dateisystem konfigurieren, werden Ihre Berechtigungen von Lambda verwendet, um Bindungsbereitstellung-Ziele zu überprüfen. Um eine Funktion für die Herstellung von Verbindungen mit einer VPC zu konfigurieren, benötigt Ihr Benutzer die folgenden Berechtigungen:
**Benutzerberechtigungen**
+ **ElasticFileSystem:DescribeMountTargets**
## Konfigurieren eines Dateisystems und eines Zugriffspunkts
Erstellen Sie ein Dateisystem in Amazon EFS mit einem Bindungsbereitstellung-Ziel in jeder Availability Zone, zu der Ihre Funktion eine Verbindung herstellt. Verwenden Sie für Leistung und Ausfallsicherheit mindestens zwei Availability Zones. In einer einfachen Konfiguration könnten Sie beispielsweise eine VPC mit zwei privaten Subnetzen in separaten Availability Zones haben. Die Funktion verbindet sich mit beiden Subnetzen und ein Mount-Ziel ist in jedem verfügbar. Stellen Sie sicher, dass NFS-Datenverkehr (Port 2049) von den Sicherheitsgruppen erlaubt ist, die von den Funktionen und Mount-Zielen verwendet werden.
**Anmerkung**
Wenn Sie ein Dateisystem erstellen, wählen Sie einen Leistungsmodus, der später nicht geändert werden kann. **Der Allzweckmodus** hat eine geringere Latenz, und der **Max I/O-Modus** unterstützt einen höheren maximalen Durchsatz und IOPS. Hilfe bei der Auswahl finden Sie unter [Amazon-EFS-Leistung](https://docs.aws.amazon.com/efs/latest/ug/performance.html) im *Amazon-Elastic-File-System-Benutzerhandbuch*.
Ein Zugriffspunkt verbindet jede Instance der Funktion mit dem richtigen Mount-Ziel für die Availability Zone, mit der sie eine Verbindung herstellt. Um eine optimale Leistung zu erzielen, erstellen Sie einen Zugriffspunkt mit einem Nicht-Stammpfad und beschränken Sie die Anzahl der Dateien, die Sie in jedem Verzeichnis erstellen. Im folgenden Beispiel wird ein Verzeichnis mit dem Namen `my-function` auf dem Dateisystem erstellt und die Besitzer-ID auf 1001 mit Standardverzeichnisberechtigungen (755) festgelegt.
**Example Konfiguration von Zugriffspunkten**
+ **Name (Name** – `files`
+ **Benutzer-ID** – `1001`
+ **Gruppen-ID** – `1001`
+ **Pfad** – `/my-function`
+ **Berechtigungen** – `755`
+ **Benutzer-ID des Eigentümers** – `1001`
+ **Gruppen-Benutzer-ID** – `1001`
Wenn eine Funktion den Zugriffspunkt verwendet, erhält sie die Benutzer-ID 1001 und hat vollen Zugriff auf das Verzeichnis.
Weitere Informationen finden Sie in den folgenden Themen im *Amazon-Elastic-File-System-Benutzerhandbuch*:
+ [Erstellen von Ressourcen für Amazon EFS](https://docs.aws.amazon.com/efs/latest/ug/creating-using.html)
+ [Arbeiten mit Benutzern, Gruppen und Berechtigungen](https://docs.aws.amazon.com/efs/latest/ug/accessing-fs-nfs-permissions.html)
## Herstellen einer Verbindung mit einem Dateisystem (Konsole)
Eine Funktion stellt eine Verbindung mit einem Dateisystem über das lokale Netzwerk in einer VPC her. Die Subnetze, mit denen Ihre Funktion eine Verbindung herstellt, können dieselben Subnetze sein, die Mounting-Punkte für Ihr Dateisystem enthalten, oder Subnetze in derselben Availability Zone, die NFS-Datenverkehr (Port 2049) an das Dateisystem weiterleiten kann.
**Anmerkung**
Wenn Ihre Funktion noch nicht mit einer VPC verbunden ist, finden Sie weitere Informationen unter [Lambda-Funktionen Zugriff auf Ressourcen in einer Amazon VPC gewähren](configuration-vpc.md).
**So konfigurieren Sie den Zugriff auf Dateisysteme**
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 **Konfiguration** und dann **Dateisysteme**.
1. Wählen Sie unter **Dateisystem** die Option **Dateisystem hinzufügen**.
1. Konfigurieren Sie die folgenden Eigenschaften:
+ **EFS-Dateisystem** – Der Zugriffspunkt für ein Dateisystem in derselben VPC.
+ **Lokaler Bindungsbereitstellungspfad** – Der Speicherort, an dem das Dateisystem für die Lambda-Funktion gemountet ist, beginnend mit `/mnt/`.
**Preisgestaltung**
Amazon EFS erhebt Gebühren für Speicher und Durchsatz, mit Raten, die je nach Speicherklasse variieren. Details dazu finden Sie unter [Amazon-EFS-Preise](https://aws.amazon.com/efs/pricing).
Lambda erhebt Gebühren für die Datenübertragung zwischen VPCs. Dies gilt nur, wenn die VPC Ihrer Funktion auf eine andere VPC mit einem Dateisystem gepeered wird. Die Preise sind die gleichen wie für die Amazon-EC2-Datenübertragung zwischen VPCs in derselben Region. Einzelheiten finden Sie unter [Lambda – Preise](https://aws.amazon.com/lambda/pricing).
# Erstellung eines Alias für eine Lambda-Funktion
Sie können für Ihre Lambda-Funktion Aliasse erstellen. Ein Lambda-Alias ist ein Zeiger auf eine Version einer Funktion, der aktualisiert werden kann. Die Benutzer der Funktion können über den Amazon-Ressourcennamen (ARN) des Alias auf die Funktionsversion zugreifen. Wenn Sie eine neue Version bereitstellen, können Sie den Alias aktualisieren, um ihn auf die neue Version umzustellen oder den Datenverkehr zwischen zwei Versionen aufzuteilen.
------
#### [ Console ]
**So erstellen Sie einen Alias mit der Konsole**
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 **Aliasse** und dann **Alias erstellen** aus.
1. Führen Sie auf der Seite **Alias erstellen** die folgenden Schritte aus:
1. Machen Sie für den Alias eine Angabe unter **Name**.
1. (Optional) Geben Sie eine **Beschreibung** für den Alias ein.
1. Wählen Sie unter **Version**, eine Funktionsversion aus, auf die der Alias verweisen soll.
1. (Optional) Um das Routing für den Alias zu konfigurieren, erweitern Sie den Eintrag **Gewichteter Alias**. Weitere Informationen finden Sie unter [Implementieren Sie Lambda Canary-Bereitstellungen mithilfe eines gewichteten Alias](configuring-alias-routing.md).
1. Wählen Sie **Save (Speichern)** aus.
------
#### [ AWS CLI ]
Verwenden Sie den Befehl [create-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-alias.html), um einen Alias mit der AWS Command Line Interface (AWS CLI) zu erstellen.
```
aws lambda create-alias \
--function-name my-function \
--name alias-name \
--function-version version-number \
--description " "
```
Verwenden Sie den Befehl [update-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-alias.html), um einen Alias so zu ändern, dass er auf eine neue Version der Funktion verweist.
```
aws lambda update-alias \
--function-name my-function \
--name alias-name \
--function-version version-number
```
Verwenden Sie den Befehl [delete-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/delete-alias.html), um einen Alias zu löschen.
```
aws lambda delete-alias \
--function-name my-function \
--name alias-name
```
Die obigen AWS CLI-Befehle entsprechen den folgenden Lambda-API-Aktionen.
+ [CreateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_CreateAlias.html)
+ [UpdateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateAlias.html)
+ [DeleteAlias](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteAlias.html)
------
# Verwendung von Lambda-Aliasen in Ereignisquellen und Berechtigungsrichtlinien
Jeder Alias hat einen eindeutigen ARN. Ein Alias kann nur auf eine Funktionsversion verweisen, nicht auf einen anderen Alias. Sie können einen Alias aktualisieren, um auf eine neue Version der Funktion zu verweisen.
Ereignisquellen wie Amazon Simple Storage Service (Amazon S3) rufen Ihre Lambda-Funktion auf. Diese Ereignisquellen pflegen eine Zuweisung, die die Funktion identifiziert, die beim Auftreten von Ereignissen aufgerufen werden soll. Wenn Sie in der Mappingkonfiguration einen Lambda-Funktionsalias angeben, müssen Sie das Mapping nicht aktualisieren, wenn sich die Funktionsversion ändert. Weitere Informationen finden Sie unter [Wie Lambda Datensätze aus Stream- und warteschlangenbasierten Ereignisquellen verarbeitet](invocation-eventsourcemapping.md).
In einer Ressourcenrichtlinie können Sie Berechtigungen für Ereignisquellen zur Verwendung Ihrer Lambda-Funktion erteilen. Wenn Sie in der Richtlinie einen Alias-ARN angeben, müssen Sie die Richtlinie nicht aktualisieren, wenn sich die Funktionsversion ändert.
## Ressourcenrichtlinien
Sie können eine [ressourcenbasierte Richtlinie](access-control-resource-based.md) verwenden, um einem Dienst, einer Ressource oder einem Konto Zugriff auf Ihre Funktion zu gewähren. Der Umfang dieser Berechtigung hängt davon ab, ob Sie sie auf einen Alias, eine Version oder die gesamte Funktion anwenden. Wenn Sie beispielsweise einen Aliasnamen verwenden (z. B. `helloworld:PROD`), gewährt Ihnen die Berechtigung, die Funktion `helloworld` mithilfe des ARN des Alias (`helloworld:PROD`) aufzurufen.
Wenn Sie versuchen, die Funktion ohne Alias oder eine bestimmte Version aufzurufen, erhalten Sie einen Berechtigungsfehler. Dieser Berechtigungsfehler tritt weiterhin auf, selbst wenn Sie versuchen, die dem Alias zugeordnete Funktionsversion direkt aufzurufen.
Der folgende AWS CLI-Befehl erteilt beispielsweise Amazon-S3-Berechtigungen zum Aufrufen des PROD-Alias der Funktion `helloworld`, wenn Amazon S3 im Auftrag von `amzn-s3-demo-bucket` handelt.
```
aws lambda add-permission \
--function-name helloworld \
--qualifier PROD \
--statement-id 1 \
--principal s3.amazonaws.com \
--action lambda:InvokeFunction \
--source-arn arn:aws:s3:::amzn-s3-demo-bucket \
--source-account 123456789012
```
Weitere Hinweise zum Verwenden von Ressourcennamen in Richtlinien finden Sie unter [Feinabstimmung der Abschnitte „Ressourcen“ und „Bedingungen“ der Richtlinien](lambda-api-permissions-ref.md).
# Implementieren Sie Lambda Canary-Bereitstellungen mithilfe eines gewichteten Alias
Sie können einen gewichteten Alias verwenden, um den Datenverkehr auf zwei verschiedene [Versionen](configuration-versions.md) derselben Funktion aufzuteilen. Mit diesem Ansatz können Sie neue Versionen Ihrer Funktionen mit einem kleinen Prozentsatz des Datenverkehrs testen und bei Bedarf schnell wieder zurücksetzen. Dies wird als [Canary-Bereitstellung](https://docs.aws.amazon.com/whitepapers/latest/overview-deployment-options/canary-deployments.html) bezeichnet. Kanarische Bereitstellungen unterscheiden sich von blue/green Bereitstellungen dadurch, dass die neue Version nur einem Teil der Anfragen ausgesetzt wird, anstatt den gesamten Datenverkehr auf einmal umzuleiten.
Sie können ein Alias auf maximal zwei Lambda-Funktionsversionen verweisen lassen. Die Versionen müssen folgende Kriterien erfüllen:
+ Beide Versionen müssen die gleiche [Ausführungsrolle](lambda-intro-execution-role.md) haben.
+ Beide Versionen müssen die gleiche [Warteschlangenkonfiguration für unzustellbare Nachrichten](invocation-async-retain-records.md#invocation-dlq) oder keine Warteschlangenkonfiguration für unzustellbare Nachrichten haben.
+ Beide Versionen müssen veröffentlicht werden. Der Alias darf nicht auf verweise `$LATEST`.
**Anmerkung**
Lambda verwendet ein einfaches probabilistisches Modell, um den Datenverkehr zwischen den beiden Funktionsversionen zu verteilen. Bei niedrigem Datenverkehr sehen Sie möglicherweise eine hohe Abweichung zwischen dem konfigurierten und dem tatsächlichen Prozentsatz des Datenverkehrs für jede Version. Wenn Ihre Funktion bereitgestellte Parallelität verwendet, können Sie [Überlaufaufrufe](monitoring-metrics-types.md#invocation-metrics) durch Konfigurieren einer höheren Anzahl von bereitgestellten Parallelitätsinstances während des aktiven Alias-Routings vermeiden.
## Einen gewichteten Alias erstellen
------
#### [ Console ]
**So konfigurieren Sie das Routing für einen Alias über die Konsole**
**Anmerkung**
Stellen Sie sicher, dass die Funktion über mindestens zwei veröffentlichte Versionen verfügt. Um weitere Versionen zu erstellen, folgen Sie den Anweisungen unter [Erstellen von Funktionsversionen](configuration-versions.md#configuration-versions-config).
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 **Aliasse** und dann **Alias erstellen** aus.
1. Führen Sie auf der Seite **Alias erstellen** die folgenden Schritte aus:
1. Machen Sie für den Alias eine Angabe unter **Name**.
1. (Optional) Geben Sie eine **Beschreibung** für den Alias ein.
1. Wählen Sie unter **Version** die erste Funktionsversion aus, auf die der Alias verweisen soll.
1. Erweitern Sie **Gewichteter Alias**.
1. Wählen Sie unter **Zusätzliche Version** die zweite Funktionsversion aus, auf die der Alias verweisen soll.
1. Geben Sie unter **Gewicht (%)** einen Gewichtungswert für die Funktion ein. Die *Gewichtung* ist der Prozentsatz des Datenverkehrs, der beim Aufruf des Alias dieser Version zugewiesen wird. Die erste Version erhält den Datenverkehr mit der verbleibenden Gewichtung. Wenn Sie beispielsweise 10 Prozent für die **Additional version (Zusätzliche Version)** angeben, werden der ersten Version automatisch 90 Prozent zugewiesen.
1. Wählen Sie **Speichern**.
------
#### [ AWS CLI ]
Verwenden Sie die AWS CLI Befehle [create-alias und update-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-alias.html)[, um die Datenverkehrsgewichte](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-alias.html) zwischen zwei Funktionsversionen zu konfigurieren. Wenn Sie den Alias erstellen oder aktualisieren, geben Sie die Datenverkehrsgewichtung im `routing-config`-Parameter an.
Im folgenden Beispiel wird ein Lambda-Funktionsalias namens **routing-alias** erstellt, der auf Version 1 der Funktion verweist. Version 2 der Funktion erhält 3 Prozent des Datenverkehrs. Die verbleibenden 97 Prozent des Datenverkehrs werden zu Version 1 weitergeleitet.
```
aws lambda create-alias \
--name routing-alias \
--function-name my-function \
--function-version 1 \
--routing-config AdditionalVersionWeights={"2"=0.03}
```
Verwenden Sie den `update-alias`-Befehl, um den Prozentsatz des eingehenden Datenverkehrs an Version 2 zu erhöhen. Im folgenden Beispiel erhöhen Sie den Datenverkehr auf 5 Prozent.
```
aws lambda update-alias \
--name routing-alias \
--function-name my-function \
--routing-config AdditionalVersionWeights={"2"=0.05}
```
Um den gesamten Datenverkehr an Version 2 weiterzuleiten, ändern Sie den Befehl `update-alias`, um die Eigenschaft `function-version` so zu ändern, dass der Alias auf Version 2 verweist. Der Befehl setzt auch die Weiterleitungskonfiguration zurück.
```
aws lambda update-alias \
--name routing-alias \
--function-name my-function \
--function-version 2 \
--routing-config AdditionalVersionWeights={}
```
Die AWS CLI Befehle in den vorherigen Schritten entsprechen den folgenden Lambda-API-Operationen:
+ [CreateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_CreateAlias.html)
+ [UpdateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateAlias.html)
------
## Feststellen, welche Version aufgerufen wurde
Wenn Sie Datenverkehrsgewichtungen zwischen zwei Funktionsversionen konfigurieren, gibt es zwei Möglichkeiten, die aufgerufene Lambda-Funktionsversion zu bestimmen:
+ **CloudWatch Logs** — Lambda gibt automatisch einen `START` Protokolleintrag aus, der die aufgerufene Versions-ID für jeden Funktionsaufruf enthält. Beispiel:
`START RequestId: 1dh194d3759ed-4v8b-a7b4-1e541f60235f Version: 2`
Für Aliasaufrufe verwendet Lambda die Dimension `ExecutedVersion` zum Filtern der Metrikdaten nach aufgerufener Version. Weitere Informationen finden Sie unter [Anzeigen von Metriken für Lambda-Funktionen](monitoring-metrics-view.md).
+ **Antwortnutzlast (synchrone Aufrufe)** – Antworten auf synchrone Funktionsaufrufe enthalten einen `x-amz-executed-version`-Header, der angibt, welche Funktionsversion aufgerufen wurde.
## Erstellen Sie eine fortlaufende Bereitstellung mit gewichteten Aliasnamen
Verwenden Sie AWS CodeDeploy und AWS Serverless Application Model (AWS SAM), um eine fortlaufende Bereitstellung zu erstellen, die automatisch Änderungen an Ihrem Funktionscode erkennt, eine neue Version Ihrer Funktion bereitstellt und die Menge des Datenverkehrs, der zur neuen Version fließt, schrittweise erhöht. Der Datenverkehr und die Erhöhungsrate sind Parameter, die Sie konfigurieren können.
AWS SAM Führt in einer fortlaufenden Bereitstellung die folgenden Aufgaben aus:
+ Konfiguriert Ihre Lambda-Funktion und erstellt einen Alias. Die gewichtete Alias-Weiterleitungskonfiguration ist die zugrunde liegende Funktion, die die fortlaufende Bereitstellung implementiert.
+ Erstellt eine CodeDeploy Anwendung und eine Bereitstellungsgruppe. Die Bereitstellungsgruppe verwaltet die fortlaufende Bereitstellung und das Rollback, falls erforderlich.
+ Erkennt, wenn Sie eine neue Version Ihrer Lambda-Funktion erstellen.
+ Löst aus CodeDeploy , um die Bereitstellung der neuen Version zu starten.
### Beispiel für AWS SAM eine Vorlage
Das folgende Beispiel zeigt eine [AWS SAM -Vorlage](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html) für eine einfache fortlaufende Bereitstellung.
```
AWSTemplateFormatVersion : '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: A sample SAM template for deploying Lambda functions
Resources:
# Details about the myDateTimeFunction Lambda function
myDateTimeFunction:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
Handler: myDateTimeFunction.handler
Runtime: nodejs24.x
# Creates an alias named "live" for the function, and automatically publishes when you update the function.
AutoPublishAlias: live
DeploymentPreference:
# Specifies the deployment configuration
Type: Linear10PercentEvery2Minutes
```
Diese Vorlage definiert eine Lambda-Funktion mit der Bezeichnung `myDateTimeFunction` und den folgenden Eigenschaften.
**AutoPublishAlias **
Die `AutoPublishAlias`-Eigenschaft erstellt einen Alias mit der Bezeichnung `live`. Darüber hinaus erkennt das AWS SAM -Framework automatisch, wenn Sie neuen Code für die Funktion speichern. Das Framework veröffentlicht dann eine neue Funktionsversion und aktualisiert den `live`-Alias so, dass er auf die neue Version verweist.
**DeploymentPreference**
Die `DeploymentPreference` Eigenschaft bestimmt die Geschwindigkeit, mit der die CodeDeploy Anwendung den Datenverkehr von der ursprünglichen Version der Lambda-Funktion auf die neue Version verlagert. Der Wert `Linear10PercentEvery2Minutes` verschiebt alle zwei Minuten weitere zehn Prozent des Datenverkehrs zur neuen Version.
Eine Liste der vordefinierten Bereitstellungskonfigurationen finden Sie unter [Bereitstellungskonfigurationen](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-configurations.html).
Weitere Informationen zum Erstellen fortlaufender Bereitstellungen mit CodeDeploy und AWS SAM finden Sie im Folgenden:
+ [Tutorial: Stellen Sie eine aktualisierte Lambda-Funktion bereit mit CodeDeploy und AWS Serverless Application Model](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-lambda-sam.html)
+ [Schrittweise Bereitstellung serverloser Anwendungen mit AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/automating-updates-to-serverless-apps.html)
# Versionen der Lambda-Funktion verwalten
Sie können Versionen verwenden, um die Bereitstellung Ihrer Funktionen zu verwalten. Beispielsweise können Sie eine neue Version einer Funktion für Beta-Tests veröffentlichen, ohne dass Benutzer der stabilen Produktionsversion betroffen sind. Lambda erstellt jedes Mal, wenn Sie die Funktion veröffentlichen, eine neue Version Ihrer Funktion. Die neue Version ist eine Kopie der unveröffentlichten Version der Funktion. Die unveröffentlichte Version heißt `$LATEST`.
Wichtig ist, dass Sie bei jeder Bereitstellung Ihres Funktionscodes den aktuellen Code in `$LATEST` überschreiben. Um die aktuelle Iteration von `$LATEST` zu speichern, erstellen Sie eine neue Funktionsversion. Wenn `$LATEST` mit einer zuvor veröffentlichten Version identisch ist, können Sie erst dann eine neue Version erstellen, wenn Sie Änderungen an `$LATEST` bereitgestellt haben. Zu diesen Änderungen können die Aktualisierung des Codes oder die Änderung der Funktionskonfigurationseinstellungen gehören.
Nachdem Sie eine Funktionsversion veröffentlicht haben, sind Code, Laufzeit, Architektur, Speicher, Ebenen und die meisten anderen Konfigurationseinstellungen unveränderlich. Das bedeutet, dass Sie diese Einstellungen nicht ändern können, ohne eine neue Version von `$LATEST` zu veröffentlichen. Sie können die folgenden Elemente für eine veröffentlichte Funktionsversion konfigurieren:
+ [Auslöser](lambda-services.md#lambda-invocation-trigger)
+ [Ziele](invocation-async-retain-records.md#create-destination)
+ [Bereitgestellte Gleichzeitigkeit](provisioned-concurrency.md)
+ [Asynchroner Aufruf](invocation-async.md)
+ [Datenbankverbindungen und Proxys](services-rds.md#rds-configuration)
**Anmerkung**
Bei Verwendung von [Steuerelementen zur Laufzeitverwaltung](runtimes-update.md#runtime-management-controls) im Modus **Auto** (Automatisch) wird die Laufzeitversion, die von der Funktionsversion verwendet wird, automatisch aktualisiert. Bei Verwendung des Modus **Function update** (Funktionsaktualisierung) oder **Manual** (Manuell) wird die Laufzeitversion nicht aktualisiert. Weitere Informationen finden Sie unter [Verstehen, wie Lambda Laufzeit-Versionsupdates verwaltet](runtimes-update.md).
**Topics**
+ [
## Erstellen von Funktionsversionen
](#configuration-versions-config)
+ [
## Verwenden von Versionen
](#versioning-versions-using)
+ [
## Gewähren von Berechtigungen
](#versioning-permissions)
## Erstellen von Funktionsversionen
Sie können den Funktionscode und die Einstellungen nur in der nicht veröffentlichten Version einer Funktion ändern. Wenn Sie eine Version veröffentlichen, sperrt Lambda den Code und die meisten Einstellungen, um eine konsistente Erfahrung für Benutzer dieser Version zu gewährleisten.
Sie können eine Funktionsversion mit der Lambda-Konsole erstellen.
**So erstellen Sie eine neue Funktionsversion**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie eine Funktion aus und dann den Tab **Versionen**.
1. Wählen Sie auf der Versionskonfigurationsseite die Option **Neue Version veröffentlichen** aus.
1. (Optional) Geben Sie eine Versionsbeschreibung ein.
1. Wählen Sie **Publish**.
Alternativ können Sie eine Version einer Funktion mithilfe der [PublishVersion](https://docs.aws.amazon.com/lambda/latest/api/API_PublishVersion.html)API-Operation veröffentlichen.
Der folgende AWS CLI Befehl veröffentlicht eine neue Version einer Funktion. In der Antwort werden die Konfigurationsinformationen der neuen Version zurückgegeben, einschließlich der Versionsnummer und des Funktion-ARN mit dem Versionssuffix.
```
aws lambda publish-version --function-name my-function
```
Die Ausgabe sollte folgendermaßen aussehen:
```
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function:1",
"Version": "1",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Handler": "function.handler",
"Runtime": "nodejs24.x",
...
}
```
**Anmerkung**
Lambda weist monoton steigende Sequenznummern für die Versionsverwaltung zu. Lambda verwendet niemals Versionsnummern wieder, auch nicht nachdem Sie eine Funktion gelöscht und neu erstellt haben.
## Verwenden von Versionen
Sie können Ihre Lambda-Funktion entweder mit einem qualifizierten ARN oder einem nicht qualifizierten ARN referenzieren.
+ **Qualifizierter ARN** – Hierbei handelt es sich um den ARN der Funktion mit einem Versionssuffix. Das folgende Beispiel bezieht sich auf Version 42 der Funktion `helloworld`.
```
arn:aws:lambda:aws-region:acct-id:function:helloworld:42
```
+ **Unqualifizierter ARN** – Hierbei handelt es sich um den ARN der Funktion ohne ein Versionssuffix.
```
arn:aws:lambda:aws-region:acct-id:function:helloworld
```
Sie können in allen relevanten API-Operationen einen qualifizierten oder einen nicht qualifizierten ARN verwenden. Sie können jedoch keinen unqualifizierten ARN verwenden, um einen Alias zu erstellen.
Wenn Sie sich entscheiden, Funktionsversionen nicht zu veröffentlichen, können Sie entweder den qualifizierten oder den nicht qualifizierten ARN in Ihrer [Ereignisquellen-Zuweisung](invocation-eventsourcemapping.md) verwenden, um die Funktion aufzurufen. Wenn Sie eine Funktion mit einem unqualifizierten ARN aufrufen, ruft Lambda implizit `$LATEST` auf.
Der qualifizierte ARN für jede Lambda-Funktionsversion ist eindeutig. Nachdem Sie eine Version veröffentlicht haben, können Sie den ARN oder den Funktionscode nicht ändern.
Lambda veröffentlicht eine neue Funktionsversion nur dann, wenn der Code noch nie veröffentlicht wurde oder wenn sich der Code im Vergleich zur zuletzt veröffentlichten Version geändert hat. Wenn keine Änderung vorliegt, bleibt die Funktionsversion die zuletzt veröffentlichte Version.
Wenn Sie eine Version veröffentlichen, erstellt Lambda einen unveränderlichen Snapshot des Codes und der Konfiguration Ihrer Funktion. Nicht alle Konfigurationsänderungen lösen die Veröffentlichung einer neuen Version aus. Die folgenden Konfigurationsänderungen qualifizieren eine Funktion für die Versionsveröffentlichung:
+ Funktionscode
+ Umgebungsvariablen
+ Laufzeit
+ Handler
+ Layer
+ Arbeitsspeichergröße
+ Zeitüberschreitung
+ VPC-Konfiguration
+ Konfiguration der Warteschlange für unzustellbare Nachrichten
+ IAM role (IAM-Rolle)
+ Description
+ Architektur (x86\$164 oder arm64)
+ Größe des flüchtigen Speichers
+ Art Package
+ Protokollierungskonfiguration
+ Dateisystemkonfiguration
+ SnapStart
+ Nachverfolgungskonfiguration
Betriebseinstellungen wie [reservierte Parallelität](configuration-concurrency.md) lösen nicht die Veröffentlichung einer neuen Version aus, wenn sie geändert werden.
## Gewähren von Berechtigungen
Sie können eine [ressourcenbasierte Richtlinie](access-control-resource-based.md) oder eine [identitätsbasierte Richtlinie](access-control-identity-based.md) verwenden, um Zugriff auf Ihre Funktion zu gewähren. Der Umfang der Berechtigung hängt davon ab, ob Sie die Richtlinie auf eine Funktion oder auf eine Version einer Funktion anwenden. Weitere Hinweise zu Funktionsressourcennamen in Richtlinien finden Sie unter [Feinabstimmung der Abschnitte „Ressourcen“ und „Bedingungen“ der Richtlinien](lambda-api-permissions-ref.md).
Sie können die Verwaltung von Ereignisquellen und AWS Identity and Access Management (IAM-) Richtlinien vereinfachen, indem Sie Funktionsaliase verwenden. Weitere Informationen finden Sie unter [Erstellung eines Alias für eine Lambda-Funktion](configuration-aliases.md).
# Verwenden von Tags für Lambda-Funktionen
Sie können Tag-Funktionen markieren, um Ihre Ressourcen zu organisieren und zu verwalten. Tags sind frei formulierte Schlüssel-Wert-Paare, die mit Ihren Ressourcen verknüpft sind und von AWS-Services unterstützt werden. Weitere Informationen zu Anwendungsfällen für Tags finden Sie unter [Allgemeine Tagging-Strategien](https://docs.aws.amazon.com//tag-editor/latest/userguide/best-practices-and-strats.html#tag-strategies) im *Tagging AWS Resources and Tag Editor Guide*.
Tags gelten für die Funktionsebene, nicht für Versionen oder Aliase. Tags sind nicht Teil der versionsspezifischen Konfiguration, die einen Snapshot davon AWS Lambda erstellt, wann Sie eine Version veröffentlichen. Sie können die Lambda-API verwenden, um Tags anzuzeigen und zu aktualisieren. Sie können Tags auch anzeigen und aktualisieren, während Sie eine bestimmte Funktion in der Lambda-Konsole verwalten.
**Topics**
+ [
## Erforderliche Berechtigungen zum Arbeiten mit Tags
](#fxn-tags-required-permissions)
+ [
## Verwendung von Tags mit der Lambda-Konsole
](#using-tags-with-the-console)
+ [
## Verwenden von Tags mit AWS CLI
](#configuration-tags-cli)
## Erforderliche Berechtigungen zum Arbeiten mit Tags
Um einer AWS Identity and Access Management -(IAM)-Identität (Benutzer, Gruppe oder Rolle) das Lesen oder Setzen von Tags auf einer Ressource zu ermöglichen, gewähren Sie ihr die entsprechenden Berechtigungen:
+ **lambda: ListTags** —Wenn eine Ressource Tags enthält, gewähren Sie diese Berechtigung jedem, der sie aufrufen muss. `ListTags` Für Funktionen mit Tags ist diese Berechtigung auch für `GetFunction` erforderlich.
+ **lambda: TagResource** —Erteilen Sie diese Berechtigung jedem, der bei create ein Tag aufrufen `TagResource` oder ausführen muss.
Optional können Sie erwägen, auch die **lambda: UntagResource** -Berechtigung zu erteilen, um `UntagResource` Aufrufe der Ressource zuzulassen.
Weitere Informationen finden Sie unter [Identitätsbasierte IAM-Richtlinien für Lambda](access-control-identity-based.md).
## Verwendung von Tags mit der Lambda-Konsole
Sie können die Lambda-Konsole verwenden, um Funktionen mit Tags zu erstellen, Tags zu vorhandenen Funktionen hinzuzufügen und Funktionen nach von Ihnen hinzugefügten Tags zu filtern.
**Hinzufügen von Tags beim Erstellen einer Funktion**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie **Funktion erstellen**.
1. Klicken Sie auf **Ohne Vorgabe erstellen** oder **Container-Image**.
1. Richten Sie unter **Grundinformationen** Ihre Funktion ein. Weitere Hinweise zum Konfigurieren von Funktionen finden Sie unter [AWS Lambda Funktionen konfigurieren](lambda-functions.md).
1. Erweitern Sie **Advanced settings** (Erweiterte Einstellungen) und wählen Sie dann **Enable tags** (Tags aktivieren) aus.
1. Wählen Sie **Add new tag** (Neues Tag hinzufügen) und geben Sie dann einen **Key** (Schlüssel) und einen optionalen **Value** (Wert) ein. Wiederholen Sie diesen Schritt, um weitere Tags hinzuzufügen.
1. Wählen Sie **Funktion erstellen**.
**Hinzufügen von Tags zu einer bestehenden Funktion**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie den Namen einer Funktion aus.
1. Wählen Sie **Configuraton** (Konfiguration) und dann **Tags** aus.
1. Wählen Sie unter **Tags** die Option **Manage tags (Tags verwalten)** aus.
1. Wählen Sie **Add new tag** (Neues Tag hinzufügen) und geben Sie dann einen **Key** (Schlüssel) und einen optionalen **Value** (Wert) ein. Wiederholen Sie diesen Schritt, um weitere Tags hinzuzufügen.
1. Wählen Sie **Speichern**.
**So filtern Sie Funktionen mit Tags**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie die Suchleiste aus, um eine Liste mit Funktionseigenschaften und Tag-Schlüsseln anzuzeigen.
1. Wählen Sie einen Tag-Schlüssel, um eine Liste der Werte zu sehen, die in der aktuellen AWS Region verwendet werden.
1. Wählen Sie **Verwenden: „Tag-Name“**, um alle Funktionen zu sehen, die mit dieser Taste gekennzeichnet sind oder wählen Sie einen **Operator**, um weiter nach Werten zu filtern.
1. Wählen Sie Ihren Tag-Wert aus, um nach einer Kombination aus Tag-Schlüssel und -Wert zu filtern.
Die Suchleiste unterstützt auch die Suche nach Tag-Schlüsseln. Geben Sie `tag` ein, um nur eine Liste der Tag-Schlüssel anzuzeigen, oder geben Sie den Namen eines Schlüssels ein, um ihn in der Liste zu suchen.
## Verwenden von Tags mit AWS CLI
Mit der Lambda-API können Sie Tags zu vorhandenen Lambda-Ressourcen, einschließlich Funktionen, hinzufügen und entfernen. Sie können beim Erstellen einer Funktion auch Tags hinzufügen, sodass Sie eine Ressource während ihres gesamten Lebenszyklus mit Tags versehen können.
### Aktualisieren von Tags mit dem Lambda-Tag APIs
Sie können Tags für unterstützte Lambda-Ressourcen über die [TagResource](https://docs.aws.amazon.com/lambda/latest/api/API_TagResource.html)und [UntagResource](https://docs.aws.amazon.com/lambda/latest/api/API_UntagResource.html)API-Operationen hinzufügen und entfernen.
Sie können diese Operationen mit der Taste AWS CLI aufrufen. Um Tags einer vorhandenen Ressource hinzuzufügen, verwenden Sie den folgenden `tag-resource`-Befehl. In diesem Beispiel werden zwei Tags hinzugefügt, eines mit dem Schlüssel *Department* und eines mit dem Schlüssel*CostCenter*.
```
aws lambda tag-resource \
--resource arn:aws:lambda:us-east-2:123456789012:resource-type:my-resource \
--tags Department=Marketing,CostCenter=1234ABCD
```
Mit dem Befehl `untag-resource` können Sie Tags entfernen. In diesem Beispiel wird das Tag mit dem Schlüssel entfernt*Department*.
```
aws lambda untag-resource --resource arn:aws:lambda:us-east-1:123456789012:resource-type:resource-identifier \
--tag-keys Department
```
### Hinzufügen von Tags beim Erstellen einer Funktion
Verwenden Sie die [CreateFunction](https://docs.aws.amazon.com//lambda/latest/api/API_CreateFunction.html)API-Operation, um eine neue Lambda-Funktion mit Tags zu erstellen. Geben Sie den Parameter `Tags` an. Sie können diesen Vorgang mit dem `create-function`-CLI-Befehl und der Option --tags aufrufen. Vergewissern Sie sich vor der Verwendung des Tags-Parameters mit `CreateFunction`, dass Ihre Rolle neben den üblichen Berechtigungen, die für diesen Vorgang erforderlich sind, auch die Berechtigung hat, Ressourcen zu taggen. Weitere Informationen zu den Berechtigungen für das Tagging finden Sie unter [Erforderliche Berechtigungen zum Arbeiten mit Tags](#fxn-tags-required-permissions). In diesem Beispiel werden zwei Tags hinzugefügt, eines mit dem Schlüssel *Department* und eines mit dem Schlüssel*CostCenter*.
```
aws lambda create-function --function-name my-function
--handler index.js --runtime nodejs24.x \
--role arn:aws:iam::123456789012:role/lambda-role \
--tags Department=Marketing,CostCenter=1234ABCD
```
### Anzeigen von Tags in einer Funktion
Um die Tags anzuzeigen, die auf eine bestimmte Lambda-Ressource angewendet werden, verwenden Sie die `ListTags`-API-Operation. Weitere Informationen finden Sie unter [ListTags](https://docs.aws.amazon.com/lambda/latest/api/API_ListTags.html).
Sie können diesen Vorgang mit dem `list-tags` AWS CLI Befehl aufrufen, indem Sie einen ARN (Amazon Resource Name) angeben.
```
aws lambda list-tags --resource arn:aws:lambda:us-east-1:123456789012:resource-type:resource-identifier
```
Sie können die Tags anzeigen, die mit der [GetFunction](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html)API-Operation auf eine bestimmte Ressource angewendet werden. Eine vergleichbare Funktion ist nicht für andere Ressourcentypen verfügbar.
Sie können diesen Vorgang mit dem `get-function`-CLI-Befehl aufrufen:
```
aws lambda get-function --function-name my-function
```
### Filtern von Ressourcen nach Tag
Sie können den AWS Resource Groups Tagging API [GetResources](https://docs.aws.amazon.com/resourcegroupstagging/latest/APIReference/API_GetResources.html)API-Vorgang verwenden, um Ihre Ressourcen nach Tags zu filtern. Die `GetResources`-Operation empfängt bis zu 10 Filter, wobei jeder Filter einen Tag-Schlüssel und bis zu 10 Tag-Werte enthält. Sie stellen `GetResources` mit einem `ResourceType` zur Verfügung, um nach bestimmten Ressourcentypen zu filtern.
Sie können diesen Vorgang mit dem `get-resources` AWS CLI Befehl aufrufen. Beispiele für die Verwendung von `get-resources` finden Sie unter [get-resources](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/resourcegroupstaggingapi/get-resources.html#examples) in der *AWS -CLI-Befehlsreferenz*.
# Antwortstreaming für Lambda-Funktionen
Lambda-Funktionen können Antwortnutzlasten nativ über die [Lambda-Funktion URLs](urls-configuration.md) oder mithilfe der [InvokeWithResponseStream](https://docs.aws.amazon.com/lambda/latest/api/API_InvokeWithResponseStream.html)API (über das AWS SDK oder direkte API-Aufrufe) an Clients zurückstreamen. Ihre Lambda-Funktion kann auch Antwort-Payloads über die [Amazon API Gateway Gateway-Proxyintegration](https://docs.aws.amazon.com/apigateway/latest/developerguide/response-transfer-mode-lambda.html) streamen, die die [InvokeWithResponseStream](https://docs.aws.amazon.com/lambda/latest/api/API_InvokeWithResponseStream.html)API verwendet, um Ihre Funktion aufzurufen. Antwort-Streaming kann für latenzempfindliche Anwendungen von Vorteil sein, da es die Leistung in der Zeit bis zum ersten Byte (TTFB) verbessert. Dies liegt daran, dass Sie Teilantworten an den Client zurücksenden können, sobald sie verfügbar sind. Darüber hinaus können Antwort-Streaming-Funktionen Nutzdaten bis zu 200 MB zurückgeben, verglichen mit dem Maximum von 6 MB für gepufferte Antworten. Das Streameng einer Antwort bedeutet auch, dass Ihre Funktion nicht die gesamte Antwort im Speicher unterbringen muss. Bei sehr großen Antworten kann dies die Menge des Speichers reduzieren, die Sie für Ihre Funktion konfigurieren müssen.
**Anmerkung**
Lambda-Response-Streaming ist noch nicht in allen AWS-Regionen Bereichen verfügbar. Informationen zur Verfügbarkeit [von AWS Funktionen nach Regionen finden Sie in den Funktionen](https://builder.aws.com/build/capabilities) des Builder Centers nach Regionen.
Die Geschwindigkeit, mit der Lambda Ihre Antworten streamt, hängt von der Größe der Antwort ab. Die Streaming-Rate für die ersten 6 MB der Antwort Ihrer Funktion ist nicht begrenzt. Bei Antworten, die größer als 6 MB sind, gilt für den Rest der Antwort eine Bandbreitenbegrenzung. Weitere Informationen zur Streaming-Bandbreite finden Sie unter [Bandbreitenbegrenzung für Antwort-Streaming](#config-rs-bandwidth-cap).
Streaming-Antworten sind mit Kosten verbunden, und gestreamte Antworten werden nicht unterbrochen oder gestoppt, wenn die Verbindung zum aufrufenden Client unterbrochen wird. Kunden wird die volle Funktionsdauer in Rechnung gestellt, weshalb Kunden bei der Konfiguration langer Funktions-Timeouts Vorsicht walten lassen sollten.
Lambda unterstützt Antwortstreaming auf verwalteten Laufzeiten von Node.js. Für andere Sprachen, einschließlich Python, können Sie [eine benutzerdefinierte Laufzeit mit einer benutzerdefinierten Runtime-API-Integration verwenden](runtimes-custom.md#runtimes-custom-response-streaming), um Antworten zu streamen, oder den [Lambda Web Adapter](https://github.com/awslabs/aws-lambda-web-adapter) verwenden.
**Anmerkung**
Wenn Sie Ihre Funktion über die Lambda-Konsole testen, werden die Antworten immer gepuffert angezeigt.
**Topics**
+ [
## Bandbreitenbegrenzung für Antwort-Streaming
](#config-rs-bandwidth-cap)
+ [
## VPC-Kompatibilität mit Antwort-Streaming
](#config-rs-vpc-compatibility)
+ [
# Schreiben von Antwort-Streaming-fähigen Lambda-Funktionen
](config-rs-write-functions.md)
+ [
# Aufrufen einer für Response-Streaming aktivierten Funktion mithilfe der Lambda-Funktion URLs
](config-rs-invoke-furls.md)
+ [
# Tutorial: Erstellen einer Lambda-Funktion zum Streamen von Antworten mit einer Funktions-URL
](response-streaming-tutorial.md)
## Bandbreitenbegrenzung für Antwort-Streaming
Für die ersten 6 MB der Nutzlast Ihrer Funktion gibt es keine Bandbreitenbegrenzung. Nach diesem ersten Burst streamt Lambda Ihre Antwort mit einer maximalen Rate von 2. MBps Wenn Ihre Funktionsantworten nie größer als 6 MB sind, gilt diese Bandbreitenbegrenzung nicht.
**Anmerkung**
Bandbreitenbegrenzungen gelten nur für die Antwortnutzlast Ihrer Funktion und nicht für den Netzwerkzugriff durch Ihre Funktion.
Die Rate der unbegrenzten Bandbreite hängt von einer Reihe von Faktoren ab, einschließlich der Verarbeitungsgeschwindigkeit Ihrer Funktion. Normalerweise können Sie MBps für die ersten 6 MB der Antwort Ihrer Funktion mit einer Rate von mehr als 2 rechnen. Wenn Ihre Funktion eine Antwort an ein Ziel außerhalb von streamt AWS, hängt die Streaming-Rate auch von der Geschwindigkeit der externen Internetverbindung ab.
## VPC-Kompatibilität mit Antwort-Streaming
Bei der Verwendung von Lambda-Funktionen in einer VPC-Umgebung gibt es wichtige Überlegungen zum Antwort-Streaming:
+ Die Lambda-Funktion unterstützt URLs kein Antwort-Streaming innerhalb einer VPC-Umgebung.
+ Sie können Antwort-Streaming innerhalb einer VPC verwenden, indem Sie Ihre Lambda-Funktion über das AWS SDK mithilfe der API aufrufen. `InvokeWithResponseStream` Das erfordert die Einrichtung der entsprechenden VPC-Endpunkte für Lambda.
+ Für VPC-Umgebungen müssen Sie einen VPC-Schnittstellen-Endpunkt für Lambda erstellen, um die Kommunikation zwischen Ihren Ressourcen in der VPC und dem Lambda-Service zu ermöglichen.
Eine typische Architektur für das Antwort-Streaming in einer VPC könnte Folgendes beinhalten:
```
Client in VPC -> Interface VPC endpoint for Lambda -> Lambda function -> Response streaming back through the same path
```
# Schreiben von Antwort-Streaming-fähigen Lambda-Funktionen
Das Schreiben des Handlers für Antwort-Streaming-Funktionen unterscheidet sich von typischen Handler-Mustern. Wenn Sie Streaming-Funktionen schreiben, sollten Sie Folgendes beachten:
+ Umschließen Sie Ihre Funktion mit dem `awslambda.streamifyResponse()`-Decorator. Das globale `awslambda`-Objekt wird von der Lambda-Laufzeitumgebung Node.js bereitgestellt.
+ Beenden Sie den Stream ordnungsgemäß, um sicherzustellen, dass die Datenverarbeitung abgeschlossen ist.
## Konfigurieren einer Handler-Funktion zum Streamen von Antworten
Um der Laufzeit zu signalisieren, dass Lambda die Antworten Ihrer Funktion streamen soll, müssen Sie Ihre Funktion mit dem `streamifyResponse()`-Decorator wrappen. Dadurch wird die Laufzeit angewiesen, den richtigen Logikpfad für Streaming-Antworten zu verwenden, und ermöglicht es der Funktion, Antworten zu streamen.
Der `streamifyResponse()`-Decorator akzeptiert eine Funktion, die die folgenden Parameter akzeptiert:
+ `event` – Stellt Informationen über das Aufrufereignis der Funktions-URL bereit, z. B. die HTTP-Methode, Abfrageparameter und den Anforderungskörper.
+ `responseStream` – Stellt einen schreibbaren Stream bereit.
+ `context` – Stellt Methoden und Eigenschaften mit Informationen zum Aufruf, zur Funktion und zur Ausführungsumgebung bereit.
Das `responseStream`-Objekt ist ein [Node.js `writableStream`](https://nodesource.com/blog/understanding-streams-in-nodejs/). Wie bei jedem solchen Stream sollten Sie die `pipeline()`-Methode verwenden.
**Anmerkung**
Das globale `awslambda`-Objekt wird automatisch von der Lambda-Laufzeit Node.js bereitgestellt, und es ist kein Import erforderlich.
**Example Handler mit aktiviertem Antwort-Streaming**
```
import { pipeline } from 'node:stream/promises';
import { Readable } from 'node:stream';
export const echo = awslambda.streamifyResponse(async (event, responseStream, _context) => {
// As an example, convert event to a readable stream.
const requestStream = Readable.from(Buffer.from(JSON.stringify(event)));
await pipeline(requestStream, responseStream);
});
```
Obwohl `responseStream` die `write()`-Methode bietet, in den Stream zu schreiben, empfehlen wir Ihnen, wo immer möglich, [https://nodejs.org/api/stream.html#streampipelinesource-transforms-destination-callback](https://nodejs.org/api/stream.html#streampipelinesource-transforms-destination-callback) zu verwenden. Die Verwendung von `pipeline()` stellt sicher, dass der schreibbare Stream nicht von einem schneller lesbaren Stream überfordert wird.
## Den Stream beenden
Stellen Sie sicher, dass Sie den Stream ordnungsgemäß beenden, bevor der Handler zurückkehrt. Die `pipeline()`-Methode verarbeitet dies automatisch.
Für andere Anwendungsfälle rufen Sie die `responseStream.end()`-Methode auf, um einen Stream ordnungsgemäß zu beenden. Diese Methode signalisiert, dass keine Daten mehr in den Stream geschrieben werden sollen. Diese Methode ist nicht erforderlich, wenn Sie mit `pipeline()` oder `pipe()` in den Stream schreiben.
Ab Node.js 24 wartet Lambda nicht mehr darauf, dass ungelöste Versprechen abgeschlossen werden, nachdem Ihr Handler zurückgekehrt ist oder der Antwortstream beendet wurde. Wenn Ihre Funktion von zusätzlichen asynchronen Vorgängen wie Timern oder Abrufen abhängt, sollten Sie sie in Ihrem Handler verwenden. `await`
**Example Beispiel für das Beenden eines Streams mit Pipeline ()**
```
import { pipeline } from 'node:stream/promises';
export const handler = awslambda.streamifyResponse(async (event, responseStream, _context) => {
await pipeline(requestStream, responseStream);
});
```
**Example Beispiel für das Beenden eines Streams ohne Pipeline ()**
```
export const handler = awslambda.streamifyResponse(async (event, responseStream, _context) => {
responseStream.write("Hello ");
responseStream.write("world ");
responseStream.write("from ");
responseStream.write("Lambda!");
responseStream.end();
});
```
# Aufrufen einer für Response-Streaming aktivierten Funktion mithilfe der Lambda-Funktion URLs
**Anmerkung**
Ihre Lambda-Funktion kann jetzt Antwort-Payloads über die [Amazon API Gateway Gateway-Proxyintegration](https://docs.aws.amazon.com/apigateway/latest/developerguide/response-transfer-mode-lambda.html) streamen.
Sie können Funktionen mit aktiviertem Antwort-Streaming aufrufen, indem Sie den Aufrufmodus der URL Ihrer Funktion ändern. Der Aufrufmodus bestimmt, welche API-Operation Lambda verwendet, um Ihre Funktion aufzurufen. Die verfügbaren Aufrufmodi sind:
+ `BUFFERED` – Dies ist die Standardoption. Lambda ruft Ihre Funktion mithilfe der `Invoke`-API-Operation auf. Die Aufrufergebnisse sind verfügbar, wenn die Nutzlast abgeschlossen ist. Die maximale Nutzlastgröße beträgt 6 MB.
+ `RESPONSE_STREAM` – Ermöglicht es Ihrer Funktion, die Ergebnisse der Nutzlasten zu streamen, sobald sie verfügbar sind. Lambda ruft Ihre Funktion mithilfe der `InvokeWithResponseStream`-API-Operation auf. Die maximale Größe der Antwort-Payload beträgt 200 MB.
Sie können Ihre Funktion auch ohne Antwort-Streaming aufrufen, indem Sie die `Invoke`-API-Operation direkt aufrufen. Lambda streamt jedoch alle Antwort-Nutzlasten für Aufrufe, die über die URL der Funktion erfolgen, bis Sie den Aufrufmodus auf `BUFFERED` ändern.
------
#### [ Console ]
**Um den Aufrufmodus einer Funktions-URL (Konsole) festzulegen**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie den Namen der Funktion, für die Sie den Aufrufmodus festlegen möchten.
1. Wählen Sie die Registerkarte **Konfiguration** und dann **Funktions-URL**.
1. Wählen Sie **Bearbeiten** und dann **Zusätzliche Einstellungen**.
1. Wählen Sie unter **Aufrufmodus** den gewünschten Aufrufmodus aus.
1. Wählen Sie **Speichern**.
------
#### [ AWS CLI ]
**Um den Aufrufmodus einer Funktions-URL (AWS CLI) festzulegen**
```
aws lambda update-function-url-config \
--function-name my-function \
--invoke-mode RESPONSE_STREAM
```
------
#### [ CloudFormation ]
**Um den Aufrufmodus einer Funktions-URL (CloudFormation) festzulegen**
```
MyFunctionUrl:
Type: AWS::Lambda::Url
Properties:
AuthType: AWS_IAM
InvokeMode: RESPONSE_STREAM
```
------
Weitere Informationen zur Konfiguration der Funktion finden Sie URLs unter [Lambda-Funktion URLs](urls-configuration.md).
# Tutorial: Erstellen einer Lambda-Funktion zum Streamen von Antworten mit einer Funktions-URL
In diesem Tutorial erstellen Sie eine Lambda-Funktion, die als ZIP-Dateiarchiv mit einem Funktions-URL-Endpunkt definiert ist, der einen Antwort-Stream zurückgibt. Weitere Hinweise zur Konfiguration der Funktion URLs finden Sie unter[Funktion URLs](urls-configuration.md).
## Voraussetzungen
In diesem Tutorial wird davon ausgegangen, dass Sie über Kenntnisse zu den grundlegenden Lambda-Operationen und der Lambda-Konsole verfügen. Sofern noch nicht geschehen, befolgen Sie die Anweisungen unter [Erstellen einer Lambda-Funktion mit der Konsole](getting-started.md#getting-started-create-function), um Ihre erste Lambda-Funktion zu erstellen.
Um die folgenden Schritte durchzuführen, benötigen Sie die [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). Befehle und die erwartete Ausgabe werden in separaten Blöcken aufgeführt:
```
aws --version
```
Die Ausgabe sollte folgendermaßen aussehen:
```
aws-cli/2.13.27 Python/3.11.6 Linux/4.14.328-248.540.amzn2.x86_64 exe/x86_64.amzn.2
```
Bei langen Befehlen wird ein Escape-Zeichen (`\`) wird verwendet, um einen Befehl über mehrere Zeilen zu teilen.
Verwenden Sie auf Linux und macOS Ihren bevorzugten Shell- und Paket-Manager.
**Anmerkung**
In Windows werden einige Bash-CLI-Befehle, die Sie häufig mit Lambda verwenden (z. B. `zip`), von den integrierten Terminals des Betriebssystems nicht unterstützt. Um eine in Windows integrierte Version von Ubuntu und Bash zu erhalten, [installieren Sie das Windows-Subsystem für Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Die CLI-Beispielbefehle in diesem Handbuch verwenden die Linux-Formatierung. Befehle, die Inline-JSON-Dokumente enthalten, müssen neu formatiert werden, wenn Sie die Windows-CLI verwenden.
## Erstellen einer Ausführungsrolle
Erstellen Sie die [Ausführungsrolle](lambda-intro-execution-role.md) die Ihrer Lambda-Funktion die Berechtigung für den Zugriff auf AWS -Ressourcen erteilt.
**So erstellen Sie eine Ausführungsrolle**
1. Öffnen Sie die Seite [Rollen](https://console.aws.amazon.com/iam/home#/roles) der AWS Identity and Access Management (IAM)-Konsole.
1. Wählen Sie **Rolle erstellen** aus.
1. Erstellen Sie eine Rolle mit den folgenden Eigenschaften:
+ **Vertrauenswürdiger Entitätstyp** – **AWS -Service**
+ **Anwendungsfall** – **Lambda**
+ **Berechtigungen** – **AWSLambdaBasicExecutionRole**
+ **Role name (Name der Rolle** – **response-streaming-role**
Die **AWSLambdaBasicExecutionRole**Richtlinie verfügt über die Berechtigungen, die die Funktion benötigt, um Protokolle in Amazon CloudWatch Logs zu schreiben. Nachdem Sie die Rolle erstellt haben, notieren Sie sich den Amazon-Ressourcennamen (ARN). Sie benötigen ihn im nächsten Schritt.
## Erstellen Sie eine Antwort-Streaming-Funktion (AWS CLI)
Erstellen Sie eine Antwort-Streaming-Lambda-Funktion mit einem Funktions-URL-Endpunkt unter Verwendung der AWS Command Line Interface (AWS CLI).
**Um eine Funktion zu erstellen, die Antworten streamen kann**
1. Kopieren Sie das folgende Codebeispiel in eine Datei mit dem Namen `index.js`. Diese Funktion streamt drei Antworten im Abstand von 1 Sekunde.
```
exports.handler = awslambda.streamifyResponse(
async (event, responseStream, _context) => {
// Metadata is a JSON serializable JS object. Its shape is not defined here.
const metadata = {
statusCode: 200,
headers: {
"Content-Type": "application/json",
"CustomHeader": "outerspace"
}
};
// Assign to the responseStream parameter to prevent accidental reuse of the non-wrapped stream.
responseStream = awslambda.HttpResponseStream.from(responseStream, metadata);
responseStream.write("Streaming with Helper \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.write("Hello 0 \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.write("Hello 1 \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.write("Hello 2 \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.end();
await responseStream.finished();
}
);
```
1. Erstellen Sie ein Bereitstellungspaket.
```
zip function.zip index.js
```
1. Erstellen Sie eine Lambda-Funktion mit dem Befehl `create-function`. Ersetzen Sie den Wert von `--role` durch den Rollen-ARN aus dem vorherigen Schritt. Mit diesem Befehl wird das Funktions-Timeout auf 10 Sekunden festgelegt, sodass die Funktion drei Antworten streamen kann.
```
aws lambda create-function \
--function-name my-streaming-function \
--runtime nodejs24.x \
--zip-file fileb://function.zip \
--handler index.handler \
--timeout 10 \
--role arn:aws:iam::123456789012:role/response-streaming-role
```
**Um eine Funktions-URL zu erstellen**
1. Fügen Sie Ihrer Funktion eine ressourcenbasierte Richtlinie hinzu, die die Berechtigungen `lambda:InvokeFunctionUrl` und `lambda:InvokeFunction` gewährt. Jede Anweisung muss in einem separaten Befehl hinzugefügt werden. Ersetzen Sie den Wert von `--principal` durch Ihre AWS-Konto ID.
```
aws lambda add-permission \
--function-name my-streaming-function \
--action lambda:InvokeFunctionUrl \
--statement-id UrlPolicyInvokeURL \
--principal 123456789012 \
--function-url-auth-type AWS_IAM
```
```
aws lambda add-permission \
--function-name my-streaming-function \
--action lambda:InvokeFunction \
--statement-id UrlPolicyInvokeFunction \
--principal 123456789012
```
1. Erstellen Sie einen URL-Endpunkt für die Funktion mit dem Befehl `create-function-url-config`.
```
aws lambda create-function-url-config \
--function-name my-streaming-function \
--auth-type AWS_IAM \
--invoke-mode RESPONSE_STREAM
```
**Anmerkung**
Wenn Sie eine Fehlermeldung über `--invoke-mode` erhalten, müssen Sie möglicherweise auf eine [neuere Version der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) aktualisieren.
## Testen des Funktions-URL-Endpunkts
Testen Sie Ihre Integration, indem Sie Ihre Funktion aufrufen. Sie können die URL Ihrer Funktion in einem Browser öffnen oder curl verwenden.
```
curl --request GET "https://abcdefghijklm7nop7qrs740abcd.lambda-url.us-east-1.on.aws/" --user "AKIAIOSFODNN7EXAMPLE" --aws-sigv4 "aws:amz:us-east-1:lambda" --no-buffer
```
Unsere Funktions-URL nutzt den Authentifizierungstyp `IAM_AUTH`. Dies bedeutet, dass Sie Anfragen sowohl mit Ihrem [AWS -Zugriffsschlüssel](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) als auch mit Ihrem geheimen Schlüssel signieren müssen. Ersetzen Sie ihn im vorherigen Befehl `AKIAIOSFODNN7EXAMPLE` durch die AWS Zugriffsschlüssel-ID. Geben Sie Ihren AWS geheimen Schlüssel ein, wenn Sie dazu aufgefordert werden. Wenn Sie Ihren AWS geheimen Schlüssel nicht haben, können Sie stattdessen [temporäre AWS Anmeldeinformationen verwenden](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html).
Das Ergebnis sollte ungefähr wie folgt aussehen:
```
Streaming with Helper
Hello 0
Hello 1
Hello 2
```
## Bereinigen Ihrer Ressourcen
Sie können jetzt die Ressourcen, die Sie für dieses Tutorial erstellt haben, löschen, es sei denn, Sie möchten sie behalten. Durch das Löschen von AWS Ressourcen, die Sie nicht mehr verwenden, vermeiden Sie unnötige Kosten für Ihre AWS-Konto.
**So löschen Sie die Ausführungsrolle**
1. Öffnen Sie die Seite [Roles](https://console.aws.amazon.com/iam/home#/roles) in der IAM-Konsole.
1. Wählen Sie die von Ihnen erstellte Ausführungsrolle aus.
1. Wählen Sie **Löschen** aus.
1. Geben Sie den Namen der Rolle in das Texteingabefeld ein und wählen Sie **Delete** (Löschen) aus.
**So löschen Sie die Lambda-Funktion:**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie die Funktion aus, die Sie erstellt haben.
1. Wählen Sie **Aktionen**, **Löschen** aus.
1. Geben Sie **confirm** in das Texteingabefeld ein und wählen Sie **Delete** (Löschen) aus.
# Verwenden des Lambda-Metadaten-Endpunkts
Mit dem Lambda-Metadaten-Endpunkt können Ihre Funktionen ermitteln, in welcher Availability Zone (AZ) sie ausgeführt werden. Auf diese Weise können Sie die Latenz optimieren, indem Sie zu denselben AZ-Ressourcen wie Amazon ElastiCache - und Amazon RDS-Endpunkten weiterleiten und AZ-fähige Resilienzmuster implementieren.
Der Endpunkt gibt Metadaten in einem einfachen JSON-Format über eine Localhost-HTTP-API innerhalb der Ausführungsumgebung zurück und ist sowohl für Laufzeiten als auch für Erweiterungen zugänglich.
**Topics**
+ [
## Erste Schritte
](#metadata-endpoint-getting-started)
+ [
## Die Availability Zone verstehen IDs
](#metadata-endpoint-az-ids)
+ [
## API-Referenz
](#metadata-endpoint-api-reference)
## Erste Schritte
[Powertools for AWS Lambda](https://docs.aws.amazon.com/powertools/) bietet ein Hilfsprogramm für den Zugriff auf den Lambda-Metadaten-Endpunkt in Python TypeScript, Java und .NET. Das Hilfsprogramm speichert die Antwort nach dem ersten Aufruf im Cache und verarbeitet SnapStart die Cache-Invalidierung automatisch.
Verwenden Sie das Metadaten-Hilfsprogramm Powertools for AWS Lambda oder rufen Sie den Metadaten-Endpunkt direkt auf
------
#### [ Python ]
Installieren Sie das Powertools-Paket:
```
pip install "aws-lambda-powertools"
```
Verwenden Sie das Metadaten-Hilfsprogramm in Ihrem Handler:
**Example Abrufen der AZ-ID mit Powertools (Python)**
```
from aws_lambda_powertools.utilities.lambda_metadata import get_lambda_metadata
def handler(event, context):
metadata = get_lambda_metadata()
az_id = metadata.availability_zone_id # e.g., "use1-az1"
return {"az_id": az_id}
```
------
#### [ TypeScript ]
Installieren Sie das Powertools-Paket:
```
npm install @aws-lambda-powertools/commons
```
Verwenden Sie das Metadaten-Hilfsprogramm in Ihrem Handler:
**Example Abrufen der AZ-ID mit Powertools () TypeScript**
```
import { getMetadata } from '@aws-lambda-powertools/commons/utils/metadata';
const metadata = await getMetadata();
export const handler = async () => {
const { AvailabilityZoneID: azId } = metadata;
return azId;
};
```
------
#### [ Java ]
Fügen Sie die Powertools-Abhängigkeit zu Ihrem hinzu: `pom.xml`
```
software.amazon.lambda
powertools-lambda-metadata
2.10.0
```
Verwenden Sie den Metadaten-Client in Ihrem Handler:
**Example Abrufen der AZ-ID mit Powertools (Java)**
```
import software.amazon.lambda.powertools.metadata.LambdaMetadata;
import software.amazon.lambda.powertools.metadata.LambdaMetadataClient;
public class App implements RequestHandler {
@Override
public String handleRequest(Object input, Context context) {
LambdaMetadata metadata = LambdaMetadataClient.get();
String azId = metadata.getAvailabilityZoneId(); // e.g., "use1-az1"
return "{\"azId\": \"" + azId + "\"}";
}
}
```
------
#### [ .NET ]
Installieren Sie das Powertools-Paket:
```
dotnet add package AWS.Lambda.Powertools.Metadata
```
Verwenden Sie die Metadatenklasse in Ihrem Handler:
**Example Abrufen der AZ-ID mit Powertools (.NET)**
```
using AWS.Lambda.Powertools.Metadata;
public class Function
{
public string Handler(object input, ILambdaContext context)
{
var azId = LambdaMetadata.AvailabilityZoneId;
return $"Running in AZ: {azId}";
}
}
```
------
#### [ All Runtimes ]
Alle Lambda-Laufzeiten unterstützen den Metadaten-Endpunkt, einschließlich benutzerdefinierter Laufzeiten und Container-Images. Verwenden Sie das folgende Beispiel, um mithilfe der Umgebungsvariablen, die Lambda automatisch in der Ausführungsumgebung festlegt, direkt von Ihrer Funktion aus auf die Metadaten-API zuzugreifen.
**Example Direkter Zugriff auf den Metadaten-Endpunkt**
```
# Variables are automatically set by Lambda
METADATA_ENDPOINT="http://${AWS_LAMBDA_METADATA_API}/2026-01-15/metadata/execution-environment"
# Make the request
RESPONSE=$(curl -s -H "Authorization: Bearer ${AWS_LAMBDA_METADATA_TOKEN}" "$METADATA_ENDPOINT")
# Parse the AZ ID
AZ_ID=$(echo "$RESPONSE" | jq -r '.AvailabilityZoneID')
echo "Function is running in AZ ID: $AZ_ID"
```
------
## Die Availability Zone verstehen IDs
AZ IDs (zum Beispiel`use1-az1`) bezieht sich immer auf denselben physischen Standort für alle AWS Konten, während AZ-Namen (z. B.`us-east-1a`) in bestimmten Regionen möglicherweise unterschiedlichen physischen Infrastrukturen in jedem AWS Konto zugeordnet werden. Weitere Informationen finden Sie unter [AZ IDs für kontoübergreifende Konsistenz](https://docs.aws.amazon.com/global-infrastructure/latest/regions/az-ids.html).
**Konvertierung der AZ-ID in den AZ-Namen:**
Verwenden Sie die Amazon EC2 [DescribeAvailabilityZones](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html)EC2-API, um eine AZ-ID in einen AZ-Namen zu konvertieren. Um diese API zu verwenden, fügen Sie die `ec2:DescribeAvailabilityZones` Berechtigung zur Ausführungsrolle Ihrer Funktion hinzu.
## API-Referenz
### Umgebungsvariablen
Lambda legt in jeder Ausführungsumgebung automatisch die folgenden Umgebungsvariablen fest:
+ `AWS_LAMBDA_METADATA_API`— Die Metadaten-Serveradresse im Format `{ipv4_address}:{port}` (zum Beispiel`169.254.100.1:9001`).
+ `AWS_LAMBDA_METADATA_TOKEN`— Ein eindeutiges Authentifizierungstoken für die aktuelle Ausführungsumgebung. Lambda generiert dieses Token automatisch bei der Initialisierung. Nehmen Sie es in alle Metadaten-API-Anfragen auf.
### Endpoint
`GET http://${AWS_LAMBDA_METADATA_API}/2026-01-15/metadata/execution-environment`
### Anforderung
**Erforderliche Header:**
+ `Authorization`— Der Tokenwert aus der `AWS_LAMBDA_METADATA_TOKEN` Umgebungsvariablen mit dem Bearer-Schema:. `Bearer ` Diese tokenbasierte Authentifizierung bietet umfassenden Schutz vor SSRF-Schwachstellen (Server-Side Request Forgery). Jede Ausführungsumgebung erhält bei der Initialisierung ein eindeutiges, zufällig generiertes Token.
### Antwort
**Status:** `200 OK`
**Inhaltstyp:** `application/json`
**Cache-Steuerung:** `private, max-age=43200, immutable`
Die Antwort ist innerhalb einer Ausführungsumgebung unveränderlich. Clients sollten die Antwort zwischenspeichern und die `Cache-Control` TTL respektieren. Bei SnapStart Funktionen wird die TTL während der Initialisierung reduziert, sodass Clients die Metadaten nach der Wiederherstellung aktualisieren, wenn sich die Ausführungsumgebung möglicherweise in einer anderen AZ befindet. Wenn Sie Powertools verwenden, werden Caching und SnapStart Invalidierung automatisch durchgeführt.
**Fließtext:**
```
{
"AvailabilityZoneID": "use1-az1"
}
```
Das `AvailabilityZoneID` Feld enthält den eindeutigen Bezeichner für die Availability Zone, in der die Ausführungsumgebung ausgeführt wird.
**Anmerkung**
In future Updates können der Antwort weitere Felder hinzugefügt werden. Kunden sollten unbekannte Felder ignorieren und nicht scheitern, wenn neue Felder erscheinen.
### Fehlermeldungen
+ **401 Nicht autorisiert** — Der `Authorization` Header fehlt oder enthält ein ungültiges Token. Stellen Sie sicher, dass Sie die Prüfung bestanden haben`Bearer ${AWS_LAMBDA_METADATA_TOKEN}`.
+ **405 Methode nicht zulässig** — Die Anforderungsmethode ist nicht zulässig`GET`.
+ **500 Interner Serverfehler** — Serverseitiger Verarbeitungsfehler.