Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Erstellen Sie Ihre Anwendung mit AWS SAM
Nachdem Sie Ihrer AWS SAM Vorlage Ihre Infrastruktur als Code (IaC) hinzugefügt haben, können Sie mit dem Erstellen Ihrer Anwendung mithilfe des **sam build** Befehls beginnen. Dieser Befehl erstellt Build-Artefakte aus den Dateien in Ihrem Anwendungsprojektverzeichnis (d. h. Ihrer AWS SAM Vorlagendatei, dem Anwendungscode und allen anwendbaren sprachspezifischen Dateien und Abhängigkeiten). Diese Build-Artefakte bereiten Ihre serverlose Anwendung auf spätere Schritte der Anwendungsentwicklung vor, z. B. lokales Testen und Bereitstellen in der Cloud. AWS Sowohl beim Testen als auch bei der Bereitstellung werden Build-Artefakte als Eingaben verwendet.
Sie können **sam build** damit Ihre gesamte serverlose Anwendung erstellen. Darüber hinaus können Sie benutzerdefinierte Builds erstellen, z. B. solche mit bestimmten Funktionen, Ebenen oder benutzerdefinierten Laufzeiten. Weitere Informationen darüber, wie und warum Sie sie verwenden**sam build**, finden Sie in den Themen in diesem Abschnitt. Eine Einführung in die Verwendung des `sam build` Befehls finden Sie unter[Einführung in das Bauen mit AWS SAM](using-sam-cli-build.md).
**Topics**
+ [Einführung in das Bauen mit AWS SAM](using-sam-cli-build.md)
+ [Standardbuild mit AWS SAM](serverless-sam-cli-using-build.md)
+ [Passen Sie Builds an mit AWS SAM](building-lambda-functions.md)
# Einführung in das Bauen mit AWS SAM
Verwenden Sie den AWS Serverless Application Model Befehl Command Line Interface (AWS SAMCLI)`sam build`, um Ihre serverlose Anwendung auf nachfolgende Schritte in Ihrem Entwicklungsworkflow vorzubereiten, z. B. lokale Tests oder die Bereitstellung auf der. AWS Cloud Mit diesem Befehl wird ein `.aws-sam` Verzeichnis erstellt, das Ihre Anwendung in einem Format und an einem Speicherort strukturiert, die `sam local` `sam deploy` erforderlich sind.
+ Eine Einführung in das finden AWS SAMCLI Sie unter[Was ist das? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli).
+ Eine Liste der `sam build` Befehlsoptionen finden Sie unter[sam build](sam-cli-command-reference-sam-build.md).
+ Ein Beispiel für die Verwendung `sam build` während eines typischen Entwicklungsworkflows finden Sie unter[Schritt 2: Erstellen Sie Ihre Anwendung](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-build).
**Anmerkung**
`sam build`Für die Verwendung müssen Sie mit den grundlegenden Komponenten einer serverlosen Anwendung auf Ihrem Entwicklungscomputer beginnen. Dazu gehören eine AWS SAM Vorlage, AWS Lambda Funktionscode und alle sprachspezifischen Dateien und Abhängigkeiten. Weitere Informationen hierzu finden Sie unter [Erstellen Sie Ihre Bewerbung in AWS SAM](using-sam-cli-init.md).
**Topics**
+ [Anwendungen mit Sam Build erstellen](#using-sam-cli-build-apps)
+ [Lokales Testen und Bereitstellen](#using-sam-cli-build-test-deploy)
+ [Best Practices](#using-sam-cli-build-best)
+ [Optionen für Sam Build](#using-sam-cli-build-options)
+ [Fehlerbehebung](#using-sam-cli-build-troubleshooting)
+ [Beispiele](#using-sam-cli-build-examples)
+ [Weitere Informationen](#using-sam-cli-build-learn)
## Anwendungen mit Sam Build erstellen
Ziehen Sie vor der Verwendung in Betracht`sam build`, Folgendes zu konfigurieren:
1. **Lambda-Funktionen und -Layer** — Der `sam build` Befehl kann Lambda-Funktionen und -Layer erstellen. Weitere Informationen zu Lambda-Schichten finden Sie unter[Aufbau von Lambda-Schichten in AWS SAM](building-layers.md).
1. **Lambda-Laufzeit** — Die *Laufzeit* bietet eine sprachspezifische Umgebung, in der Ihre Funktion in einer Ausführungsumgebung ausgeführt wird, wenn sie aufgerufen wird. Sie können native und benutzerdefinierte Laufzeiten konfigurieren.
1. **Native Laufzeit** — Verfassen Sie Ihre Lambda-Funktionen in einer unterstützten Lambda-Laufzeit und erstellen Sie Funktionen für die Verwendung einer nativen Lambda-Laufzeit in der. AWS Cloud
1. **Benutzerdefinierte Laufzeit** — Verfassen Sie Ihre Lambda-Funktionen mit einer beliebigen Programmiersprache und erstellen Sie Ihre Laufzeit mit einem benutzerdefinierten Prozess, der in einem Builder makefile oder einem Drittanbieter definiert ist, z. B. esbuild Weitere Informationen hierzu finden Sie unter [Erstellen von Lambda-Funktionen mit benutzerdefinierten Laufzeiten in AWS SAM](building-custom-runtimes.md).
1. **Lambda-Pakettyp** — Lambda-Funktionen können in den folgenden Lambda-Bereitstellungspakettypen verpackt werden:
1. **ZIP-Dateiarchiv** — Enthält Ihren Anwendungscode und seine Abhängigkeiten.
1. **Container-Image** — Enthält das Basisbetriebssystem, die Laufzeit, Lambda-Erweiterungen, Ihren Anwendungscode und dessen Abhängigkeiten.
Diese Anwendungseinstellungen können konfiguriert werden, wenn eine Anwendung initialisiert wird mit. `sam init`
+ Weitere Informationen zur Verwendung von finden Sie `sam init` unter[Erstellen Sie Ihre Bewerbung in AWS SAM](using-sam-cli-init.md).
+ Weitere Informationen zur Konfiguration dieser Einstellungen in Ihrer Anwendung finden Sie unter[Standardbuild mit AWS SAM](serverless-sam-cli-using-build.md).
**So erstellen Sie eine Anwendung**
1. `cd`zur Wurzel Ihres Projekts. Dies ist derselbe Speicherort wie Ihre AWS SAM Vorlage.
```
$ cd sam-app
```
1. Führen Sie Folgendes aus:
```
sam-app $ sam build
```
**Anmerkung**
Eine häufig verwendete Option ist`--use-container`. Weitere Informationen hierzu finden Sie unter [Eine Lambda-Funktion innerhalb eines bereitgestellten Containers erstellen](#using-sam-cli-build-options-container).
Das Folgende ist ein Beispiel für die AWS SAMCLI Ausgabe:
```
sam-app $ sam build
Starting Build use cache
Manifest file is changed (new hash: 3298f1304...d4d421) or dependency folder (.aws-sam/deps/4d3dfad6-a267-47a6-a6cd-e07d6fae318c) is missing for (HelloWorldFunction), downloading dependencies and copying/building source
Building codeuri: /Users/.../sam-app/hello_world runtime: python3.12 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CleanUp
Running PythonPipBuilder:ResolveDependencies
Running PythonPipBuilder:CopySource
Running PythonPipBuilder:CopySource
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
1. Das AWS SAMCLI erstellt ein `.aws-sam` Build-Verzeichnis. Im Folgenden wird ein Beispiel gezeigt:
```
.aws-sam
├── build
│ ├── HelloWorldFunction
│ │ ├── __init__.py
│ │ ├── app.py
│ │ └── requirements.txt
│ └── template.yaml
└── build.toml
```
Je nachdem, wie Ihre Anwendung konfiguriert ist, AWS SAMCLI macht der Folgendes:
1. Lädt Abhängigkeiten im `.aws-sam/build` Verzeichnis herunter, installiert und organisiert sie.
1. Bereitet Ihren Lambda-Code vor. Dies kann das Kompilieren Ihres Codes, das Erstellen ausführbarer Binärdateien und das Erstellen von Container-Images umfassen.
1. Kopiert Build-Artefakte in das `.aws-sam` Verzeichnis. Das Format hängt vom Typ Ihres Anwendungspakets ab.
1. Bei Pakettypen mit der Erweiterung.zip-Datei sind die Artefakte noch nicht gezippt, sodass sie für lokale Tests verwendet werden können. Das AWS SAMCLI komprimiert Ihre Anwendung, wenn Sie sie verwenden. `sam deploy`
1. Für Container-Image-Pakettypen wird ein Container-Image lokal erstellt und in der `.aws-sam/build.toml` Datei referenziert.
1. Kopiert die AWS SAM Vorlage in das `.aws-sam` Verzeichnis und ändert sie bei Bedarf mit neuen Dateipfaden.
Im Folgenden sind die Hauptkomponenten aufgeführt, aus denen Ihre Build-Artefakte im `.aws-sam` Verzeichnis bestehen:
+ **Das Build-Verzeichnis** — Enthält Ihre Lambda-Funktionen und -Layer, die unabhängig voneinander strukturiert sind. Dies führt zu einer eindeutigen Struktur für jede Funktion oder Ebene im `.aws-sam/build` Verzeichnis.
+ **Die AWS SAM Vorlage** — Modifiziert mit aktualisierten Werten, die auf Änderungen während des Erstellungsprozesses basieren.
+ **Die Datei build.toml — Eine Konfigurationsdatei**, die Build-Einstellungen enthält, die von der verwendet werden. AWS SAMCLI
## Lokales Testen und Bereitstellen
Bei der Durchführung lokaler Tests mit `sam local` oder bei der Bereitstellung mit `sam deploy` AWS SAMCLI führt der wie folgt aus:
1. Zunächst wird geprüft, ob ein `.aws-sam` Verzeichnis existiert und ob sich eine AWS SAM Vorlage in diesem Verzeichnis befindet. Wenn diese Bedingungen erfüllt sind, AWS SAMCLI betrachtet der dieses Verzeichnis als das Stammverzeichnis Ihrer Anwendung.
1. Wenn diese Bedingungen nicht erfüllt sind, AWS SAMCLI betrachtet der den ursprünglichen Speicherort Ihrer AWS SAM Vorlage als Stammverzeichnis Ihrer Anwendung.
Wenn bei der Entwicklung Änderungen an Ihren ursprünglichen Anwendungsdateien vorgenommen werden, führen `sam build` Sie zunächst die Aktualisierung des `.aws-sam` Verzeichnisses durch, bevor Sie lokal testen.
## Best Practices
+ Bearbeiten Sie keinen Code unter dem `.aws-sam/build` Verzeichnis. Aktualisieren Sie stattdessen Ihren ursprünglichen Quellcode in Ihrem Projektordner und führen Sie den Befehl aus`sam build`, um das `.aws-sam/build` Verzeichnis zu aktualisieren.
+ Wenn Sie Ihre Originaldateien ändern, führen Sie den Befehl aus, `sam build` um das `.aws-sam/build` Verzeichnis zu aktualisieren.
+ Möglicherweise möchten Sie AWS SAMCLI, dass der auf das ursprüngliche Stammverzeichnis Ihres Projekts statt auf das `.aws-sam` Verzeichnis verweist, z. B. beim Entwickeln und Testen mit`sam local`. Löschen Sie das `.aws-sam` Verzeichnis oder die AWS SAM Vorlage im `.aws-sam` Verzeichnis, damit Ihr ursprüngliches Projektverzeichnis als Stammprojektverzeichnis AWS SAMCLI erkannt wird. Wenn Sie bereit sind, führen Sie den `sam build` Vorgang erneut aus, um das `.aws-sam` Verzeichnis zu erstellen.
+ Bei der Ausführung `sam build` wird das `.aws-sam/build` Verzeichnis jedes Mal überschrieben. Das `.aws-sam` Verzeichnis tut dies nicht. Wenn Sie Dateien wie Protokolle speichern möchten, speichern Sie sie in, `.aws-sam` damit sie nicht überschrieben werden.
## Optionen für Sam Build
### Aufbau einer einzigen Ressource
Geben Sie die logische ID der Ressource an, um nur diese Ressource zu erstellen. Im Folgenden wird ein Beispiel gezeigt:
```
$ sam build HelloWorldFunction
```
Um eine Ressource aus einer verschachtelten Anwendung oder einem geschachtelten Stack zu erstellen, geben Sie die logische ID der Anwendung oder des Stacks zusammen mit der logischen ID der Ressource im folgenden Format `/` an:
```
$ sam build MyNestedStack/MyFunction
```
### Eine Lambda-Funktion innerhalb eines bereitgestellten Containers erstellen
Die `--use-container` Option lädt ein Container-Image herunter und verwendet es, um Ihre Lambda-Funktionen zu erstellen. Der lokale Container wird dann in Ihrer `.aws-sam/build.toml` Datei referenziert.
Diese Option Docker muss installiert sein. Detaillierte Anweisungen finden Sie unter [Installieren von Docker](install-docker.md).
Das Folgende ist ein Beispiel für diesen Befehl:
```
$ sam build --use-container
```
Sie können das Container-Image angeben, das mit der `--build-image` Option verwendet werden soll. Im Folgenden wird ein Beispiel gezeigt:
```
$ sam build --use-container --build-image amazon/aws-sam-cli-build-image-nodejs20.x
```
Um das Container-Image anzugeben, das für eine einzelne Funktion verwendet werden soll, geben Sie die logische ID der Funktion an. Im Folgenden wird ein Beispiel gezeigt:
```
$ sam build --use-container --build-image Function1=amazon/aws-sam-cli-build-image-python3.12
```
### Übergeben Sie Umgebungsvariablen an den Build-Container
Verwenden Sie die`--container-env-var`, um Umgebungsvariablen an den Build-Container zu übergeben. Im Folgenden wird ein Beispiel gezeigt:
```
$ sam build --use-container --container-env-var Function1.GITHUB_TOKEN= --container-env-var GLOBAL_ENV_VAR=
```
Verwenden Sie die `--container-env-var-file` Option, um Umgebungsvariablen aus einer Datei zu übergeben. Im Folgenden wird ein Beispiel gezeigt:
```
$ sam build --use-container --container-env-var-file
```
Beispiel für die `env.json` Datei:
```
{
"MyFunction1": {
"GITHUB_TOKEN": "TOKEN1"
},
"MyFunction2": {
"GITHUB_TOKEN": "TOKEN2"
}
}
```
### Beschleunigen Sie die Erstellung von Anwendungen, die mehrere Funktionen enthalten
Wenn Sie eine Anwendung mit mehreren Funktionen ausführen`sam build`, AWS SAMCLI erstellt sie jede Funktion einzeln. Verwenden Sie die `--parallel` Option, um den Erstellungsprozess zu beschleunigen. Dadurch werden alle Ihre Funktionen und Ebenen gleichzeitig erstellt.
Im Folgenden finden Sie ein Beispiel für diesen Befehl:
```
$ sam build —-parallel
```
### Beschleunigen Sie die Build-Zeiten, indem Sie Ihr Projekt im Quellordner erstellen
Für unterstützte Laufzeiten und Build-Methoden können Sie die `--build-in-source` Option verwenden, Ihr Projekt direkt im Quellordner zu erstellen. Standardmäßig werden die AWS SAM CLI Builds in einem temporären Verzeichnis gespeichert, was das Kopieren von Quellcode und Projektdateien beinhaltet. Damit befinden `--build-in-source` sich die AWS SAM CLI Builds direkt in Ihrem Quellordner, was den Build-Prozess beschleunigt, da keine Dateien mehr in ein temporäres Verzeichnis kopiert werden müssen.
Eine Liste der unterstützten Laufzeiten und Build-Methoden finden Sie unter`--build-in-source`.
## Fehlerbehebung
Informationen zur Behebung von Problemen finden Sie unter[AWS SAMCLIProblembehandlung](sam-cli-troubleshooting.md). AWS SAMCLI
## Beispiele
### Erstellen einer Anwendung, die eine native Runtime- und .zip-Pakettyp verwendet
Dieses Beispiel finden Sie unter[Tutorial: Stellen Sie eine Hello World-Anwendung bereit mit AWS SAM](serverless-getting-started-hello-world.md).
### Eine Anwendung erstellen, die einen systemeigenen Laufzeit- und Image-Pakettyp verwendet
Zuerst starten wir, `sam init` um eine neue Anwendung zu initialisieren. Während des interaktiven Ablaufs wählen wir den `Image` Pakettyp aus. Im Folgenden wird ein Beispiel gezeigt:
```
$ sam init
...
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
4 - Scheduled task
5 - Standalone function
6 - Data processing
7 - Hello World Example With Powertools
8 - Infrastructure event management
9 - Serverless Connector Hello World Example
10 - Multi-step workflow with Connectors
11 - Lambda EFS example
12 - DynamoDB Example
13 - Machine Learning
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
...
10 - java8
11 - nodejs20.x
12 - nodejs18.x
13 - nodejs16.x
...
Runtime: 12
What package type would you like to use?
1 - Zip
2 - Image
Package type: 2
Based on your selections, the only dependency manager available is npm.
We will proceed copying the template using npm.
Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER
Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER
Project name [sam-app]: ENTER
Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment)
-----------------------
Generating application:
-----------------------
Name: sam-app
Base Image: amazon/nodejs18.x-base
Architectures: x86_64
Dependency Manager: npm
Output Directory: .
Configuration file: sam-app/samconfig.toml
Next steps can be found in the README file at sam-app/README.md
...
```
Das AWS SAMCLI initialisiert eine Anwendung und erstellt das folgende Projektverzeichnis:
```
sam-app
├── README.md
├── events
│ └── event.json
├── hello-world
│ ├── Dockerfile
│ ├── app.mjs
│ ├── package.json
│ └── tests
│ └── unit
│ └── test-handler.mjs
├── samconfig.toml
└── template.yaml
```
Als Nächstes starten wir, um unsere `sam build` Anwendung zu erstellen:
```
sam-app $ sam build
Building codeuri: /Users/.../build-demo/sam-app runtime: None metadata: {'DockerTag': 'nodejs18.x-v1', 'DockerContext': '/Users/.../build-demo/sam-app/hello-world', 'Dockerfile': 'Dockerfile'} architecture: arm64 functions: HelloWorldFunction
Building image for HelloWorldFunction function
Setting DockerBuildArgs: {} for HelloWorldFunction function
Step 1/4 : FROM public.ecr.aws/lambda/nodejs:18
---> f5b68038c080
Step 2/4 : COPY app.mjs package*.json ./
---> Using cache
---> 834e565aae80
Step 3/4 : RUN npm install
---> Using cache
---> 31c2209dd7b5
Step 4/4 : CMD ["app.lambdaHandler"]
---> Using cache
---> 2ce2a438e89d
Successfully built 2ce2a438e89d
Successfully tagged helloworldfunction:nodejs18.x-v1
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
### Erstellen einer Anwendung, die eine kompilierte Programmiersprache enthält
In diesem Beispiel erstellen wir mithilfe der Go Laufzeit eine Anwendung, die eine Lambda-Funktion enthält.
Zunächst initialisieren wir eine neue Anwendung `sam init` und konfigurieren unsere Anwendung für die Verwendung von: Go
```
$ sam init
...
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
...
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
...
4 - dotnetcore3.1
5 - go1.x
6 - go (provided.al2)
...
Runtime: 5
What package type would you like to use?
1 - Zip
2 - Image
Package type: 1
Based on your selections, the only dependency manager available is mod.
We will proceed copying the template using mod.
Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER
Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER
Project name [sam-app]: ENTER
Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment)
-----------------------
Generating application:
-----------------------
Name: sam-app
Runtime: go1.x
Architectures: x86_64
Dependency Manager: mod
Application Template: hello-world
Output Directory: .
Configuration file: sam-app/samconfig.toml
Next steps can be found in the README file at sam-app-go/README.md
...
```
Das AWS SAMCLI initialisiert die Anwendung. Im Folgenden finden Sie ein Beispiel für die Verzeichnisstruktur der Anwendung:
```
sam-app
├── Makefile
├── README.md
├── events
│ └── event.json
├── hello-world
│ ├── go.mod
│ ├── go.sum
│ ├── main.go
│ └── main_test.go
├── samconfig.toml
└── template.yaml
```
Wir verweisen auf die `README.md` Datei für die Anforderungen dieser Anwendung.
```
...
## Requirements
* AWS CLI already configured with Administrator permission
* [Docker installed](https://www.docker.com/community-edition)
* [Golang](https://golang.org)
* SAM CLI - [Install the SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html)
...
```
Als Nächstes testen `sam local invoke` wir unsere Funktion. Dieser Befehl Go ist fehlerhaft, da er nicht auf unserem lokalen Computer installiert ist:
```
sam-app $ sam local invoke
Invoking hello-world (go1.x)
Local image was not found.
Removing rapid images for repo public.ecr.aws/sam/emulation-go1.x
Building image.................................................................................................................................................................................................................................................
Using local image: public.ecr.aws/lambda/go:1-rapid-x86_64.
Mounting /Users/.../Playground/build/sam-app/hello-world as /var/task:ro,delegated inside runtime container
START RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31 Version: $LATEST
fork/exec /var/task/hello-world: no such file or directory: PathError
null
END RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31
REPORT RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31 Init Duration: 0.88 ms Duration: 175.75 ms Billed Duration: 176 ms Memory Size: 128 MB Max Memory Used: 128 MB
{"errorMessage":"fork/exec /var/task/hello-world: no such file or directory","errorType":"PathError"}%
```
Als Nächstes erstellen `sam build` wir unsere Anwendung. Wir stoßen auf einen Fehler, da Go es nicht auf unserem lokalen Computer installiert ist:
```
sam-app $ sam build
Starting Build use cache
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../Playground/build/sam-app/hello-world runtime: go1.x metadata: {} architecture: x86_64 functions: HelloWorldFunction
Build Failed
Error: GoModulesBuilder:Resolver - Path resolution for runtime: go1.x of binary: go was not successful
```
Wir könnten unseren lokalen Computer zwar so konfigurieren, dass er unsere Funktion korrekt erstellt, aber wir verwenden stattdessen die `--use-container` Option mit`sam build`. Der AWS SAMCLI lädt ein Container-Image herunter, erstellt unsere Funktion mit dem nativen GoModulesBuilder und kopiert die resultierende Binärdatei in unser `.aws-sam/build/HelloWorldFunction` Verzeichnis.
```
sam-app $ sam build --use-container
Starting Build use cache
Starting Build inside a container
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../build/sam-app/hello-world runtime: go1.x metadata: {} architecture: x86_64 functions: HelloWorldFunction
Fetching public.ecr.aws/sam/build-go1.x:latest-x86_64 Docker container image.....................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
Mounting /Users/.../build/sam-app/hello-world as /tmp/samcli/source:ro,delegated inside runtime container
Running GoModulesBuilder:Build
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
Das Folgende ist ein Beispiel für das `.aws-sam` Verzeichnis:
```
.aws-sam
├── build
│ ├── HelloWorldFunction
│ │ └── hello-world
│ └── template.yaml
├── build.toml
├── cache
│ └── c860d011-4147-4010-addb-2eaa289f4d95
│ └── hello-world
└── deps
```
Als nächstes rennen wir`sam local invoke`. Unsere Funktion wurde erfolgreich aufgerufen:
```
sam-app $ sam local invoke
Invoking hello-world (go1.x)
Local image is up-to-date
Using local image: public.ecr.aws/lambda/go:1-rapid-x86_64.
Mounting /Users/.../Playground/build/sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated inside runtime container
START RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479 Version: $LATEST
END RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479
REPORT RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479 Init Duration: 1.20 ms Duration: 1782.46 ms Billed Duration: 1783 ms Memory Size: 128 MB Max Memory Used: 128 MB
{"statusCode":200,"headers":null,"multiValueHeaders":null,"body":"Hello, 72.21.198.67\n"}%
```
## Weitere Informationen
Weitere Informationen zur Verwendung des `sam build` Befehls finden Sie in den folgenden Abschnitten:
+ **[Lernen AWS SAM: Sam Build](https://www.youtube.com/watch?v=fDhYKp4op_g)** — Serie „Lernen AWS SAM“ von Serverless Land amYouTube.
+ **[Lernen AWS SAM \$1 Sam Build \$1 E3](https://www.youtube.com/watch?v=vsAvRyLnB7Y)** — Serverless Land-Serie „Lernen AWS SAM“ weiter. YouTube
+ **[AWS SAM build: wie es Artefakte für den Einsatz bereitstellt (Sessions With SAM S2E8)](https://www.youtube.com/watch?v=bNbBd6XoDHg)** — Sessions mit Serien weiter. AWS SAM YouTube
+ **[AWS SAM benutzerdefinierte Builds: Wie man Makefiles verwendet, um Builds in SAM anzupassen (S2E9](https://www.youtube.com/watch?v=wpccutnSbAk)**) — Sessions mit laufenden Serien. AWS SAM YouTube
# Standardbuild mit AWS SAM
Verwenden Sie den Befehl, um Ihre serverlose Anwendung zu erstellen. `sam build` Dieser Befehl sammelt auch die Build-Artefakte der Abhängigkeiten Ihrer Anwendung und platziert sie im richtigen Format und am richtigen Speicherort für die nächsten Schritte, z. B. lokales Testen, Paketieren und Bereitstellen.
Sie geben die Abhängigkeiten Ihrer Anwendung in einer Manifestdatei wie `requirements.txt` (Python) oder `package.json` (Node.js) an, oder indem Sie die `Layers` Eigenschaft einer Funktionsressource verwenden. Die `Layers` Eigenschaft enthält eine Liste von [AWS Lambda Layer-Ressourcen](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html), von denen die Lambda-Funktion abhängt.
Das Format der Build-Artefakte Ihrer Anwendung hängt von den `PackageType` Eigenschaften der einzelnen Funktionen ab. Die Optionen für diese Eigenschaft sind:
+ **`Zip`**— Ein ZIP-Dateiarchiv, das Ihren Anwendungscode und seine Abhängigkeiten enthält. Wenn Sie Ihren Code als ZIP-Dateiarchiv verpacken, müssen Sie eine Lambda-Laufzeit für Ihre Funktion angeben.
+ **`Image`**— Ein Container-Image, das neben Ihrem Anwendungscode und seinen Abhängigkeiten auch das Basisbetriebssystem, die Laufzeit und Erweiterungen enthält.
Weitere Informationen zu Lambda-Pakettypen finden Sie unter [Lambda-Bereitstellungspakete](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) im *AWS Lambda Developer* Guide.
**Topics**
+ [Erstellen eines ZIP-Dateiarchivs](#build-zip-archive)
+ [Ein Container-Image erstellen](#build-container-image)
+ [Datei mit Container-Umgebungsvariablen](#serverless-sam-cli-using-container-environment-file)
+ [Beschleunigen Sie die Build-Zeiten, indem Sie Ihr Projekt im Quellordner erstellen](#serverless-sam-cli-using-build-in-source)
+ [Beispiele](#building-applications-examples)
+ [Gebäudefunktionen außerhalb von AWS SAM](#building-applications-skip)
## Erstellen eines ZIP-Dateiarchivs
Um Ihre serverlose Anwendung als ZIP-Dateiarchiv zu erstellen, deklarieren Sie Ihre serverlose `PackageType: Zip` Funktion.
AWS SAM erstellt Ihre Anwendung für die von Ihnen [angegebene Architektur](sam-resource-function.md#sam-function-architectures). Wenn Sie keine Architektur angeben, AWS SAM verwendet `x86_64` standardmäßig.
Wenn Ihre Lambda-Funktion von Paketen abhängt, die nativ kompilierte Programme enthalten, verwenden Sie das `--use-container` Flag. Dieses Flag kompiliert Ihre Funktionen lokal in einem Container, der sich wie eine Lambda-Umgebung verhält, sodass sie im richtigen Format vorliegen, wenn Sie sie in der Cloud bereitstellen. AWS
Wenn Sie die `--use-container` Option verwenden, wird das Container-Image standardmäßig aus [Amazon ECR AWS SAM](https://docs.aws.amazon.com/AmazonECR/latest/public/what-is-ecr.html) Public abgerufen. Wenn Sie ein Container-Image aus einem anderen Repository oder für eine bestimmte Version von AWS SAM CLI abrufen möchten, können Sie die `--build-image` Option verwenden und den URI eines alternativen Container-Images angeben. Im Folgenden finden Sie zwei Beispielbefehle zum Erstellen von Anwendungen mit Container-Images aus einer bestimmten Version von AWS SAM CLI:
```
# Build a Node.js 20 application using a container image for a specific version of AWS SAM CLI (1.136.0)
sam build --use-container --build-image public.ecr.aws/sam/build-nodejs22.x:1.136.0
# Build a function resource using the Python 3.13 container image from a specific version of AWS SAM CLI (1.136.0)(
sam build --use-container --build-image Function1=public.ecr.aws/sam/build-python3.13:1.136.0
```
Weitere Beispiele für die Erstellung einer ZIP-Dateiarchivanwendung finden Sie im Abschnitt Beispiele weiter unten in diesem Thema.
## Ein Container-Image erstellen
Um Ihre serverlose Anwendung als Container-Image zu erstellen, deklarieren `PackageType: Image` Sie Ihre serverlose Funktion. Sie müssen auch das `Metadata` Ressourcenattribut mit den folgenden Einträgen deklarieren:
`Dockerfile`
Der Name der Dockerfile, die der Lambda-Funktion zugeordnet ist.
`DockerContext`
Der Speicherort des Dockerfiles.
`DockerTag`
(Optional) Ein Tag, das auf das erstellte Image angewendet werden soll.
`DockerBuildArgs`
Generieren Sie Argumente für den Build.
Das AWS SAMCLI redigiert oder verschleiert keine Informationen, die Sie in Argumenten angeben. `DockerBuildArgs` Es wird dringend empfohlen, mit diesem Abschnitt keine vertraulichen Informationen wie Passwörter oder Secrets zu speichern.
Im Folgenden finden Sie ein Beispiel für einen Abschnitt mit `Metadata` Ressourcenattributen:
```
Metadata:
Dockerfile: Dockerfile
DockerContext: ./hello_world
DockerTag: v1
```
Informationen zum Herunterladen einer Beispielanwendung, die mit dem `Image` Pakettyp konfiguriert ist, finden Sie unter[Tutorial: Stellen Sie eine Hello World-Anwendung bereit mit AWS SAM](serverless-getting-started-hello-world.md). Wenn Sie gefragt werden, welchen Pakettyp Sie installieren möchten, wählen Sie`Image`.
**Anmerkung**
Wenn Sie in Ihrem Dockerfile ein Basis-Image mit mehreren Architekturen angeben, AWS SAM erstellt es Ihr Container-Image für die Architektur Ihres Host-Computers. Um für eine andere Architektur zu erstellen, geben Sie ein Basis-Image an, das die spezifische Zielarchitektur verwendet.
## Datei mit Container-Umgebungsvariablen
Um eine JSON-Datei bereitzustellen, die Umgebungsvariablen für den Build-Container enthält, verwenden Sie das `--container-env-var-file` Argument zusammen mit dem `sam build` Befehl. Sie können eine einzelne Umgebungsvariable angeben, die für alle serverlosen Ressourcen gilt, oder unterschiedliche Umgebungsvariablen für jede Ressource.
### Format
Das Format für die Übergabe von Umgebungsvariablen an einen Build-Container hängt davon ab, wie viele Umgebungsvariablen Sie für Ihre Ressourcen bereitstellen.
Um eine einzige Umgebungsvariable für alle Ressourcen bereitzustellen, geben Sie ein `Parameters` Objekt wie das Folgende an:
```
{
"Parameters": {
"GITHUB_TOKEN": "TOKEN_GLOBAL"
}
}
```
Um für jede Ressource unterschiedliche Umgebungsvariablen bereitzustellen, geben Sie Objekte für jede Ressource wie folgt an:
```
{
"MyFunction1": {
"GITHUB_TOKEN": "TOKEN1"
},
"MyFunction2": {
"GITHUB_TOKEN": "TOKEN2"
}
}
```
Speichern Sie Ihre Umgebungsvariablen als Datei, z. B. mit dem Namen`env.json`. Der folgende Befehl verwendet diese Datei, um Ihre Umgebungsvariablen an den Build-Container zu übergeben:
```
sam build --use-container --container-env-var-file env.json
```
### Precedence
+ Die Umgebungsvariablen, die Sie für bestimmte Ressourcen angeben, haben Vorrang vor der einzelnen Umgebungsvariablen für alle Ressourcen.
+ Umgebungsvariablen, die Sie in der Befehlszeile angeben, haben Vorrang vor Umgebungsvariablen in einer Datei.
## Beschleunigen Sie die Build-Zeiten, indem Sie Ihr Projekt im Quellordner erstellen
Für unterstützte Laufzeiten und Build-Methoden können Sie die `--build-in-source` Option verwenden, um Ihr Projekt direkt im Quellordner zu erstellen. Standardmäßig werden die AWS SAM CLI Builds in einem temporären Verzeichnis gespeichert, was das Kopieren von Quellcode und Projektdateien beinhaltet. Damit befinden `--build-in-source` sich die AWS SAM CLI Builds direkt in Ihrem Quellordner, was den Build-Prozess beschleunigt, da keine Dateien mehr in ein temporäres Verzeichnis kopiert werden müssen.
Eine Liste der unterstützten Laufzeiten und Build-Methoden finden Sie unter`--build-in-source`.
## Beispiele
### Beispiel 1: ZIP-Dateiarchiv
Mit den folgenden `sam build` Befehlen wird ein ZIP-Dateiarchiv erstellt:
```
# Build all functions and layers, and their dependencies
sam build
# Run the build process inside a Docker container that functions like a Lambda environment
sam build --use-container
# Build a Node.js 20 application using a container image for a specific version of AWS SAM CLI (1.136.0)
sam build --use-container --build-image public.ecr.aws/sam/build-nodejs22.x:1.136.0
# Build a function resource using the Python 3.13 container image from a specific version of AWS SAM CLI (1.136.0)(
sam build --use-container --build-image Function1=public.ecr.aws/sam/build-python3.13:1.136.0
# Build and run your functions locally
sam build && sam local invoke
# For more options
sam build --help
```
### Beispiel 2: Container-Image
Die folgende AWS SAM Vorlage wird als Container-Image erstellt:
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
PackageType: Image
ImageConfig:
Command: ["app.lambda_handler"]
Metadata:
Dockerfile: Dockerfile
DockerContext: ./hello_world
DockerTag: v1
```
Im Folgenden finden Sie ein Beispiel für eine Dockerfile:
```
FROM public.ecr.aws/lambda/python:3.12
COPY app.py requirements.txt ./
RUN python3.12 -m pip install -r requirements.txt
# Overwrite the command by providing a different command directly in the template.
CMD ["app.lambda_handler"]
```
### Beispiel 3: npm ci
Für Anwendungen mit Node.js können Sie `npm ci` anstelle von `npm install` Abhängigkeiten verwenden. Geben Sie zur Verwendung `npm ci` `BuildProperties` im `Metadata` Ressourcenattribut Ihrer Lambda-Funktion `UseNpmCi: True` unter an. Um sie verwenden zu können`npm ci`, muss Ihre Anwendung eine `package-lock.json` `npm-shrinkwrap.json` OR-Datei in der `CodeUri` for your Lambda-Funktion enthalten.
Das folgende Beispiel dient `npm ci` zur Installation von Abhängigkeiten bei der Ausführung`sam build`:
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello-world/
Handler: app.handler
Runtime: nodejs20.x
Architectures:
- x86_64
Events:
HelloWorld:
Type: Api
Properties:
Path: /hello
Method: get
Metadata:
BuildProperties:
UseNpmCi: True
```
### Python-Elternpakete
Bei Python-Anwendungen können Sie Ihre Paketstruktur während des Build-Prozesses beibehalten, um absolute Importe zu ermöglichen. Um die Paketstruktur beizubehalten, geben Sie `BuildProperties` im `Metadata` Ressourcenattribut Ihrer Lambda-Funktion `ParentPackageMode` unter an.
Im folgenden Beispiel wird die `app` Paketstruktur bei der Ausführung beibehalten: `sam build`
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello-world/
Handler: app.main.handler
Runtime: python3.12
Architectures:
- x86_64
Metadata:
BuildProperties:
ParentPackageMode: explicit
ParentPackages: app
```
Mit dieser Konfiguration kann Ihr Code absolute Importe wie `from app.utils import logger` anstelle von relativen Importen wie `from .utils import logger` verwenden.
## Gebäudefunktionen außerhalb von AWS SAM
Standardmäßig werden beim Ausführen **sam build** alle Ihre Funktionsressourcen AWS SAM erstellt. Weitere Optionen sind:
+ **Alle Funktionsressourcen außerhalb von** erstellen AWS SAM— Wenn Sie all Ihre Funktionsressourcen manuell oder mit einem anderen Tool erstellen, **sam build** ist dies nicht erforderlich. Sie können den Vorgang überspringen **sam build** und mit dem nächsten Schritt in Ihrem Prozess fortfahren, z. B. dem Durchführen lokaler Tests oder dem Bereitstellen Ihrer Anwendung.
+ **Erstellen Sie einige Funktionsressourcen außerhalb von AWS SAM** — Wenn Sie einige Ihrer Funktionsressourcen erstellen und gleichzeitig andere Funktionsressourcen außerhalb von erstellen möchten AWS SAM AWS SAM, können Sie dies in Ihrer AWS SAM Vorlage angeben.
### Erstellen Sie einige Funktionsressourcen außerhalb von AWS SAM
Damit bei der Verwendung eine Funktion AWS SAM übersprungen **sam build** wird, konfigurieren Sie in Ihrer AWS SAM Vorlage Folgendes:
1. Fügen Sie die `SkipBuild: True` Metadaten-Eigenschaft zu Ihrer Funktion hinzu.
1. Geben Sie den Pfad zu Ihren erstellten Funktionsressourcen an.
Hier ist ein Beispiel, das `TestFunction` so konfiguriert ist, dass es übersprungen wird. Die erstellten Ressourcen befinden sich unter`built-resources/TestFunction.zip`.
```
TestFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: built-resources/TestFunction.zip
Handler: TimeHandler::handleRequest
Runtime: java11
Metadata:
SkipBuild: True
```
Wenn Sie jetzt laufen**sam build**, AWS SAM werden Sie Folgendes tun:
1. AWS SAM überspringt Funktionen, die mit konfiguriert wurden`SkipBuild: True`.
1. AWS SAM erstellt alle anderen Funktionsressourcen und speichert sie im `.aws-sam` Build-Verzeichnis.
1. Bei übersprungenen Funktionen wird ihre Vorlage im `.aws-sam` Build-Verzeichnis automatisch aktualisiert, sodass sie auf den angegebenen Pfad zu Ihren erstellten Funktionsressourcen verweist.
Hier ist ein Beispiel für die zwischengespeicherte Vorlage für `TestFunction` im `.aws-sam` Build-Verzeichnis:
```
TestFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ../../built-resources/TestFunction.zip
Handler: TimeHandler::handleRequest
Runtime: java11
Metadata:
SkipBuild: True
```
# Passen Sie Builds an mit AWS SAM
Sie können Ihren Build so anpassen, dass er bestimmte Lambda-Funktionen oder Lambda-Schichten enthält. Eine Funktion ist eine Ressource, die Sie aufrufen können, um Ihren Code in Lambda auszuführen. Eine Lambda-Schicht ermöglicht es Ihnen, Code aus einer Lambda-Funktion zu extrahieren, der dann für mehrere Lambda-Funktionen wiederverwendet werden kann. Sie können Ihren Build mit bestimmten Lambda-Funktionen anpassen, wenn Sie sich auf die Entwicklung und Bereitstellung einzelner serverloser Funktionen konzentrieren möchten, ohne die Komplexität der Verwaltung gemeinsam genutzter Abhängigkeiten oder Ressourcen. Darüber hinaus können Sie eine Lambda-Schicht erstellen, um die Größe Ihrer Bereitstellungspakete zu reduzieren, die Logik der Kernfunktionen von Abhängigkeiten zu trennen und Abhängigkeiten für mehrere Funktionen gemeinsam zu nutzen.
In den Themen in diesem Abschnitt werden einige der verschiedenen Möglichkeiten beschrieben, mit AWS SAM denen Sie Lambda-Funktionen erstellen können. Dazu gehören die Erstellung von Lambda-Funktionen mit Kundenlaufzeiten und die Erstellung von Lambda-Layern. Mit benutzerdefinierten Laufzeiten können Sie eine Sprache installieren und verwenden, die nicht in den Lambda-Laufzeiten im Developer Guide aufgeführt ist AWS Lambda . Auf diese Weise können Sie eine spezielle Ausführungsumgebung für die Ausführung serverloser Funktionen und Anwendungen erstellen. Wenn Sie nur Lambda-Schichten erstellen (anstatt Ihre gesamte Anwendung zu erstellen), können Sie in mehrfacher Hinsicht davon profitieren. Es kann Ihnen helfen, die Größe Ihrer Bereitstellungspakete zu reduzieren, die Logik der Kernfunktionen von Abhängigkeiten zu trennen und Abhängigkeiten für mehrere Funktionen gemeinsam zu nutzen.
Weitere Informationen zu Funktionen finden Sie unter [Lambda-Konzepte](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html) im *AWS Lambda Developer Guide*.
**Topics**
+ [Lambda-Funktionen von Node.js mit esbuild in erstellen AWS SAM](serverless-sam-cli-using-build-typescript.md)
+ [Erstellen von.NET-Lambda-Funktionen mit nativer AOT-Kompilierung in AWS SAM](build-dotnet7.md)
+ [Erstellen von Rust Lambda-Funktionen mit Cargo Lambda in AWS SAM](building-rust.md)
+ [Python-Lambda-Funktionen mit uv in erstellen AWS SAM](building-python-uv.md)
+ [Erstellen von Lambda-Funktionen mit benutzerdefinierten Laufzeiten in AWS SAM](building-custom-runtimes.md)
+ [Aufbau von Lambda-Schichten in AWS SAM](building-layers.md)
# Lambda-Funktionen von Node.js mit esbuild in erstellen AWS SAM
Um die AWS Lambda Funktionen von Node.js zu erstellen und zu verpacken, können Sie den AWS SAMCLI mit dem JavaScript Esbuild-Bundler verwenden. Der Esbuild-Bundler unterstützt Lambda-Funktionen, in die Sie schreiben. TypeScript
Um eine Lambda-Funktion von Node.js mit esbuild zu erstellen, fügen Sie Ihrer `AWS:Serverless::Function` Ressource ein `Metadata` Objekt hinzu und geben Sie `esbuild` für die an. `BuildMethod` Wenn Sie den **sam build** Befehl ausführen, AWS SAM verwendet esbuild, um Ihren Lambda-Funktionscode zu bündeln.
## Eigenschaften von Metadaten
Das `Metadata` Objekt unterstützt die folgenden Eigenschaften für esbuild.
### BuildMethod
Gibt den Bundler für Ihre Anwendung an. Der einzige unterstützte Wert ist `esbuild`.
### BuildProperties
Gibt die Build-Eigenschaften für Ihren Lambda-Funktionscode an.
Das `BuildProperties` Objekt unterstützt die folgenden Eigenschaften für esbuild. Alle Eigenschaften sind optional. AWS SAM Verwendet standardmäßig Ihren Lambda-Funktionshandler für den Einstiegspunkt.
**EntryPoints**
Gibt Einstiegspunkte für Ihre Anwendung an.
**Extern**
Gibt die Liste der Pakete an, die beim Build weggelassen werden sollen. Weitere Informationen finden Sie auf der *esbuildWebsite* unter [Extern](https://esbuild.github.io/api/#external).
**Format**
Gibt das Ausgabeformat der generierten JavaScript Dateien in Ihrer Anwendung an. Weitere Informationen finden Sie unter [Format](https://esbuild.github.io/api/#format) auf der *Esbuild-Website*.
**Loader**
Gibt die Liste der Konfigurationen zum Laden von Daten für einen bestimmten Dateityp an.
**MainFields**
Gibt an, welche `package.json` Felder beim Auflösen eines Pakets importiert werden sollen. Der Standardwert ist `main,module`.
**Verkleinern**
Gibt an, ob der gebündelte Ausgabecode minimiert werden soll. Der Standardwert ist `true`.
**OutExtension**
Passen Sie die Dateierweiterung der Dateien an, die esbuild generiert. Weitere Informationen finden Sie unter [Out-Erweiterung auf](https://esbuild.github.io/api/#out-extension) der *Esbuild-Website*.
**Quellenkarte**
Gibt an, ob der Bundler eine Quellzuordnungsdatei erzeugt. Der Standardwert ist `false`.
Wenn auf gesetzt`true`, `NODE_OPTIONS: --enable-source-maps` wird es an die Umgebungsvariablen der Lambda-Funktion angehängt, und eine Quellenzuordnung wird generiert und in die Funktion aufgenommen.
Alternativ `NODE_OPTIONS: --enable-source-maps` wird, wenn in den Umgebungsvariablen der Funktion enthalten `Sourcemap` ist, automatisch auf gesetzt. `true`
Im Konfliktfall hat `Sourcemap: false` dies Vorrang vor. `NODE_OPTIONS: --enable-source-maps`
Standardmäßig verschlüsselt Lambda alle ruhenden Umgebungsvariablen mit AWS Key Management Service ()AWS KMS. Wenn Sie Quellzuordnungen verwenden, muss die Ausführungsrolle Ihrer Funktion über die Berechtigung zum Ausführen der Aktion verfügen, damit die `kms:Encrypt` Bereitstellung erfolgreich ist.
**SourcesContent**
Gibt an, ob der Quellcode in die Quellzuordnungsdatei aufgenommen werden soll. Konfigurieren Sie diese Eigenschaft, wenn sie auf gesetzt `Sourcemap` ist`'true'`.
+ Geben Sie `SourcesContent: 'true'` an, dass der gesamte Quellcode eingeschlossen werden soll.
+ Geben Sie `SourcesContent: 'false'` an, dass der gesamte Quellcode ausgeschlossen werden soll. Dies führt zu kleineren Quellzuordnungsdateien, was in der Produktion nützlich ist, da die Startzeiten reduziert werden. Der Quellcode wird jedoch nicht im Debugger verfügbar sein.
Der Standardwert ist `SourcesContent: true`.
Weitere Informationen finden Sie unter [Quelleninhalt](https://esbuild.github.io/api/#sources-content) auf der *Esbuild-Website*.
**Target**
Gibt die ECMAScript Zielversion an. Der Standardwert ist `es2020`.
## TypeScript Beispiel für eine Lambda-Funktion
Das folgende Beispiel für einen AWS SAM Vorlagenausschnitt verwendet esbuild, um eine Node.js Lambda-Funktion aus dem Code in zu erstellen. TypeScript `hello-world/app.ts`
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello-world/
Handler: app.handler
Runtime: nodejs20.x
Architectures:
- x86_64
Events:
HelloWorld:
Type: Api
Properties:
Path: /hello
Method: get
Environment:
Variables:
NODE_OPTIONS: --enable-source-maps
Metadata:
BuildMethod: esbuild
BuildProperties:
Format: esm
Minify: false
OutExtension:
- .js=.mjs
Target: "es2020"
Sourcemap: true
EntryPoints:
- app.ts
External:
- ""
```
# Erstellen von.NET-Lambda-Funktionen mit nativer AOT-Kompilierung in AWS SAM
Erstellen und verpacken Sie Ihre .NET AWS Lambda 8-Funktionen mit AWS Serverless Application Model (AWS SAM). Verwenden Sie dabei die native Kompilierung Ahead-of-Time (AOT), um die AWS Lambda Kaltstartzeiten zu verbessern.
**Topics**
+ [Überblick über .NET 8 Native AOT](#build-dotnet7-overview)
+ [Verwendung AWS SAM mit Ihren.NET-8-Lambda-Funktionen](#build-dotnet7-sam)
+ [Voraussetzungen für die Installation](#build-dotnet7-prerequisites)
+ [Definieren Sie.NET 8 Lambda-Funktionen in Ihrer Vorlage AWS SAM](#build-dotnet7-sam-define)
+ [Erstellen Sie Ihre Anwendung mit AWS SAMCLI](#build-dotnet7-sam-build)
+ [Weitere Informationen](#build-dotnet7-learn-more)
## Überblick über .NET 8 Native AOT
In der Vergangenheit hatten die.NET-Lambda-Funktionen Kaltstartzeiten, die sich auf die Benutzererfahrung, die Systemlatenz und die Nutzungskosten Ihrer serverlosen Anwendungen auswirken. Mit.NET Native AOT-Kompilierung können Sie die Kaltstartzeiten Ihrer Lambda-Funktionen verbessern. *Weitere Informationen zu Native AOT für .NET 8 finden Sie unter [Verwenden von Native AOT](https://github.com/dotnet/runtime/tree/main/src/coreclr/nativeaot#readme) im Dotnet-Repository. GitHub *
## Verwendung AWS SAM mit Ihren.NET-8-Lambda-Funktionen
Gehen Sie wie folgt vor, um Ihre .NET 8-Lambda-Funktionen mit der AWS Serverless Application Model (AWS SAM) zu konfigurieren:
+ Installieren Sie die erforderlichen Komponenten auf Ihrem Entwicklungscomputer.
+ Definieren Sie .NET 8 Lambda-Funktionen in Ihrer AWS SAM Vorlage.
+ Erstellen Sie Ihre Anwendung mit dem AWS SAMCLI.
## Voraussetzungen für die Installation
Die folgenden Voraussetzungen sind erforderlich:
+ Die AWS SAMCLI
+ Die.NET Core CLI
+ Das globale .NET Core-Tool von Amazon.Lambda.Tools
+ Docker
**Installieren Sie das AWS SAMCLI**
1. Um zu überprüfen, ob Sie das bereits AWS SAMCLI installiert haben, führen Sie Folgendes aus:
```
sam --version
```
1. Informationen zur Installation von AWS SAMCLI finden Sie unter[Installieren Sie das AWS SAMCLI](install-sam-cli.md).
1. Informationen zum Upgrade einer installierten Version von finden Sie unter[Aktualisierung des AWS SAMCLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade). AWS SAMCLI
**Installieren Sie das.NET Core CLI**
1. Informationen zum Herunterladen und Installieren von.NET Core-CLI finden [Sie unter .NET von der Microsoft-Website herunterladen](https://dotnet.microsoft.com/download).
1. Weitere Informationen zur.NET Core CLI finden Sie [unter.NET Core CLI](https://docs.aws.amazon.com/lambda/latest/dg/csharp-package-cli.html) im *AWS Lambda Developer Guide*.
**Installieren Sie das Amazon.Lambda.Tools .NET Core Global Tool**
1. Führen Sie den folgenden Befehl aus:
```
dotnet tool install -g Amazon.Lambda.Tools
```
1. Wenn Sie das Tool bereits installiert haben, können Sie sich mit dem folgenden Befehl vergewissern, dass Sie die neueste Version verwenden:
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Weitere Informationen zum Amazon.Lambda.Tools .NET Core Global Tool finden Sie im [AWS Extensions](https://github.com/aws/aws-extensions-for-dotnet-cli) for .NET CLI Repository unter. GitHub
**Installieren Docker**
+ Das Erstellen mit nativem AOT muss installiert werden. Docker Installationsanweisungen finden Sie unter [Installation von Docker zur Verwendung mit dem AWS SAMCLI](install-docker.md).
## Definieren Sie.NET 8 Lambda-Funktionen in Ihrer Vorlage AWS SAM
Um eine zu definieren. NET8 Gehen Sie in der Lambda-Funktion in Ihrer AWS SAM Vorlage wie folgt vor:
1. Führen Sie den folgenden Befehl in einem Startverzeichnis Ihrer Wahl aus:
```
sam init
```
1. Wählen Sie `AWS Quick Start Templates` diese Option, um eine Startvorlage auszuwählen.
1. Wählen Sie als Vorlage `Hello World Example` aus.
1. Geben Sie ein, dass Sie nicht den gängigsten Laufzeit- und Pakettyp verwenden möchten`n`.
1. Wählen Sie für Runtime`dotnet8`.
1. Wählen Sie als Pakettyp`Zip`.
1. Wählen Sie für Ihre Starter-Vorlage`Hello World Example using native AOT`.
**Installieren Docker**
+ Building with Native AOT, Docker muss installiert sein. Installationsanweisungen finden Sie unter [Installation von Docker zur Verwendung mit dem AWS SAMCLI](install-docker.md).
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src/HelloWorldAot/
Handler: bootstrap
Runtime: dotnet8
Architectures:
- x86_64
Events:
HelloWorldAot:
Type: Api
Properties:
Path: /hello
Method: get
```
**Anmerkung**
Wenn die `Event` Eigenschaft von auf gesetzt `AWS::Serverless::Function` ist`Api`, die `RestApiId` Eigenschaft aber nicht angegeben ist, wird die `AWS::ApiGateway::RestApi` CloudFormation Ressource AWS SAM generiert.
## Erstellen Sie Ihre Anwendung mit AWS SAMCLI
Führen Sie im Stammverzeichnis Ihres Projekts den `sam build` Befehl aus, um mit der Erstellung Ihrer Anwendung zu beginnen. Wenn die `PublishAot` Eigenschaft in Ihrer .NET 8-Projektdatei definiert wurde, AWS SAMCLI wird sie mit der systemeigenen AOT-Kompilierung erstellt. Weitere Informationen zu dieser `PublishAot` Eigenschaft finden Sie unter [Native AOT Deployment](https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/) in der *.NET-Dokumentation* von Microsoft.
Um Ihre Funktion zu erstellen, AWS SAMCLI ruft die .NET Core CLI auf, die das Amazon.Lambda.Tools .NET Core Global Tool verwendet.
**Anmerkung**
Wenn beim Erstellen eine `.sln` Datei im selben oder einem übergeordneten Verzeichnis Ihres Projekts vorhanden ist, wird das Verzeichnis, das die `.sln` Datei enthält, in den Container gemountet. Wenn eine `.sln` Datei nicht gefunden wird, wird nur der Projektordner bereitgestellt. Wenn Sie eine Multiprojektanwendung erstellen, stellen Sie daher sicher, dass sich die `.sln` Datei im richtigen Verzeichnis befindet.
## Weitere Informationen
Weitere Informationen zum Erstellen von.NET 8-Lambda-Funktionen finden Sie unter [Einführung in die .NET 8-Laufzeit für AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-net-8-runtime-for-aws-lambda/).
Eine Referenz zu dem **sam build** Befehl finden Sie unter[sam build](sam-cli-command-reference-sam-build.md).
# Erstellen von Rust Lambda-Funktionen mit Cargo Lambda in AWS SAM
| |
| --- |
| Diese Funktion befindet sich in der Vorschauversion für AWS SAM und kann sich ändern. |
Verwenden Sie die AWS Serverless Application Model Befehlszeilenschnittstelle (AWS SAMCLI) mit Ihren AWS Lambda Rust-Funktionen.
**Topics**
+ [Voraussetzungen](#building-rust-prerequisites)
+ [Konfiguration AWS SAM für die Verwendung mit Rust Lambda-Funktionen](#building-rust-configure)
+ [Beispiele](#building-rust-examples)
## Voraussetzungen
**RustSprache**
Informationen zur Installation Rust finden [Sie unter Installieren Rust](https://www.rust-lang.org/tools/install) auf der *RustSprachwebsite*.
**Cargo Lambda**
Das AWS SAMCLI erfordert die Installation von [https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html](https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html), einen Unterbefehl fürCargo. Installationsanweisungen finden Sie in der *Cargo LambdaDokumentation* unter [Installation](https://www.cargo-lambda.info/guide/installation.html).
**Docker**
Das Erstellen und Testen von Rust Lambda-Funktionen erfordertDocker. Installationsanweisungen finden Sie unter [Installieren von Docker](install-docker.md).
**Melden Sie sich für die AWS SAMCLI Beta-Funktion an**
Da es sich bei dieser Funktion um eine Vorschauversion handelt, müssen Sie sich mit einer der folgenden Methoden anmelden:
1. Verwenden Sie die Umgebungsvariable:`SAM_CLI_BETA_RUST_CARGO_LAMBDA=1`.
1. Fügen Sie der `samconfig.toml`-Datei Folgendes hinzu:
```
[default.build.parameters]
beta_features = true
[default.sync.parameters]
beta_features = true
```
1. Verwenden Sie die `--beta-features` Option, wenn Sie einen unterstützten AWS SAMCLI Befehl verwenden. Beispiel:
```
$ sam build --beta-features
```
1. Wählen Sie die Option`y`, wenn Sie AWS SAMCLI aufgefordert werden, sich anzumelden. Im Folgenden wird ein Beispiel gezeigt:
```
$ sam build
Starting Build use cache
Build method "rust-cargolambda" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
```
## Konfiguration AWS SAM für die Verwendung mit Rust Lambda-Funktionen
### Schritt 1: Konfigurieren Sie Ihre Vorlage AWS SAM
Konfigurieren Sie Ihre AWS SAM Vorlage wie folgt:
+ **Binär** — Optional. Geben Sie an, wann Ihre Vorlage mehrere Rust-Lambda-Funktionen enthält.
+ **BuildMethod** – `rust-cargolambda`.
+ **CodeUri**— Pfad zu deiner `Cargo.toml` Datei.
+ **Handler** —`bootstrap`.
+ **Laufzeit** —`provided.al2`.
Weitere Informationen zu benutzerdefinierten Laufzeiten finden Sie unter [Benutzerdefinierte AWS Lambda Laufzeiten](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html) im *AWS Lambda Entwicklerhandbuch*.
Hier ist ein Beispiel für eine konfigurierte AWS SAM Vorlage:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties: function_a
Properties:
CodeUri: ./rust_app
Handler: bootstrap
Runtime: provided.al2
...
```
### Schritt 2: Verwenden Sie die AWS SAMCLI mit Ihrer Rust Lambda-Funktion
Verwenden Sie einen beliebigen AWS SAMCLI Befehl mit Ihrer AWS SAM Vorlage. Weitere Informationen finden Sie unter [AWS SAM CLI](using-sam-cli.md).
## Beispiele
### Beispiel Hello World
**In diesem Beispiel erstellen wir die Hello World-Beispielanwendung Rust als Laufzeit.**
Zunächst initialisieren wir eine neue serverlose Anwendung mit. `sam init` Während des interaktiven Ablaufs wählen wir die **Hello World-Anwendung** und wählen die **Rust-Laufzeit** aus.
```
$ sam init
...
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
...
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
1 - dotnet8
2 - dotnet6
3 - go (provided.al2)
...
18 - python3.11
19 - python3.10
20 - ruby3.3
21 - ruby3.2
22 - rust (provided.al2)
23 - rust (provided.al2023)
Runtime: 22
Based on your selections, the only Package type available is Zip.
We will proceed to selecting the Package type as Zip.
Based on your selections, the only dependency manager available is cargo.
We will proceed copying the template using cargo.
Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER
Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER
Project name [sam-app]: hello-rust
-----------------------
Generating application:
-----------------------
Name: hello-rust
Runtime: rust (provided.al2)
Architectures: x86_64
Dependency Manager: cargo
Application Template: hello-world
Output Directory: .
Configuration file: hello-rust/samconfig.toml
Next steps can be found in the README file at hello-rust/README.md
Commands you can use next
=========================
[*] Create pipeline: cd hello-rust && sam pipeline init --bootstrap
[*] Validate SAM template: cd hello-rust && sam validate
[*] Test Function in the Cloud: cd hello-rust && sam sync --stack-name {stack-name} --watch
```
Im Folgenden ist die Struktur unserer Hello World-Anwendung dargestellt:
```
hello-rust
├── README.md
├── events
│ └── event.json
├── rust_app
│ ├── Cargo.toml
│ └── src
│ └── main.rs
├── samconfig.toml
└── template.yaml
```
In unserer AWS SAM Vorlage ist unsere Rust Funktion wie folgt definiert:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
Properties:
CodeUri: ./rust_app
Handler: bootstrap
Runtime: provided.al2
Architectures:
- x86_64
Events:
HelloWorld:
Type: Api
Path: /hello
Method: get
```
Als Nächstes erstellen wir `sam build` unsere Anwendung und bereiten sie auf die Bereitstellung vor. Das AWS SAMCLI erstellt ein `.aws-sam` Verzeichnis und organisiert dort unsere Build-Artefakte. Unsere Funktion wird unter Verwendung einer ausführbaren Binärdatei erstellt Cargo Lambda und als solche gespeichert. `.aws-sam/build/HelloWorldFunction/bootstrap`
**Anmerkung**
Wenn Sie den **sam local invoke** Befehl in macOS ausführen möchten, müssen Sie vor dem Aufrufen andere Funktionen erstellen. Verwenden Sie dazu den folgenden Befehl:
**SAM\$1BUILD\$1MODE=debug sam build**
Dieser Befehl wird nur benötigt, wenn lokale Tests durchgeführt werden sollen. Dies wird nicht empfohlen, wenn Sie für die Bereitstellung erstellen.
```
hello-rust$ sam build
Starting Build use cache
Build method "rust-cargolambda" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
Experimental features are enabled for this session.
Visit the docs page to learn more about the AWS Beta terms https://aws.amazon.com/service-terms/.
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../hello-rust/rust_app runtime: provided.al2 metadata: {'BuildMethod': 'rust-cargolambda'} architecture: x86_64 functions: HelloWorldFunction
Running RustCargoLambdaBuilder:CargoLambdaBuild
Running RustCargoLambdaBuilder:RustCopyAndRename
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
Als Nächstes stellen wir unsere Anwendung bereit mit`sam deploy --guided`.
```
hello-rust$ sam deploy --guided
Configuring SAM deploy
======================
Looking for config file [samconfig.toml] : Found
Reading default arguments : Success
Setting default arguments for 'sam deploy'
=========================================
Stack Name [hello-rust]: ENTER
AWS Region [us-west-2]: ENTER
#Shows you resources changes to be deployed and require a 'Y' to initiate deploy
Confirm changes before deploy [Y/n]: ENTER
#SAM needs permission to be able to create roles to connect to the resources in your template
Allow SAM CLI IAM role creation [Y/n]: ENTER
#Preserves the state of previously provisioned resources when an operation fails
Disable rollback [y/N]: ENTER
HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y
Save arguments to configuration file [Y/n]: ENTER
SAM configuration file [samconfig.toml]: ENTER
SAM configuration environment [default]: ENTER
Looking for resources needed for deployment:
...
Uploading to hello-rust/56ba6585d80577dd82a7eaaee5945c0b 817973 / 817973 (100.00%)
Deploying with following values
===============================
Stack name : hello-rust
Region : us-west-2
Confirm changeset : True
Disable rollback : False
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_IAM"]
Parameter overrides : {}
Signing Profiles : {}
Initiating deployment
=====================
Uploading to hello-rust/a4fc54cb6ab75dd0129e4cdb564b5e89.template 1239 / 1239 (100.00%)
Waiting for changeset to be created..
CloudFormation stack changeset
---------------------------------------------------------------------------------------------------------
Operation LogicalResourceId ResourceType Replacement
---------------------------------------------------------------------------------------------------------
+ Add HelloWorldFunctionHelloW AWS::Lambda::Permission N/A
orldPermissionProd
...
---------------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1681427201/f0ef1563-5ab6-4b07-9361-864ca3de6ad6
Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: y
2023-04-13 13:07:17 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 5.0 seconds)
---------------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
---------------------------------------------------------------------------------------------------------
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation
...
---------------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
---------------------------------------------------------------------------------------------------------
Outputs
---------------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/hello-rust-HelloWorldFunctionRole-10II2P13AUDUY
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/
Key HelloWorldFunction
Description Hello World Lambda Function ARN
Value arn:aws:lambda:us-west-2:012345678910:function:hello-rust-HelloWorldFunction-
yk4HzGzYeZBj
---------------------------------------------------------------------------------------------------------
Successfully created/updated stack - hello-rust in us-west-2
```
Zum Testen können wir unsere Lambda-Funktion über den API-Endpunkt aufrufen.
```
$ curl https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/
Hello World!%
```
Um unsere Funktion lokal zu testen, stellen wir zunächst sicher, dass die `Architectures` Eigenschaft unserer Funktion mit unserem lokalen Computer übereinstimmt.
```
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
Metadata:
BuildMethod: rust-cargolambda # More info about Cargo Lambda: https://github.com/cargo-lambda/cargo-lambda
Properties:
CodeUri: ./rust_app # Points to dir of Cargo.toml
Handler: bootstrap # Do not change, as this is the default executable name produced by Cargo Lambda
Runtime: provided.al2
Architectures:
- arm64
...
```
Da wir `arm64` in diesem Beispiel unsere Architektur von `x86_64` bis geändert haben, führen `sam build` wir die Aktualisierung unserer Build-Artefakte durch. Anschließend starten wir`sam local invoke`, um unsere Funktion lokal aufzurufen.
```
hello-rust$ sam local invoke
Invoking bootstrap (provided.al2)
Local image was not found.
Removing rapid images for repo public.ecr.aws/sam/emulation-provided.al2
Building image.....................................................................................................................................
Using local image: public.ecr.aws/lambda/provided:al2-rapid-arm64.
Mounting /Users/.../hello-rust/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container
START RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 Version: $LATEST
{"statusCode":200,"body":"Hello World!"}END RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6
REPORT RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 Init Duration: 0.68 ms Duration: 130.63 ms Billed Duration: 131 ms Memory Size: 128 MB Max Memory Used: 128 MB
```
### Projekt mit einer einzigen Lambda-Funktion
**Hier ist ein Beispiel für eine serverlose Anwendung, die eine Rust-Lambda-Funktion enthält.**
Struktur des Projektverzeichnisses:
```
.
├── Cargo.lock
├── Cargo.toml
├── src
│ └── main.rs
└── template.yaml
```
AWS SAM Vorlage:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
...
```
### Projekt mit mehreren Lambda-Funktionen
**Hier ist ein Beispiel für eine serverlose Anwendung, die mehrere Rust-Lambda-Funktionen enthält.**
Struktur des Projektverzeichnisses:
```
.
├── Cargo.lock
├── Cargo.toml
├── src
│ ├── function_a.rs
│ └── function_b.rs
└── template.yaml
```
AWS SAM Vorlage:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
FunctionA:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties:
Binary: function_a
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
FunctionB:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties:
Binary: function_b
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
```
`Cargo.toml`-Datei:
```
[package]
name = "test-handler"
version = "0.1.0"
edition = "2021"
[dependencies]
lambda_runtime = "0.6.0"
serde = "1.0.136"
tokio = { version = "1", features = ["macros"] }
tracing = { version = "0.1", features = ["log"] }
tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] }
[[bin]]
name = "function_a"
path = "src/function_a.rs"
[[bin]]
name = "function_b"
path = "src/function_b.rs"
```
# Python-Lambda-Funktionen mit uv in erstellen AWS SAM
| |
| --- |
| Diese Funktion befindet sich in der Vorschauversion für AWS SAM und kann sich ändern. |
Verwenden Sie die AWS Serverless Application Model Befehlszeilenschnittstelle (AWS SAMCLI) mituv, einem schnellen Installationsprogramm und Resolver für Python-Pakete, um Ihre AWS Lambda Python-Funktionen zu erstellen.
**Topics**
+ [Voraussetzungen](#building-python-uv-prerequisites)
+ [Konfiguration AWS SAM für die Verwendung mit Python-Lambda-Funktionen und uv](#building-python-uv-configure)
+ [Beispiele](#building-python-uv-examples)
## Voraussetzungen
**Python**
Informationen zur Installation von Python finden [Sie unter Python herunterladen](https://www.python.org/downloads/) auf der *Python-Website*.
**uv**
Das AWS SAMCLI erfordert die Installation von [https://docs.astral.sh/uv/](https://docs.astral.sh/uv/), einem extrem schnellen Python-Paket-Installer und Resolver. Installationsanweisungen finden Sie in der *uvDokumentation* unter [Installation](https://docs.astral.sh/uv/getting-started/installation/).
**Melden Sie sich für die AWS SAMCLI Beta-Funktion an**
Da es sich bei dieser Funktion um eine Vorschauversion handelt, müssen Sie sich mit einer der folgenden Methoden anmelden:
1. Verwenden Sie die Umgebungsvariable:`SAM_CLI_BETA_PYTHON_UV=1`.
1. Fügen Sie der `samconfig.toml`-Datei Folgendes hinzu:
```
[default.build.parameters]
beta_features = true
[default.sync.parameters]
beta_features = true
```
1. Verwenden Sie die `--beta-features` Option, wenn Sie einen unterstützten AWS SAMCLI Befehl verwenden. Beispiel:
```
$ sam build --beta-features
```
1. Wählen Sie die Option`y`, wenn Sie AWS SAMCLI aufgefordert werden, sich anzumelden. Im Folgenden wird ein Beispiel gezeigt:
```
$ sam build
Starting Build use cache
Build method "python-uv" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
```
## Konfiguration AWS SAM für die Verwendung mit Python-Lambda-Funktionen und uv
### Schritt 1: Konfiguriere deine AWS SAM Vorlage
Konfigurieren Sie Ihre AWS SAM Vorlage wie folgt:
+ **BuildMethod** – `python-uv`.
+ **CodeUri**— Pfad zu Ihrem Funktionscode-Verzeichnis, das `pyproject.toml` oder enthält`requirements.txt`.
+ **Handler** — Ihr Funktionshandler (z. B.`app.lambda_handler`).
+ **Runtime** — Python-Laufzeitversion (z. B.`python3.12`).
Hier ist ein Beispiel für eine konfigurierte AWS SAM Vorlage:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./my_function
Handler: app.lambda_handler
Runtime: python3.12
Metadata:
BuildMethod: python-uv
...
```
## Beispiele
### Beispiel Hello World
**In diesem Beispiel erstellen wir eine Hello World-Beispielanwendung mit Python uv als Paketmanager.**
uvkann entweder `pyproject.toml` oder verwenden`requirements.txt`, um Abhängigkeiten zu lesen. Wenn beide angegeben sind, `sam build` wird aus `requirements.txt` den Abhängigkeiten gelesen.
Das Folgende ist die Struktur unserer Hello World-Anwendung:
```
hello-python-uv
├── README.md
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── pyproject.toml
├── samconfig.toml
└── template.yaml
```
`pyproject.toml`-Datei:
```
[project]
name = "my-function"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = [
"requests>=2.31.0",
"boto3>=1.28.0",
]
```
In unserer AWS SAM Vorlage ist unsere Python-Funktion wie folgt definiert:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.12
Architectures:
- x86_64
Metadata:
BuildMethod: python-uv
```
Als Nächstes erstellen wir `sam build` unsere Anwendung und bereiten sie auf die Bereitstellung vor. Das AWS SAMCLI erstellt ein `.aws-sam` Verzeichnis und organisiert dort unsere Build-Artefakte. Unsere Funktionsabhängigkeiten werden unter installiert uv und gespeichert. `.aws-sam/build/HelloWorldFunction/`
```
hello-python-uv$ sam build
Starting Build use cache
Build method "python-uv" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
Experimental features are enabled for this session.
Visit the docs page to learn more about the AWS Beta terms https://aws.amazon.com/service-terms/.
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../hello-python-uv/hello_world runtime: python3.12 metadata: {'BuildMethod': 'python-uv'} architecture: x86_64 functions: HelloWorldFunction
Running PythonUvBuilder:UvBuild
Running PythonUvBuilder:CopySource
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
**Anmerkung**
Die `python-uv` Build-Methode wird pro Funktion im `Metadata` Abschnitt konfiguriert. Jede Funktion in Ihrer Vorlage kann eine andere Build-Methode verwenden, sodass Sie uv basierte Funktionen mit `pip` basierten Funktionen in derselben AWS SAM Vorlage kombinieren können. Wenn keine Build-Methode angegeben `pip` ist, wird standardmäßig verwendet.
# Erstellen von Lambda-Funktionen mit benutzerdefinierten Laufzeiten in AWS SAM
Sie können den `sam build` Befehl verwenden, um benutzerdefinierte Laufzeiten zu erstellen, die für Ihre Lambda-Funktion erforderlich sind. Sie deklarieren Ihre Lambda-Funktion so, dass sie eine benutzerdefinierte Laufzeit verwendet, indem Sie `Runtime: provided` für die Funktion angeben.
Um eine benutzerdefinierte Laufzeit zu erstellen, deklarieren Sie das `Metadata` Ressourcenattribut mit einem `BuildMethod: makefile` Eintrag. Sie stellen ein benutzerdefiniertes Makefile bereit, in dem Sie ein Build-Ziel in der Form deklarieren`build-function-logical-id`, das die Build-Befehle für Ihre Laufzeit enthält. Ihr Makefile ist dafür verantwortlich, falls erforderlich, die benutzerdefinierte Runtime zu kompilieren und die Build-Artefakte an den richtigen Ort zu kopieren, der für nachfolgende Schritte in Ihrem Workflow erforderlich ist. Der Speicherort des Makefiles wird durch die `CodeUri` Eigenschaft der Funktionsressource angegeben und muss benannt werden. `Makefile`
## Beispiele
### Beispiel 1: Benutzerdefinierte Laufzeit für eine in Rust geschriebene Funktion
**Anmerkung**
Wir empfehlen, Lambda-Funktionen mit Cargo Lambda zu erstellen. Weitere Informationen hierzu finden Sie unter [Erstellen von Rust Lambda-Funktionen mit Cargo Lambda in AWS SAM](building-rust.md).
Die folgende AWS SAM Vorlage deklariert eine Funktion, die eine benutzerdefinierte Laufzeit für eine in Rust geschriebene Lambda-Funktion verwendet, und weist `sam build` an, die Befehle für das `build-HelloRustFunction` Build-Ziel auszuführen.
```
Resources:
HelloRustFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: HelloRust
Handler: bootstrap.is.real.handler
Runtime: provided
MemorySize: 512
CodeUri: .
Metadata:
BuildMethod: makefile
```
Das folgende Makefile enthält das Build-Ziel und die Befehle, die ausgeführt werden. Beachten Sie, dass die `CodeUri` Eigenschaft auf gesetzt ist`.`, sodass sich das Makefile im Stammverzeichnis des Projekts befinden muss (d. h. im selben Verzeichnis wie die AWS SAM Vorlagendatei der Anwendung). Der Dateiname muss sein. `Makefile`
```
build-HelloRustFunction:
cargo build --release --target x86_64-unknown-linux-musl
cp ./target/x86_64-unknown-linux-musl/release/bootstrap $(ARTIFACTS_DIR)
```
Weitere Informationen zum Einrichten Ihrer Entwicklungsumgebung zur Ausführung des `cargo build` Befehls aus dem vorherigen `makefile` Abschnitt finden Sie im AWS Lambda Blogbeitrag [Rust Runtime for](https://aws.amazon.com/blogs/opensource/rust-runtime-for-aws-lambda/).
### Beispiel 2: Makefile-Builder für Python 3.12 (Alternative zur Verwendung des mitgelieferten Builders)
Möglicherweise möchten Sie eine Bibliothek oder ein Modul verwenden, das nicht in einem gebündelten Builder enthalten ist. Dieses Beispiel zeigt eine AWS SAM Vorlage für eine Python3.12-Laufzeit mit einem Makefile-Builder.
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.12
Metadata:
BuildMethod: makefile
```
Das folgende Makefile enthält das Build-Ziel und die Befehle, die ausgeführt werden. Beachten Sie, dass die `CodeUri` Eigenschaft auf `hello_world` gesetzt ist. Das Makefile muss sich also im Stammverzeichnis des `hello_world` Unterverzeichnisses befinden, und der Dateiname muss sein. `Makefile`
```
build-HelloWorldFunction:
cp *.py $(ARTIFACTS_DIR)
cp requirements.txt $(ARTIFACTS_DIR)
python -m pip install -r requirements.txt -t $(ARTIFACTS_DIR)
rm -rf $(ARTIFACTS_DIR)/bin
```
# Aufbau von Lambda-Schichten in AWS SAM
Sie können sie verwenden AWS SAM , um benutzerdefinierte Lambda-Schichten zu erstellen. Mit Lambda-Schichten können Sie Code aus einer Lambda-Funktion extrahieren, der dann für mehrere Lambda-Funktionen wiederverwendet werden kann. Wenn Sie nur Lambda-Schichten erstellen (anstatt Ihre gesamte Anwendung zu erstellen), können Sie in mehrfacher Hinsicht davon profitieren. Es kann Ihnen helfen, die Größe Ihrer Bereitstellungspakete zu reduzieren, die Logik der Kernfunktionen von Abhängigkeiten zu trennen und Abhängigkeiten für mehrere Funktionen gemeinsam zu nutzen. Informationen zu Layern finden Sie unter [AWS Lambda-Schichten](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) im *AWS Lambda Developer Guide*.
## So erstellen Sie eine Lambda-Schicht in AWS SAM
**Anmerkung**
Bevor Sie eine Lambda-Schicht erstellen können, müssen Sie zunächst eine Lambda-Schicht in Ihre AWS SAM Vorlage schreiben. Informationen und Beispiele dazu finden Sie unter. [Steigern Sie die Effizienz mithilfe von Lambda-Schichten mit AWS SAM](serverless-sam-cli-layers.md)
Um eine benutzerdefinierte Ebene zu erstellen, deklarieren Sie sie in Ihrer Vorlagendatei AWS Serverless Application Model (AWS SAM) und fügen Sie einen Abschnitt mit einem `Metadata` Ressourcenattribut mit einem `BuildMethod` Eintrag hinzu. Gültige Werte für `BuildMethod` sind Bezeichner für eine [AWS Lambda Laufzeit](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html) oder`makefile`. Fügen Sie einen `BuildArchitecture` Eintrag hinzu, um die Befehlssatzarchitekturen anzugeben, die Ihr Layer unterstützt. Gültige Werte für `BuildArchitecture` sind [Lambda-Befehlssatzarchitekturen](https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html).
Wenn Sie angeben`makefile`, geben Sie das benutzerdefinierte Makefile an, in dem Sie ein Build-Ziel in der Form deklarieren`build-layer-logical-id`, das die Build-Befehle für Ihre Ebene enthält. Ihr Makefile ist dafür verantwortlich, die Ebene bei Bedarf zu kompilieren und die Build-Artefakte an den richtigen Ort zu kopieren, der für nachfolgende Schritte in Ihrem Workflow erforderlich ist. Der Speicherort des Makefiles wird durch die `ContentUri` Eigenschaft der Layer-Ressource angegeben und muss benannt werden. `Makefile`
**Anmerkung**
Wann Sie eine benutzerdefinierte Ebene erstellen, AWS Lambda hängt von Umgebungsvariablen ab, um Ihren Layer-Code zu finden. Lambda-Laufzeiten enthalten Pfade in dem `/opt` Verzeichnis, in das Ihr Layer-Code kopiert wird. Die Ordnerstruktur für Build-Artefakte Ihres Projekts muss mit der erwarteten Ordnerstruktur der Laufzeit übereinstimmen, damit Ihr benutzerdefinierter Layer-Code gefunden werden kann.
Für Python können Sie beispielsweise Ihren Code im `python/` Unterverzeichnis platzieren. Für NodeJS können Sie Ihren Code im Unterverzeichnis platzieren. `nodejs/node_modules/`
*Weitere Informationen finden Sie im Entwicklerhandbuch unter [Einbeziehen von Bibliotheksabhängigkeiten in eine Ebene](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html#configuration-layers-path).AWS Lambda *
Im Folgenden finden Sie ein Beispiel für einen Abschnitt mit `Metadata` Ressourcenattributen.
```
Metadata:
BuildMethod: python3.12
BuildArchitecture: arm64
```
**Anmerkung**
Wenn Sie den Abschnitt mit den `Metadata` Ressourcenattributen nicht einbeziehen, AWS SAM wird der Layer nicht erstellt. Stattdessen werden die Build-Artefakte von dem Speicherort kopiert, der in der `CodeUri` Eigenschaft der Layer-Ressource angegeben ist. Weitere Informationen finden Sie unter der [ContentUri](sam-resource-layerversion.md#sam-layerversion-contenturi)Eigenschaft des `AWS::Serverless::LayerVersion` Ressourcentyps.
Wenn Sie den Abschnitt mit den `Metadata` Ressourcenattributen einbeziehen, können Sie den `sam build` Befehl verwenden, um den Layer sowohl als eigenständiges Objekt als auch als Abhängigkeit von einer AWS Lambda Funktion zu erstellen.
+ ****Als unabhängiges Objekt.**** Möglicherweise möchten Sie nur das Layer-Objekt erstellen, wenn Sie beispielsweise lokal eine Codeänderung an der Ebene testen und nicht Ihre gesamte Anwendung erstellen müssen. Um die Ebene unabhängig zu erstellen, geben Sie die Layer-Ressource mit dem `sam build layer-logical-id` Befehl an.
+ **Als Abhängigkeit einer Lambda-Funktion.** Wenn Sie die logische ID einer Ebene in die `Layers` Eigenschaft einer Lambda-Funktion in derselben AWS SAM Vorlagendatei aufnehmen, ist die Ebene eine Abhängigkeit von dieser Lambda-Funktion. Wenn diese Ebene auch einen Abschnitt mit einem `Metadata` Ressourcenattribut mit einem `BuildMethod` Eintrag enthält, erstellen Sie die Ebene, indem Sie entweder die gesamte Anwendung mit dem `sam build` Befehl erstellen oder indem Sie die Funktionsressource mit dem `sam build function-logical-id` Befehl angeben.
## Beispiele
### Vorlagenbeispiel 1: Erstellen Sie eine Ebene für die Python 3.12-Laufzeitumgebung
Die folgende AWS SAM Beispielvorlage erstellt eine Ebene für die Python 3.12-Laufzeitumgebung.
```
Resources:
MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
ContentUri: my_layer
CompatibleRuntimes:
- python3.12
Metadata:
BuildMethod: python3.12 # Required to have AWS SAM build this layer
```
### Vorlagenbeispiel 2: Erstellen Sie eine Ebene mit einem benutzerdefinierten Makefile
Die folgende AWS SAM Beispielvorlage verwendet eine benutzerdefinierte Vorlage`makefile`, um die Ebene zu erstellen.
```
Resources:
MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
ContentUri: my_layer
CompatibleRuntimes:
- python3.12
Metadata:
BuildMethod: makefile
```
Das Folgende `makefile` enthält das Build-Ziel und die Befehle, die ausgeführt werden. Beachten Sie, dass die `ContentUri` Eigenschaft auf `my_layer` gesetzt ist. Das Makefile muss sich also im Stammverzeichnis des `my_layer` Unterverzeichnisses befinden, und der Dateiname muss sein. `Makefile` Beachten Sie auch, dass die Build-Artefakte in das `python/` Unterverzeichnis kopiert AWS Lambda werden, damit der Layer-Code gefunden werden kann.
```
build-MyLayer:
mkdir -p "$(ARTIFACTS_DIR)/python"
cp *.py "$(ARTIFACTS_DIR)/python"
python -m pip install -r requirements.txt -t "$(ARTIFACTS_DIR)/python"
```
**Anmerkung**
Wenn der aufgerufen `makefile` wird, wird das entsprechende Ziel ausgelöst und die Artefakte sollten in die exponierte Umgebungsvariable `$ARTIFACTS_DIR` kopiert werden. Weitere Informationen finden Sie [aws-lambda-builders unter GitHub](https://github.com/aws/aws-lambda-builders/blob/develop/aws_lambda_builders/workflows/custom_make/DESIGN.md).
### Beispiel für Sam Build-Befehle
Mit den folgenden `sam build` Befehlen werden Ebenen erstellt, die die Abschnitte mit den `Metadata` Ressourcenattributen enthalten.
```
# Build the 'layer-logical-id' resource independently
$ sam build layer-logical-id
# Build the 'function-logical-id' resource and layers that this function depends on
$ sam build function-logical-id
# Build the entire application, including the layers that any function depends on
$ sam build
```