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.
# Entwickeln Sie Ihre serverlose Anwendung mit AWS SAM
Dieser Abschnitt enthält Themen zur Validierung Ihrer AWS SAM Vorlage und zum Erstellen Ihrer Anwendung mit Abhängigkeiten. Es enthält auch Themen AWS SAM zur Verwendung für bestimmte Anwendungsfälle, z. B. die Arbeit mit Lambda-Schichten, die Verwendung verschachtelter Anwendungen, die Steuerung des Zugriffs auf API Gateway APIs, die Orchestrierung von AWS Ressourcen mit Step Functions und die Codesignatur Ihrer Anwendungen. Die drei wichtigsten Meilensteine, die Sie für die Entwicklung Ihrer Anwendung erreichen müssen, sind unten aufgeführt.
**Topics**
+ [Erstellen Sie Ihre Bewerbung in AWS SAM](using-sam-cli-init.md)
+ [Definieren Sie Ihre Infrastruktur mit AWS SAM](serverless-authoring.md)
+ [Erstellen Sie Ihre Anwendung mit AWS SAM](serverless-building.md)
# Erstellen Sie Ihre Bewerbung in AWS SAM
Nachdem Sie die Lektüre „[Erste Schritte](serverless-getting-started.md)“ abgeschlossen haben[Wie benutzt man AWS Serverless Application Model (AWS SAM)](chapter-using-sam.md), sind Sie bereit, ein AWS SAM Projekt in Ihrer Entwicklerumgebung zu erstellen. Ihr AWS SAM Projekt dient als Ausgangspunkt für das Schreiben Ihrer serverlosen Anwendung. Eine Liste der AWS SAMCLI `sam init` Befehlsoptionen finden Sie unter[sam init](sam-cli-command-reference-sam-init.md).
Der AWS Serverless Application Model Befehl Command Line Interface (AWS SAMCLI) bietet Optionen zur Initialisierung einer neuen serverlosen Anwendung, die aus `sam init` folgenden Komponenten besteht:
+ Eine AWS SAM Vorlage zur Definition Ihres Infrastrukturcodes.
+ Eine Ordnerstruktur, die Ihre Anwendung organisiert.
+ Konfiguration für Ihre AWS Lambda Funktionen.
Informationen zum Erstellen eines AWS SAM Projekts finden Sie in den Themen in diesen Abschnitten.
**Anmerkung**
`sam init`enthält Projektvorlagen für dauerhafte Funktionen in unterstützten Laufzeiten (TypeScript, Python, Java). Diese Vorlagen bieten Startcode und Konfiguration für die Erstellung von statusbehafteten serverlosen Anwendungen.
**Topics**
+ [Initialisieren Sie eine neue serverlose Anwendung](#using-sam-cli-init-new)
+ [Optionen für Sam Init](#using-sam-cli-init-options)
+ [Fehlerbehebung](#using-sam-cli-init-troubleshooting)
+ [Beispiele](#using-sam-cli-init-examples)
+ [Weitere Informationen](#using-sam-cli-init-learn)
+ [Nächste Schritte](#w2aac18c11c39)
## Initialisieren Sie eine neue serverlose Anwendung
**Um eine neue serverlose Anwendung mit dem zu initialisieren AWS SAMCLI**
1. `cd`in ein Startverzeichnis.
1. Führen Sie in der Befehlszeile Folgendes aus:
```
$ sam init
```
1. Der AWS SAMCLI führt Sie durch einen interaktiven Ablauf zur Erstellung einer neuen serverlosen Anwendung.
**Anmerkung**
Wie unter beschrieben[Tutorial: Stellen Sie eine Hello World-Anwendung bereit mit AWS SAM](serverless-getting-started-hello-world.md), initialisiert dieser Befehl Ihre serverlose Anwendung und erstellt Ihr Projektverzeichnis. Dieses Verzeichnis wird mehrere Dateien und Ordner enthalten. Die wichtigste Datei ist`template.yaml`. Das ist deine AWS SAM Vorlage. Ihre Version von Python muss mit der Version von Python übereinstimmen, die in der `template.yaml` Datei aufgeführt ist, die der **sam init** Befehl erstellt hat.
### Wählen Sie eine Startvorlage
Eine *Vorlage* besteht aus den folgenden Komponenten:
1. Eine AWS SAM Vorlage für Ihren Infrastrukturcode.
1. Ein Startprojektverzeichnis, das Ihre Projektdateien organisiert. Dies kann beispielsweise Folgendes beinhalten:
1. Eine Struktur für Ihren Lambda-Funktionscode und seine Abhängigkeiten.
1. Ein `events` Ordner, der Testereignisse für lokale Tests enthält.
1. Ein `tests` Ordner zur Unterstützung von Komponententests.
1. Eine `samconfig.toml` Datei zur Konfiguration der Projekteinstellungen.
1. Eine `ReadMe` Datei und andere grundlegende Startprojektdateien.
Im Folgenden finden Sie ein Beispiel für ein Startprojektverzeichnis:
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
├── integration
│ ├── __init__.py
│ └── test_api_gateway.py
├── requirements.txt
└── unit
├── __init__.py
└── test_handler.py
```
Sie können aus einer Liste verfügbarer *AWS Schnellstartvorlagen* auswählen oder Ihren eigenen *Speicherort für benutzerdefinierte Vorlagen* angeben.
**Um eine AWS Schnellstart-Vorlage auszuwählen**
1. Wenn Sie dazu aufgefordert werden, wählen Sie **AWS Schnellstartvorlagen** aus.
1. Wählen Sie zunächst eine AWS Schnellstart-Vorlage aus. Im Folgenden wird ein Beispiel gezeigt:
```
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: 4
```
**Um Ihren eigenen Speicherort für benutzerdefinierte Vorlagen auszuwählen**
1. Wenn Sie dazu aufgefordert werden, wählen Sie den **Speicherort für benutzerdefinierte Vorlagen** aus.
```
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 2
```
1. Sie AWS SAMCLI werden aufgefordert, einen Speicherort für die Vorlage anzugeben.
```
Template location (git, mercurial, http(s), zip, path):
```
Geben Sie einen der folgenden Speicherorte für Ihr ZIP-Vorlagenarchiv an:
+ **GitHubRepository** — Der Pfad zur .zip-Datei in Ihrem GitHub Repository. Die Datei muss sich im Stammverzeichnis Ihres Repositorys befinden.
+ **MercurialRepository** — Der Pfad zur .zip-Datei in Ihrem Mercurial Repository. Die Datei muss sich im Stammverzeichnis Ihres Repositorys befinden.
+ **.zip-Pfad** — Ein HTTPS-Pfad oder ein lokaler Pfad zu Ihrer .zip-Datei.
1. Dadurch AWS SAMCLI wird Ihre serverlose Anwendung mithilfe Ihrer benutzerdefinierten Vorlage initialisiert.
### Wählen Sie eine Laufzeit
Wenn Sie eine *AWS Schnellstartvorlage* auswählen, werden Sie AWS SAMCLI aufgefordert, eine Laufzeit für Ihre Lambda-Funktionen auszuwählen. Die von der angezeigte Liste der Optionen entspricht den AWS SAMCLI Laufzeiten, die von Lambda nativ unterstützt werden.
+ Die [Laufzeit](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-runtime) stellt eine sprachspezifische Umgebung bereit, die in der Ausführungsumgebung ausgeführt wird.
+ Bei der Bereitstellung auf dem AWS Cloud ruft der Lambda-Service Ihre Funktion in einer [Ausführungsumgebung](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtime-environment.html) auf.
Sie können jede andere Programmiersprache mit einer benutzerdefinierten Laufzeit verwenden. Dazu müssen Sie Ihre Startanwendungsstruktur manuell erstellen. Anschließend können Sie Ihre Anwendung `sam init` schnell initialisieren, indem Sie einen benutzerdefinierten Speicherort für Vorlagen konfigurieren.
Aus Ihrer Auswahl AWS SAMCLI erstellt der das Startverzeichnis für Ihren Lambda-Funktionscode und die Abhängigkeiten.
Wenn Lambda mehrere Abhängigkeitsmanager für Ihre Laufzeit unterstützt, werden Sie aufgefordert, Ihren bevorzugten Abhängigkeitsmanager auszuwählen.
### Wählen Sie einen Pakettyp
Wenn Sie eine *AWS Schnellstartvorlage* und eine *Runtime* auswählen, werden Sie AWS SAMCLI aufgefordert, einen *Pakettyp* auszuwählen. Der Pakettyp bestimmt, wie Ihre Lambda-Funktionen für die Verwendung mit dem Lambda-Service bereitgestellt werden. Die beiden unterstützten Pakettypen sind:
1. **Container-Image** — Enthält das Basisbetriebssystem, die Laufzeit, Lambda-Erweiterungen, Ihren Anwendungscode und dessen Abhängigkeiten.
1. **ZIP-Dateiarchiv** — Enthält Ihren Anwendungscode und seine Abhängigkeiten.
Weitere Informationen zu Bereitstellungspakettypen finden Sie unter [Lambda-Bereitstellungspakete](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) im *AWS Lambda Entwicklerhandbuch*.
Im Folgenden finden Sie ein Beispiel für die Verzeichnisstruktur einer Anwendung mit einer Lambda-Funktion, die als Container-Image verpackt ist. Das AWS SAMCLI lädt das Bild herunter und erstellt `Dockerfile` im Verzeichnis der Funktion ein, um das Bild zu spezifizieren.
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── Dockerfile
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
└── unit
├── __init__.py
└── test_handler.py
```
Im Folgenden finden Sie ein Beispiel für die Verzeichnisstruktur einer Anwendung mit einer Funktion, die als ZIP-Dateiarchiv verpackt ist.
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
├── integration
│ ├── __init__.py
│ └── test_api_gateway.py
├── requirements.txt
└── unit
├── __init__.py
└── test_handler.py
```
### Konfigurieren Sie die Ablaufverfolgung AWS X-Ray
Sie können wählen, ob Sie die AWS X-Ray Ablaufverfolgung aktivieren möchten. Weitere Informationen finden Sie unter [Was ist AWS X-Ray?](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html) im *AWS X-Ray Entwicklerhandbuch*.
Wenn Sie es aktivieren, AWS SAMCLI konfiguriert das Ihre AWS SAM Vorlage. Im Folgenden wird ein Beispiel gezeigt:
```
Globals:
Function:
...
Tracing: Active
Api:
TracingEnabled: True
```
### Konfigurieren Sie die Überwachung mit Amazon CloudWatch Application Insights
Sie können wählen, ob Sie die Überwachung mit Amazon CloudWatch Application Insights aktivieren möchten. Weitere Informationen finden Sie unter [Amazon CloudWatch Application Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html) im * CloudWatch Amazon-Benutzerhandbuch*.
Wenn Sie aktivieren, AWS SAMCLI konfiguriert der Ihre AWS SAM Vorlage. Im Folgenden wird ein Beispiel gezeigt:
```
Resources:
ApplicationResourceGroup:
Type: AWS::ResourceGroups::Group
Properties:
Name:
Fn::Join:
- ''
- - ApplicationInsights-SAM-
- Ref: AWS::StackName
ResourceQuery:
Type: CLOUDFORMATION_STACK_1_0
ApplicationInsightsMonitoring:
Type: AWS::ApplicationInsights::Application
Properties:
ResourceGroupName:
Fn::Join:
- ''
- - ApplicationInsights-SAM-
- Ref: AWS::StackName
AutoConfigurationEnabled: 'true'
DependsOn: ApplicationResourceGroup
```
### Benennen Sie Ihre Anwendung
Geben Sie einen Namen für Ihre Anwendung ein. Der AWS SAMCLI erstellt unter diesem Namen einen Ordner auf oberster Ebene für Ihre Anwendung.
## Optionen für Sam Init
Im Folgenden sind einige der wichtigsten Optionen aufgeführt, die Sie mit dem `sam init` Befehl verwenden können. Eine Liste aller Optionen finden Sie unter[sam init](sam-cli-command-reference-sam-init.md).
### Initialisieren Sie eine Anwendung mithilfe eines benutzerdefinierten Vorlagenspeicherorts
Verwenden Sie die `--location` Option und geben Sie einen unterstützten Speicherort für benutzerdefinierte Vorlagen an. Im Folgenden wird ein Beispiel gezeigt:
```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```
### Initialisieren Sie eine Anwendung ohne den interaktiven Ablauf
Verwenden Sie die `--no-interactive` Option und geben Sie Ihre Konfigurationsoptionen in der Befehlszeile an, um den interaktiven Ablauf zu überspringen. Im Folgenden wird ein Beispiel gezeigt:
```
$ sam init --no-interactive --runtime go1.x --name go-demo --dependency-manager mod --app-template hello-world
```
## Fehlerbehebung
Informationen zur Behebung von Problemen finden Sie unter[AWS SAMCLIProblembehandlung](sam-cli-troubleshooting.md). AWS SAMCLI
## Beispiele
### Initialisieren Sie eine neue serverlose Anwendung mithilfe der Hello World AWS Starter-Vorlage
Dieses Beispiel finden Sie [Schritt 1: Initialisieren Sie die Hello World-Beispielanwendung](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-init) im *Tutorial: Bereitstellen einer Hello World-Anwendung*.
### Initialisieren Sie eine neue serverlose Anwendung mit einem benutzerdefinierten Speicherort für Vorlagen
Im Folgenden finden Sie Beispiele für die Bereitstellung eines GitHub Speicherorts für Ihre benutzerdefinierte Vorlage:
```
$ sam init --location gh:aws-samples/cookiecutter-aws-sam-python
$ sam init --location git+sh://git@github.com/aws-samples/cookiecutter-aws-sam-python.git
$ sam init --location hg+ssh://hg@bitbucket.org/repo/template-name
```
Im Folgenden finden Sie ein Beispiel für einen lokalen Dateipfad:
```
$ sam init --location /path/to/template.zip
```
Im Folgenden finden Sie ein Beispiel für einen Pfad, der über HTTPS erreichbar ist:
```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```
## Weitere Informationen
Weitere Informationen zur Verwendung des `sam init` Befehls finden Sie in den folgenden Abschnitten:
+ **[Lernen AWS SAM: sam init](https://www.youtube.com/watch?v=9m3R-leD5Xo)** — Reihe Serverless Land „Lernen AWS SAM“ amYouTube.
+ **[Strukturierung serverloser Anwendungen für die Verwendung mit den AWS SAMCLI (Sessions with SAM S2E7)](https://www.youtube.com/watch?v=k9IRdgze9fQ)** — Sessions mit der Serie On. AWS SAM YouTube
## Nächste Schritte
Nachdem Sie Ihr AWS SAM Projekt erstellt haben, können Sie mit der Erstellung Ihrer Anwendung beginnen. [Definieren Sie Ihre Infrastruktur mit AWS SAM](serverless-authoring.md)Ausführliche Anweisungen zu den Aufgaben, die Sie dazu erledigen müssen, finden Sie unter.
# Definieren Sie Ihre Infrastruktur mit AWS SAM
Nachdem Sie Ihr Projekt erstellt haben, sind Sie bereit, Ihre Anwendungsinfrastruktur mit zu definieren AWS SAM. Konfigurieren Sie dazu Ihre AWS SAM Vorlage so, dass sie die Ressourcen und Eigenschaften Ihrer Anwendung definiert. Dabei handelt es sich um die `template.yaml` Datei in Ihrem AWS SAM Projekt.
Die Themen in diesem Abschnitt enthalten Inhalte zur Definition Ihrer Infrastruktur in Ihrer AWS SAM Vorlage (Ihrer `template.yaml` Datei). Es enthält auch Themen zur Definition von Ressourcen für bestimmte Anwendungsfälle, z. B. zur Arbeit mit Lambda-Layern, zur Verwendung verschachtelter Anwendungen, zur Steuerung des Zugriffs auf API Gateway APIs, zur Orchestrierung von AWS Ressourcen mit Step Functions, zur Codesignatur Ihrer Anwendungen und zur Validierung Ihrer Vorlage. AWS SAM
**Topics**
+ [Definieren Sie Anwendungsressourcen in Ihrer AWS SAM Vorlage](authoring-define-resources.md)
+ [Richten Sie den Ressourcenzugriff in Ihrer AWS SAM Vorlage ein und verwalten Sie ihn](sam-permissions.md)
+ [Kontrollieren Sie den API-Zugriff mit Ihrer AWS SAM Vorlage](serverless-controlling-access-to-apis.md)
+ [Steigern Sie die Effizienz mithilfe von Lambda-Schichten mit AWS SAM](serverless-sam-cli-layers.md)
+ [Verwenden Sie Code und Ressourcen mithilfe verschachtelter Anwendungen in AWS SAM](serverless-sam-template-nested-applications.md)
+ [Verwalten Sie zeitbasierte Ereignisse mit dem EventBridge Scheduler in AWS SAM](using-eventbridge-scheduler.md)
+ [Orchestrierung von AWS SAM Ressourcen mit AWS Step Functions](serverless-step-functions-in-sam.md)
+ [Richten Sie die Codesignatur für Ihre AWS SAM Anwendung ein](authoring-codesigning.md)
+ [AWS SAM Vorlagendateien validieren](serverless-sam-cli-using-validate.md)
# Definieren Sie Anwendungsressourcen in Ihrer AWS SAM Vorlage
Sie definieren die AWS Ressourcen, die Ihre serverlose Anwendung verwendet, im `Resources` Abschnitt Ihrer AWS SAM Vorlage. Wenn Sie eine Ressource definieren, legen Sie fest, was die Ressource ist, wie sie mit anderen Ressourcen interagiert und wie auf sie zugegriffen werden kann (d. h. die Berechtigungen der Ressource).
Der `Resources` Abschnitt Ihrer AWS SAM Vorlage kann eine Kombination aus CloudFormation Ressourcen und AWS SAM Ressourcen enthalten. Darüber hinaus können Sie die Kurzsyntax für die folgenden Ressourcen verwenden AWS SAM:
| AWS SAM kurze Syntax | Was macht es mit einer verwandten Ressource AWS |
| --- | --- |
| [AWS::Serverless::Api](sam-resource-api.md) | Erstellt eine Sammlung von API-Gateway-Ressourcen und -Methoden, die über HTTPS-Endpunkte aufgerufen werden können. |
| [AWS::Serverless::Application](sam-resource-application.md) | Bettet eine serverlose Anwendung aus dem [AWS Serverless Application Repository](https://serverlessrepo.aws.amazon.com/applications)oder aus einem Amazon S3 S3-Bucket als verschachtelte Anwendung ein. |
| [AWS::Serverless::Connector](sam-resource-connector.md) | Konfiguriert Berechtigungen zwischen zwei Ressourcen. Eine Einführung in Konnektoren finden Sie unter[Verwaltung von Ressourcenberechtigungen mit AWS SAM Konnektoren](managing-permissions-connectors.md). |
| [AWS::Serverless::Function](sam-resource-function.md) | Erstellt eine AWS Lambda Funktion, eine AWS Identity and Access Management (IAM-) Ausführungsrolle und Zuordnungen von Ereignisquellen, die die Funktion auslösen. |
| [AWS::Serverless::GraphQLApi](sam-resource-graphqlapi.md) | erstellt und konfiguriert eine AWS AppSync GraphQL API für Ihre serverlose Anwendung. |
| [AWS::Serverless::HttpApi](sam-resource-httpapi.md) | Erstellt eine Amazon API Gateway Gateway-HTTP-API, mit der Sie RESTful APIs mit geringerer Latenz und geringeren Kosten als REST erstellen können APIs. |
| [AWS::Serverless::LayerVersion](sam-resource-layerversion.md) | Erzeugt ein Lambda LayerVersion , das Bibliotheks- oder Laufzeitcode enthält, der von einer Lambda-Funktion benötigt wird. |
| [AWS::Serverless::SimpleTable](sam-resource-simpletable.md) | Erstellt eine DynamoDB-Tabelle mit einem einzelnen Attribut-Primärschlüssel. |
| [AWS::Serverless::StateMachine](sam-resource-statemachine.md) | Erstellt eine AWS Step Functions Zustandsmaschine, mit der Sie AWS Lambda Funktionen und andere AWS Ressourcen orchestrieren können, um komplexe und robuste Workflows zu bilden. |
Die oben genannten Ressourcen sind auch unter aufgeführt[AWS SAM Ressourcen und Immobilien](sam-specification-resources-and-properties.md).
Referenzinformationen zu allen AWS Ressourcen- und Eigenschaftstypen CloudFormation sowie deren AWS SAM Unterstützung finden Sie unter [Referenz zu AWS Ressourcen- und Eigenschaftstypen](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html) im *AWS CloudFormation Benutzerhandbuch*.
# Richten Sie den Ressourcenzugriff in Ihrer AWS SAM Vorlage ein und verwalten Sie ihn
Damit Ihre AWS Ressourcen miteinander interagieren können, müssen der richtige Zugriff und die entsprechenden Berechtigungen zwischen Ihren Ressourcen konfiguriert werden. Dazu ist die Konfiguration von AWS Identity and Access Management (IAM-) Benutzern, Rollen und Richtlinien erforderlich, um Ihre Interaktion auf sichere Weise durchzuführen.
Die Themen in diesem Abschnitt beziehen sich alle auf die Einrichtung des Zugriffs auf die in Ihrer Vorlage definierten Ressourcen. Dieser Abschnitt beginnt mit allgemeinen bewährten Methoden. In den nächsten beiden Themen werden zwei Optionen behandelt, mit denen Sie Zugriff und Berechtigungen für die Ressourcen einrichten können, auf die in Ihrer serverlosen Anwendung verwiesen wird: AWS SAM Konnektoren und AWS SAM Richtlinienvorlagen. Das letzte Thema enthält Einzelheiten zur Verwaltung des Benutzerzugriffs mithilfe derselben Mechanik CloudFormation wie bei der Benutzerverwaltung.
Weitere Informationen finden Sie unter [Steuern des Zugriffs mit AWS Identity and Access Management](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) im *AWS CloudFormation Benutzerhandbuch*.
AWS Serverless Application Model (AWS SAM) bietet zwei Optionen, die die Zugriffs- und Berechtigungsverwaltung für Ihre serverlosen Anwendungen vereinfachen.
1. AWS SAM Anschlüsse
1. AWS SAM Richtlinienvorlagen
## AWS SAM Anschlüsse
Konnektoren sind eine Möglichkeit, Berechtigungen zwischen zwei Ressourcen bereitzustellen. Dazu beschreiben Sie in Ihrer AWS SAM Vorlage, wie sie miteinander interagieren sollen. Sie können entweder mit dem `Connectors` Ressourcenattribut oder dem `AWS::Serverless::Connector` Ressourcentyp definiert werden. Konnektoren unterstützen die Bereitstellung von `Read` und `Write` den Zugriff auf Daten und Ereignisse zwischen einer Kombination von AWS Ressourcen. Weitere Informationen zu AWS SAM Konnektoren finden Sie unter[Verwaltung von Ressourcenberechtigungen mit AWS SAM Konnektoren](managing-permissions-connectors.md).
## AWS SAM Richtlinienvorlagen
AWS SAM Richtlinienvorlagen sind vordefinierte Berechtigungssätze, die Sie Ihren AWS SAM Vorlagen hinzufügen können, um den Zugriff und die Berechtigungen zwischen Ihren AWS Lambda Funktionen, AWS Step Functions Zustandsmaschinen und den Ressourcen, mit denen sie interagieren, zu verwalten. Weitere Informationen zu AWS SAM Richtlinienvorlagen finden Sie unter[AWS SAM Richtlinienvorlagen](serverless-policy-templates.md).
## AWS CloudFormation Mechanismen
CloudFormation Zu den Mechanismen gehört die Konfiguration von IAM-Benutzern, -Rollen und Richtlinien zur Verwaltung von Berechtigungen zwischen Ihren AWS Ressourcen. Weitere Informationen hierzu finden Sie unter [Verwaltung von AWS SAM Berechtigungen mit CloudFormation Mechanismen](sam-permissions-cloudformation.md).
## Best Practices
In Ihren serverlosen Anwendungen können Sie mehrere Methoden verwenden, um Berechtigungen zwischen Ihren Ressourcen zu konfigurieren. Daher können Sie für jedes Szenario die beste Option auswählen und in Ihren Anwendungen mehrere Optionen zusammen verwenden. Hier sind einige Dinge, die Sie bei der Auswahl der für Sie besten Option beachten sollten:
+ AWS SAM Sowohl Konnektoren als auch Richtlinienvorlagen reduzieren den IAM-Bedarf an Fachwissen, das erforderlich ist, um sichere Interaktionen zwischen Ihren AWS Ressourcen zu ermöglichen. Verwenden Sie Konnektoren und Richtlinienvorlagen, sofern diese unterstützt werden.
+ AWS SAM Konnektoren bieten eine einfache und intuitive Kurzsyntax zur Definition von Berechtigungen in Ihren AWS SAM Vorlagen und erfordern das geringste Maß an IAM-Fachwissen. Wenn sowohl AWS SAM Konnektoren als auch Richtlinienvorlagen unterstützt werden, verwenden Sie AWS SAM Konnektoren.
+ AWS SAM Konnektoren können Daten `Read` und Ereignisse zwischen unterstützten AWS SAM Quell- und Zielressourcen bereitstellen und `Write` darauf zugreifen. Eine Liste der unterstützten Ressourcen finden Sie unter[AWS SAM Steckverbinderreferenz](reference-sam-connector.md). Verwenden Sie AWS SAM Konnektoren, sofern dies unterstützt wird.
+ Während AWS SAM Richtlinienvorlagen auf Berechtigungen zwischen Ihren Lambda-Funktionen, Step Functions Functions-Zustandsmaschinen und den AWS Ressourcen, mit denen sie interagieren, beschränkt sind, unterstützen Richtlinienvorlagen alle CRUD-Operationen. Verwenden AWS SAM Sie Richtlinienvorlagen, sofern sie unterstützt werden und wenn eine AWS SAM Richtlinienvorlage für Ihr Szenario verfügbar ist. Eine Liste der verfügbaren Richtlinienvorlagen finden Sie unter[AWS SAM Richtlinienvorlagen](serverless-policy-templates.md).
+ Verwenden Sie für alle anderen Szenarien oder wenn Granularität erforderlich ist, CloudFormation Mechanismen.
# Verwaltung von Ressourcenberechtigungen mit AWS SAM Konnektoren
Konnektoren sind ein abstrakter Ressourcentyp AWS Serverless Application Model (AWS SAM)`AWS::Serverless::Connector`, der einfache und gut abgegrenzte Berechtigungen zwischen Ihren serverlosen Anwendungsressourcen bereitstellt.
## Vorteile von Konnektoren AWS SAM
Durch die automatische Erstellung der entsprechenden Zugriffsrichtlinien zwischen Ressourcen können Sie mithilfe von Konnektoren Ihre serverlosen Anwendungen erstellen und sich auf Ihre Anwendungsarchitektur konzentrieren, ohne dass Sie Kenntnisse in den Bereichen AWS Autorisierungsfunktionen, Richtliniensprache und dienstspezifische Sicherheitseinstellungen benötigen. Daher sind Konnektoren ein großer Vorteil für Entwickler, die mit der serverlosen Entwicklung noch nicht vertraut sind, oder für erfahrene Entwickler, die ihre Entwicklungsgeschwindigkeit erhöhen möchten.
## Konnektoren verwenden AWS SAM
Verwenden Sie das `Connectors` Ressourcenattribut, indem Sie es in eine **Quellressource** einbetten. Definieren Sie anschließend Ihre **Zielressource** und beschreiben Sie, wie Daten oder Ereignisse zwischen diesen Ressourcen fließen sollen. AWS SAM erstellt dann die Zugriffsrichtlinien, die zur Erleichterung der erforderlichen Interaktionen erforderlich sind.
Im Folgenden wird beschrieben, wie dieses Ressourcenattribut geschrieben wird:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
:
Type:
...
Connectors:
:
Properties:
Destination:
Permissions:
...
```
## Wie funktionieren Konnektoren
**Anmerkung**
In diesem Abschnitt wird erklärt, wie Konnektoren die erforderlichen Ressourcen hinter den Kulissen bereitstellen. Dies geschieht automatisch für Sie, wenn Sie Konnektoren verwenden.
Zunächst wird das eingebettete `Connectors` Ressourcenattribut in einen `AWS::Serverless::Connector` Ressourcentyp umgewandelt. Seine logische ID wird automatisch als erstellt**.
Hier ist zum Beispiel ein eingebetteter Konnektor:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Lambda::Function
Connectors:
MyConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Read
- Write
MyTable:
Type: AWS::DynamoDB::Table
```
Dadurch wird die folgende `AWS::Serverless::Connector` Ressource generiert:
```
Transform: AWS::Serverless-2016-10-31
Resources:
...
MyFunctionMyConn:
Type: AWS::Serverless::Connector
Properties:
Source:
Id: MyFunction
Destination:
Id: MyTable
Permissions:
- Read
- Write
```
**Anmerkung**
Mithilfe dieser Syntax können Sie in Ihrer AWS SAM Vorlage auch Konnektoren definieren. Dies wird empfohlen, wenn Ihre Quellressource in einer anderen Vorlage als Ihr Connector definiert ist.
Als Nächstes werden die erforderlichen Zugriffsrichtlinien für diese Verbindung automatisch erstellt. Weitere Informationen zu den von Konnektoren generierten Ressourcen finden Sie unter[CloudFormation Ressourcen, die generiert werden, wenn Sie angeben AWS::Serverless::Connector](sam-specification-generated-resources-connector.md).
## Beispiel für Konnektoren
Das folgende Beispiel zeigt, wie Sie Konnektoren verwenden können, um Daten aus einer AWS Lambda Funktion in eine Amazon DynamoDB-Tabelle zu schreiben.
![\[Eine Lambda-Funktion, die mithilfe von Konnektoren Daten in eine DynamoDB-Tabelle schreibt. AWS SAM\]](http://docs.aws.amazon.com/de_de/serverless-application-model/latest/developerguide/images/managing-connectors-example.png)
```
Transform: AWS::Serverless-2016-10-31
Resources:
MyTable:
Type: AWS::Serverless::SimpleTable
MyFunction:
Type: AWS::Serverless::Function
Connectors:
MyConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Write
Properties:
Runtime: nodejs16.x
Handler: index.handler
InlineCode: |
const AWS = require("aws-sdk");
const docClient = new AWS.DynamoDB.DocumentClient();
exports.handler = async (event, context) => {
await docClient.put({
TableName: process.env.TABLE_NAME,
Item: {
id: context.awsRequestId,
event: JSON.stringify(event)
}
}).promise();
}
Environment:
Variables:
TABLE_NAME: !Ref MyTable
```
Das `Connectors` Ressourcenattribut ist in die Quellressource der Lambda-Funktion eingebettet. Die DynamoDB-Tabelle wird mithilfe der Eigenschaft als Zielressource definiert. `Id` Konnektoren stellen `Write` Berechtigungen zwischen diesen beiden Ressourcen bereit.
Wenn Sie Ihre AWS SAM Vorlage auf bereitstellen CloudFormation, AWS SAM werden automatisch die erforderlichen Zugriffsrichtlinien erstellt, die für das Funktionieren dieser Verbindung erforderlich sind.
## Unterstützte Verbindungen zwischen Quell- und Zielressourcen
Konnektoren unterstützen `Write` Daten `Read` - und Ereignisberechtigungstypen zwischen einer ausgewählten Kombination von Quell- und Zielressourcenverbindungen. Konnektoren unterstützen beispielsweise eine `Write` Verbindung zwischen einer `AWS::ApiGateway::RestApi` Quellressource und einer `AWS::Lambda::Function` Zielressource.
Quell- und Zielressourcen können mithilfe einer Kombination unterstützter Eigenschaften definiert werden. Die Eigenschaftsanforderungen hängen von der Verbindung ab, die Sie herstellen und davon, wo die Ressourcen definiert sind.
**Anmerkung**
Connectoren können Berechtigungen zwischen unterstützten serverlosen und nicht serverlosen Ressourcentypen bereitstellen.
Eine Liste der unterstützten Ressourcenverbindungen und ihrer Eigenschaftsanforderungen finden Sie unter. [Unterstützte Quell- und Zielressourcentypen für Konnektoren](reference-sam-connector.md#supported-connector-resource-types)
# Definieren Sie Lese- und Schreibberechtigungen in AWS SAM
In AWS SAM`Read` und `Write` Berechtigungen können innerhalb eines einzigen Connectors bereitgestellt werden:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Lambda::Function
Connectors:
MyTableConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Read
- Write
MyTable:
Type: AWS::DynamoDB::Table
```
Weitere Informationen zur Verwendung von Konnektoren finden Sie unter. [AWS SAM Steckverbinderreferenz](reference-sam-connector.md)
# Definieren Sie Ressourcen mithilfe anderer unterstützter Eigenschaften in AWS SAM
Verwenden Sie die `Id` Eigenschaft sowohl für Quell- als auch für Zielressourcen, sofern sie in derselben Vorlage definiert sind. Optional `Qualifier` kann eine hinzugefügt werden, um den Umfang Ihrer definierten Ressource einzuschränken. Wenn sich die Ressource nicht in derselben Vorlage befindet, verwenden Sie eine Kombination unterstützter Eigenschaften.
+ Eine Liste der unterstützten Eigenschaftskombinationen für Quell- und Zielressourcen finden Sie unter[Unterstützte Quell- und Zielressourcentypen für Konnektoren](reference-sam-connector.md#supported-connector-resource-types).
+ Eine Beschreibung der Eigenschaften, die Sie mit Konnektoren verwenden können, finden Sie unter[AWS::Serverless::Connector](sam-resource-connector.md).
Wenn Sie eine Quellressource mit einer anderen Eigenschaft als definieren`Id`, verwenden Sie die `SourceReference` Eigenschaft.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
:
Type:
...
Connectors:
:
Properties:
SourceReference:
Qualifier:
Destination:
Permissions:
```
Hier ist ein Beispiel, bei dem a verwendet wird, `Qualifier` um den Umfang einer Amazon API Gateway Gateway-Ressource einzuschränken:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyApi:
Type: AWS::Serverless::Api
Connectors:
ApiToLambdaConn:
Properties:
SourceReference:
Qualifier: Prod/GET/foobar
Destination:
Id: MyFunction
Permissions:
- Write
...
```
Hier ist ein Beispiel, bei dem eine unterstützte Kombination von `Arn` und verwendet wird`Type`, um eine Zielressource aus einer anderen Vorlage zu definieren:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
TableConn:
Properties:
Destination:
Type: AWS::DynamoDB::Table
Arn: !GetAtt MyTable.Arn
...
```
Weitere Informationen zur Verwendung von Konnektoren finden Sie unter[AWS SAM Steckverbinderreferenz](reference-sam-connector.md).
# Erstellen Sie mehrere Konnektoren aus einer einzigen Quelle in AWS SAM
Innerhalb einer Quellressource können Sie mehrere Konnektoren mit jeweils einer anderen Zielressource definieren.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
BucketConn:
Properties:
Destination:
Id: amzn-s3-demo-bucket
Permissions:
- Read
- Write
SQSConn:
Properties:
Destination:
Id: MyQueue
Permissions:
- Read
- Write
TableConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Read
- Write
TableConnWithTableArn:
Properties:
Destination:
Type: AWS::DynamoDB::Table
Arn: !GetAtt MyTable.Arn
Permissions:
- Read
- Write
...
```
Weitere Informationen zur Verwendung von Konnektoren finden Sie unter[AWS SAM Steckverbinderreferenz](reference-sam-connector.md).
# Erstellen Sie Konnektoren mit mehreren Zielen in AWS SAM
Innerhalb einer Quellressource können Sie einen einzelnen Konnektor mit mehreren Zielressourcen definieren. Hier ist ein Beispiel für eine Lambda-Funktionsquellenressource, die eine Verbindung zu einem Amazon Simple Storage Service (Amazon S3) -Bucket und einer DynamoDB-Tabelle herstellt:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
WriteAccessConn:
Properties:
Destination:
- Id: OutputBucket
- Id: CredentialTable
Permissions:
- Write
...
OutputBucket:
Type: AWS::S3::Bucket
CredentialTable:
Type: AWS::DynamoDB::Table
```
Weitere Informationen zur Verwendung von Konnektoren finden Sie unter. [AWS SAM Steckverbinderreferenz](reference-sam-connector.md)
# Definieren Sie Ressourcenattribute mit Konnektoren in AWS SAM
Ressourcenattribute können für Ressourcen definiert werden, um zusätzliche Verhaltensweisen und Beziehungen zu spezifizieren. Weitere Informationen zu Ressourcenattributen finden Sie unter [Referenz zu Ressourcenattributen](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-product-attribute-reference.html) im *AWS CloudFormation Benutzerhandbuch*.
Sie können Ihrem eingebetteten Konnektor Ressourcenattribute hinzufügen, indem Sie sie auf derselben Ebene wie Ihre Konnektoreigenschaften definieren. Wenn Ihre AWS SAM Vorlage bei der Bereitstellung transformiert wird, werden die Attribute an die generierten Ressourcen weitergegeben.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
MyConn:
DeletionPolicy: Retain
DependsOn: AnotherFunction
Properties:
...
```
Weitere Informationen zur Verwendung von Konnektoren finden Sie unter[AWS SAM Steckverbinderreferenz](reference-sam-connector.md).
## Weitere Informationen
Weitere Informationen zur Verwendung von AWS SAM Konnektoren finden Sie in den folgenden Themen:
+ [AWS::Serverless::Connector](sam-resource-connector.md)
+ [Definieren Sie Lese- und Schreibberechtigungen in AWS SAM](connector-usage-define.md)
+ [Definieren Sie Ressourcen mithilfe anderer unterstützter Eigenschaften in AWS SAM](connector-usage-other-properties.md)
+ [Erstellen Sie mehrere Konnektoren aus einer einzigen Quelle in AWS SAM](connector-usage-single-source.md)
+ [Erstellen Sie Konnektoren mit mehreren Zielen in AWS SAM](connector-usage-multi-destination.md)
+ [Definieren Sie Lese- und Schreibberechtigungen in AWS SAM](connector-usage-define.md)
+ [Definieren Sie Ressourcenattribute mit Konnektoren in AWS SAM](connector-usage-resource-attributes.md)
## Bereitstellen von Feedback
Wenn Sie Feedback zu Konnektoren geben möchten, [reichen Sie ein neues Problem](https://github.com/aws/serverless-application-model/issues/new?assignees=&labels=area%2Fconnectors,stage%2Fneeds-triage&template=other.md&title=%28Feature%20Request%29) im *serverless-application-model AWS GitHubRepository* ein.
# AWS SAM Richtlinienvorlagen
Mit AWS Serverless Application Model (AWS SAM) können Sie aus einer Liste von Richtlinienvorlagen auswählen, um die Berechtigungen Ihrer Lambda-Funktionen und AWS Step Functions Zustandsmaschinen auf die Ressourcen zu beschränken, die von Ihrer Anwendung verwendet werden.
AWS SAM Für Anwendungen in der AWS Serverless Application Repository , die Richtlinienvorlagen verwenden, ist keine besondere Bestätigung durch den Kunden erforderlich, um die Anwendung von zu implementieren. AWS Serverless Application Repository
Wenn Sie das Hinzufügen einer neuen Richtlinienvorlage anfordern möchten, führen Sie die folgenden Schritte aus:
1. Reichen Sie eine Pull-Anfrage für die Quelldatei policy\$1templates.json im Branch des Projekts ein. `develop` AWS SAM GitHub Sie finden die Quelldatei in [policy\$1templates.json](https://github.com/aws/serverless-application-model/blob/develop/samtranslator/policy_templates_data/policy_templates.json) auf der Website. GitHub
1. Reichen Sie im AWS SAM GitHub Projekt ein Problem ein, das die Gründe für Ihre Pull-Anfrage und einen Link zur Anfrage enthält. Verwenden Sie diesen Link, um ein neues Problem einzureichen [AWS Serverless Application Model: Probleme](https://github.com/aws/serverless-application-model/issues/new).
## Syntax
Für jede Richtlinienvorlage, die Sie in Ihrer AWS SAM Vorlagendatei angeben, müssen Sie immer ein Objekt angeben, das die Platzhalterwerte der Richtlinienvorlage enthält. Wenn für eine Richtlinienvorlage keine Platzhalterwerte erforderlich sind, müssen Sie ein leeres Objekt angeben.
### YAML
```
MyFunction:
Type: AWS::Serverless::Function
Properties:
Policies:
- PolicyTemplateName1: # Policy template with placeholder value
Key1: Value1
- PolicyTemplateName2: {} # Policy template with no placeholder value
```
**Anmerkung**
Wenn Sie eine reguläre IAM-Richtlinie eingerichtet oder Richtlinien über Lambda verwaltet haben, kann die Richtlinienvorlage eingerichtet werden, ohne ein leeres Objekt zu verwenden.
## Beispiele
### Beispiel 1: Richtlinienvorlage mit Platzhalterwerten
Das folgende Beispiel zeigt, dass die [SQSPollerPolicy](serverless-policy-template-list.md#sqs-poller-policy)-Richtlinienvorlage als Ressource einen `QueueName` erwartet. Die AWS SAM Vorlage ruft den Namen der "`MyQueue`" Amazon SQS SQS-Warteschlange ab, die Sie in derselben Anwendung erstellen oder als Parameter für die Anwendung anfordern können.
```
1. MyFunction:
2. Type: 'AWS::Serverless::Function'
3. Properties:
4. CodeUri: ${codeuri}
5. Handler: hello.handler
6. Runtime: python2.7
7. Policies:
8. - SQSPollerPolicy:
9. QueueName:
10. !GetAtt MyQueue.QueueName
```
### Beispiel 2: Richtlinienvorlage ohne Platzhalterwerten
Das folgende Beispiel enthält die [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy)-Richtlinienvorlage ohne Platzhalterwerte.
**Anmerkung**
Auch wenn es keine Platzhalterwerte gibt, müssen Sie ein leeres Objekt angeben, da andernfalls ein Fehler auftritt.
```
1. MyFunction:
2. Type: 'AWS::Serverless::Function'
3. Properties:
4. CodeUri: ${codeuri}
5. Handler: hello.handler
6. Runtime: python2.7
7. Policies:
8. - CloudWatchPutMetricPolicy: {}
```
### Beispiel 3: Richtlinienvorlage mit Platzhalterwerten und einer regulären IAM-Richtlinie
Das folgende Beispiel enthält die Amazon SQSFull Access-Richtlinie und die [DynamoDBCrudPolicy](serverless-policy-template-list.md#dynamo-db-crud-policy) Richtlinienvorlage. Die Amazon SQSFull Access-Richtlinie ist eine IAM-Richtlinie und keine AWS SAM Richtlinie. Sie müssen also kein leeres Objekt angeben, da die Richtlinie direkt an die CloudFormationübergeben würde.
```
1. MyFunction:
2. Type: 'AWS::Serverless::Function'
3. Properties:
4. CodeUri: ${codeuri}
5. Handler: hello.handler
6. Runtime: python2.7
7. Policies:
8. - AmazonSQSFullAccess // IAM policy could be set without passing an empty object
9. - DynamoDBCrudPolicy: // SAM specific policy, has a defined structure
10. TableName:
11. !Ref SampleTable
```
## Tabelle mit Richtlinienvorlagen
Die folgende Tabelle enthält die verfügbaren Richtlinienvorlagen.
****
| Richtlinienvorlage | Description |
| --- | --- |
| [AcmGetCertificatePolicy](serverless-policy-template-list.md#acm-get-certificate-policy) | Erteilt die Berechtigung zum Lesen eines Zertifikats von AWS Certificate Manager. |
| [AMIDescribePolicy](serverless-policy-template-list.md#ami-describe-policy) | Erteilt die Erlaubnis, Amazon Machine Images (AMIs) zu beschreiben. |
| [AthenaQueryPolicy](serverless-policy-template-list.md#athena-query-policy) | Erteilt Berechtigungen zur Ausführung von Athena-Abfragen. |
| [AWSSecretsManagerGetSecretValuePolicy](serverless-policy-template-list.md#secrets-manager-get-secret-value-policy) | Erteilt die Erlaubnis, den geheimen Wert für das angegebene AWS Secrets Manager Geheimnis abzurufen. |
| [AWSSecretsManagerRotationPolicy](serverless-policy-template-list.md#secrets-manager-rotation-policy) | Erteilt die Erlaubnis, ein Geheimnis abwechselnd einzugeben AWS Secrets Manager. |
| [CloudFormationDescribeStacksPolicy](serverless-policy-template-list.md#cloud-formation-describe-stacks-policy) | Erteilt die Erlaubnis, CloudFormation Stapel zu beschreiben. |
| [CloudWatchDashboardPolicy](serverless-policy-template-list.md#cloudwatch-dashboard-policy) | Erteilt die Erlaubnis, Metriken auf CloudWatch Dashboards zu platzieren. |
| [CloudWatchDescribeAlarmHistoryPolicy](serverless-policy-template-list.md#cloudwatch-describe-alarm-history-policy) | Erlaubt die Beschreibung des CloudWatch Alarmverlaufs. |
| [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy) | Erteilt die Erlaubnis, Messwerte an zu senden CloudWatch. |
| [CodeCommitCrudPolicy](serverless-policy-template-list.md#codecommit-crud-policy) | Erteilt Berechtigungen für create/read/update/delete Objekte in einem bestimmten CodeCommit Repository. |
| [CodeCommitReadPolicy](serverless-policy-template-list.md#codecommit-read-policy) | Erteilt Berechtigungen zum Lesen von Objekten in einem bestimmten CodeCommit Repository. |
| [CodePipelineLambdaExecutionPolicy](serverless-policy-template-list.md#code-pipeline-lambda-execution-policy) | Erteilt die Erlaubnis für eine Lambda-Funktion, die von aufgerufen wird CodePipeline , um den Status des Jobs zu melden. |
| [CodePipelineReadOnlyPolicy](serverless-policy-template-list.md#code-pipeline-readonly-policy) | Erteilt die Leseberechtigung zum Abrufen von Details zu einer CodePipeline Pipeline. |
| [ComprehendBasicAccessPolicy](serverless-policy-template-list.md#comprehend-basic-access-policy) | Erteilt die Berechtigung zum Erkennen von Entitäten, Schlüsselbegriffen, Sprachen und Stimmungen. |
| [CostExplorerReadOnlyPolicy](serverless-policy-template-list.md#cost-explorer-readonly-policy) | Erteilt dem Cost Explorer APIs mit Lesezugriff für die Abrechnungshistorie die Berechtigung zum Lesen. |
| [DynamoDBBackupFullAccessPolicy](serverless-policy-template-list.md#ddb-back-full-policy) | Erteilt Lese- und Schreibberechtigungen für DynamoDB-Backups auf Abruf für eine Tabelle. |
| [DynamoDBCrudPolicy](serverless-policy-template-list.md#dynamo-db-crud-policy) | Erteilt Erstellungs-, Lese-, Aktualisierungs- und Löschberechtigungen für eine Amazon DynamoDB-Tabelle. |
| [DynamoDBReadPolicy](serverless-policy-template-list.md#dynamo-db-read-policy) | Erteilt einer DynamoDB-Tabelle nur Leseberechtigungen. |
| [DynamoDBReconfigurePolicy](serverless-policy-template-list.md#dynamo-db-reconfigure-policy) | Erteilt die Erlaubnis, eine DynamoDB-Tabelle neu zu konfigurieren. |
| [DynamoDBRestoreFromBackupPolicy](serverless-policy-template-list.md#ddb-restore-from-backup-policy) | Erteilt die Erlaubnis, eine DynamoDB-Tabelle aus einem Backup wiederherzustellen. |
| [DynamoDBStreamReadPolicy](serverless-policy-template-list.md#dynamo-db-stream-read-policy) | Erlaubt das Beschreiben und Lesen von DynamoDB-Streams und -Datensätzen. |
| [DynamoDBWritePolicy](serverless-policy-template-list.md#dynamo-db-write-policy) | Erteilt nur Schreibberechtigungen für eine DynamoDB-Tabelle. |
| [EC2CopyImagePolicy](serverless-policy-template-list.md#ec2-copy-image-policy) | Erlaubt das Kopieren von Amazon EC2 EC2-Images. |
| [EC2DescribePolicy](serverless-policy-template-list.md#ec2-describe-policy) | Erteilt die Erlaubnis, Amazon Elastic Compute Cloud (Amazon EC2) -Instances zu beschreiben. |
| [EcsRunTaskPolicy](serverless-policy-template-list.md#ecs-run-task-policy) | Erteilt die Erlaubnis, eine neue Aufgabe für eine Aufgabendefinition zu starten. |
| [EFSWriteAccessPolicy](serverless-policy-template-list.md#efs-write-access-policy) | Erteilt die Erlaubnis, ein Amazon EFS-Dateisystem mit Schreibzugriff zu mounten. |
| [EKSDescribePolicy](serverless-policy-template-list.md#eks-describe-policy) | Erteilt die Erlaubnis, Amazon EKS-Cluster zu beschreiben oder aufzulisten. |
| [ElasticMapReduceAddJobFlowStepsPolicy](serverless-policy-template-list.md#elastic-map-reduce-add-job-flows-policy) | Erteilt die Erlaubnis, einem laufenden Cluster neue Schritte hinzuzufügen. |
| [ElasticMapReduceCancelStepsPolicy](serverless-policy-template-list.md#elastic-map-reduce-cancel-steps-policy) | Erteilt die Erlaubnis, einen oder mehrere ausstehende Schritte in einem laufenden Cluster abzubrechen. |
| [ElasticMapReduceModifyInstanceFleetPolicy](serverless-policy-template-list.md#elastic-map-reduce-modify-instance-fleet-policy) | Erteilt die Erlaubnis, Details für Instance-Flotten innerhalb eines Clusters aufzulisten und Kapazitäten zu ändern. |
| [ElasticMapReduceModifyInstanceGroupsPolicy](serverless-policy-template-list.md#elastic-map-reduce-modify-instance-groups-policy) | Erteilt die Erlaubnis, Details aufzulisten und Einstellungen für Instanzgruppen innerhalb eines Clusters zu ändern. |
| [ElasticMapReduceSetTerminationProtectionPolicy](serverless-policy-template-list.md#elastic-map-reduce-set-termination-protection-policy) | Erteilt die Erlaubnis, den Kündigungsschutz für einen Cluster festzulegen. |
| [ElasticMapReduceTerminateJobFlowsPolicy](serverless-policy-template-list.md#elastic-map-reduce-terminate-job-flows-policy) | Erteilt die Erlaubnis, einen Cluster herunterzufahren. |
| [ElasticsearchHttpPostPolicy](serverless-policy-template-list.md#elastic-search-http-post-policy) | Erteilt Amazon OpenSearch Service die POST-Berechtigung. |
| [EventBridgePutEventsPolicy](serverless-policy-template-list.md#eventbridge-put-events-policy) | Erteilt Berechtigungen zum Senden von Ereignissen an EventBridge. |
| [FilterLogEventsPolicy](serverless-policy-template-list.md#filter-log-events-policy) | Erteilt die Berechtigung, CloudWatch Log-Ereignisse aus einer bestimmten Protokollgruppe zu filtern. |
| [FirehoseCrudPolicy](serverless-policy-template-list.md#firehose-crud-policy) | Erteilt die Erlaubnis, einen Firehose-Lieferstream zu erstellen, zu schreiben, zu aktualisieren und zu löschen. |
| [FirehoseWritePolicy](serverless-policy-template-list.md#firehose-write-policy) | Erteilt die Erlaubnis, in einen Firehose-Lieferstream zu schreiben. |
| [KinesisCrudPolicy](serverless-policy-template-list.md#kinesis-crud-policy) | Erteilt die Erlaubnis, einen Amazon Kinesis Kinesis-Stream zu erstellen, zu veröffentlichen und zu löschen. |
| [KinesisStreamReadPolicy](serverless-policy-template-list.md#kinesis-stream-read-policy) | Erteilt die Erlaubnis, einen Amazon Kinesis Kinesis-Stream aufzulisten und zu lesen. |
| [KMSDecryptPolicy](serverless-policy-template-list.md#kms-decrypt-policy) | Erteilt die Erlaubnis zum Entschlüsseln mit einem AWS Key Management Service (AWS KMS) -Schlüssel. |
| [KMSEncryptPolicy](serverless-policy-template-list.md#kms-encrypt-policy) | Erteilt die Erlaubnis, mit einem Schlüssel AWS Key Management Service (AWS KMS) zu verschlüsseln. |
| [LambdaInvokePolicy](serverless-policy-template-list.md#lambda-invoke-policy) | Erteilt die Erlaubnis, eine AWS Lambda Funktion, einen Alias oder eine Version aufzurufen. |
| [MobileAnalyticsWriteOnlyAccessPolicy](serverless-policy-template-list.md#mobile-analytics-write-only-access-policy) | Erteilt Schreibzugriff zum Speichern von Ereignisdaten für alle Anwendungsressourcen. |
| [OrganizationsListAccountsPolicy](serverless-policy-template-list.md#organizations-list-accounts-policy) | Erteilt die Leseberechtigung zum Auflisten der Kontonamen von Kindern und. IDs |
| [PinpointEndpointAccessPolicy](serverless-policy-template-list.md#pinpoint-endpoint-access-policy) | Erteilt die Erlaubnis, Endpunkte für eine Amazon Pinpoint Pinpoint-Anwendung abzurufen und zu aktualisieren. |
| [PollyFullAccessPolicy](serverless-policy-template-list.md#polly-full-access-policy) | Gewährt vollen Zugriff auf Amazon Polly Polly-Lexikonressourcen. |
| [RekognitionDetectOnlyPolicy](serverless-policy-template-list.md#rekognition-detect-only-policy) | Erteilt die Erlaubnis, Gesichter, Beschriftungen und Text zu erkennen. |
| [RekognitionFacesManagementPolicy](serverless-policy-template-list.md#rekognition-face-management-policy) | Erlaubt das Hinzufügen, Löschen und Suchen von Gesichtern in einer Amazon Rekognition Rekognition-Sammlung. |
| [RekognitionFacesPolicy](serverless-policy-template-list.md#rekognition-faces-policy) | Erlaubt das Vergleichen und Erkennen von Gesichtern und Labels. |
| [RekognitionLabelsPolicy](serverless-policy-template-list.md#rekognition-labels-policy) | Erteilt die Erlaubnis, Objekt- und Moderationsbezeichnungen zu erkennen. |
| [RekognitionNoDataAccessPolicy](serverless-policy-template-list.md#rekognition-no-data-access-policy) | Erlaubt das Vergleichen und Erkennen von Gesichtern und Labels. |
| [RekognitionReadPolicy](serverless-policy-template-list.md#rekognition-read-policy) | Erlaubt das Auflisten und Suchen von Gesichtern. |
| [RekognitionWriteOnlyAccessPolicy](serverless-policy-template-list.md#rekognition-write-only-access-policy) | Erteilt die Erlaubnis, Gesichter in einer Sammlung zu erstellen und zu indexieren. |
| [Route53ChangeResourceRecordSetsPolicy](serverless-policy-template-list.md#route53-change-resource-record-sets-policy) | Erteilt die Erlaubnis, Ressourcendatensätze in Route 53 zu ändern. |
| [S3CrudPolicy](serverless-policy-template-list.md#s3-crud-policy) | Erteilt Erstellungs-, Lese-, Aktualisierungs- und Löschberechtigungen, um auf die Objekte in einem Amazon S3 S3-Bucket zu reagieren. |
| [S3FullAccessPolicy](serverless-policy-template-list.md#s3-full-access-policy) | Erteilt die volle Zugriffsberechtigung, um auf die Objekte in einem Amazon S3 S3-Bucket zu reagieren. |
| [S3ReadPolicy](serverless-policy-template-list.md#s3-read-policy) | Erteilt nur Leseberechtigungen zum Lesen von Objekten in einem Amazon Simple Storage Service (Amazon S3) -Bucket. |
| [S3WritePolicy](serverless-policy-template-list.md#s3-write-policy) | Erteilt Schreibberechtigungen zum Schreiben von Objekten in einen Amazon S3 S3-Bucket. |
| [SageMakerCreateEndpointConfigPolicy](serverless-policy-template-list.md#sagemaker-create-endpoint-config-policy) | Erteilt die Erlaubnis, eine Endpunktkonfiguration in SageMaker AI zu erstellen. |
| [SageMakerCreateEndpointPolicy](serverless-policy-template-list.md#sagemaker-create-endpoint-policy) | Erteilt die Erlaubnis, einen Endpunkt in SageMaker AI zu erstellen. |
| [ServerlessRepoReadWriteAccessPolicy](serverless-policy-template-list.md#serverlessrepo-read-write-access-policy) | Erteilt die Erlaubnis, Anwendungen im AWS Serverless Application Repository Dienst zu erstellen und aufzulisten. |
| [SESBulkTemplatedCrudPolicy](serverless-policy-template-list.md#ses-bulk-templated-crud-policy) | Erteilt die Erlaubnis, E-Mails, E-Mails mit Vorlagen und Massen-E-Mails mit Vorlagen zu senden und die Identität zu überprüfen. |
| [SESBulkTemplatedCrudPolicy\$1v2](serverless-policy-template-list.md#ses-bulk-templated-crud-policy-v2) | Erteilt die Erlaubnis, Amazon SES SES-E-Mails, E-Mail-Vorlagen und Massen-E-Mails mit Vorlagen zu senden und die Identität zu überprüfen. |
| [SESCrudPolicy](serverless-policy-template-list.md#ses-crud-policy) | Erteilt die Erlaubnis, E-Mails zu senden und die Identität zu überprüfen. |
| [SESEmailTemplateCrudPolicy](serverless-policy-template-list.md#ses-email-template-crud-policy) | Erteilt die Erlaubnis, Amazon SES SES-E-Mail-Vorlagen zu erstellen, abzurufen, aufzulisten, zu aktualisieren und zu löschen. |
| [SESSendBouncePolicy](serverless-policy-template-list.md#ses-send-bounce-policy) | SendBounce Erteilt die Erlaubnis für eine Amazon Simple Email Service (Amazon SES) -Identität. |
| [SNSCrudPolicy](serverless-policy-template-list.md#sns-crud-policy) | Erteilt die Erlaubnis, Amazon SNS SNS-Themen zu erstellen, zu veröffentlichen und zu abonnieren. |
| [SNSPublishMessagePolicy](serverless-policy-template-list.md#sqs-publish-message-policy) | Erteilt die Erlaubnis, eine Nachricht zu einem Amazon Simple Notification Service (Amazon SNS) -Thema zu veröffentlichen. |
| [SQSPollerPolicy](serverless-policy-template-list.md#sqs-poller-policy) | Erteilt die Erlaubnis, eine Amazon Simple Queue Service (Amazon SQS) -Warteschlange abzufragen. |
| [SQSSendMessagePolicy](serverless-policy-template-list.md#sqs-send-message-policy) | Erteilt die Erlaubnis, Nachrichten an eine Amazon SQS SQS-Warteschlange zu senden. |
| [SSMParameterReadPolicy](serverless-policy-template-list.md#ssm-parameter-read-policy) | Erteilt die Erlaubnis, auf einen Parameter aus einem Amazon EC2 Systems Manager (SSM) -Parameterspeicher zuzugreifen, um Geheimnisse in dieses Konto zu laden. Wird verwendet, wenn der Parametername kein Schrägstrich-Präfix hat. |
| [SSMParameterWithSlashPrefixReadPolicy](serverless-policy-template-list.md#ssm-parameter-slash-read-policy) | Erteilt die Erlaubnis, auf einen Parameter aus einem Amazon EC2 Systems Manager (SSM) -Parameterspeicher zuzugreifen, um Geheimnisse in dieses Konto zu laden. Wird verwendet, wenn der Parametername ein Schrägstrich-Präfix hat. |
| [StepFunctionsExecutionPolicy](serverless-policy-template-list.md#stepfunctions-execution-policy) | Erteilt die Erlaubnis, die Ausführung einer Step Functions Functions-Zustandsmaschine zu starten. |
| [TextractDetectAnalyzePolicy](serverless-policy-template-list.md#textract-detect-analyze-policy) | Ermöglicht den Zugriff auf die Erkennung und Analyse von Dokumenten mit Amazon Textract. |
| [TextractGetResultPolicy](serverless-policy-template-list.md#textract-get-result-policy) | Ermöglicht den Zugriff auf erkannte und analysierte Dokumente von Amazon Textract. |
| [TextractPolicy](serverless-policy-template-list.md#textract-policy) | Ermöglicht vollen Zugriff auf Amazon Textract. |
| [VPCAccessPolicy](serverless-policy-template-list.md#vpc-access-policy) | Ermöglicht das Erstellen, Löschen, Beschreiben und Trennen elastischer Netzwerkschnittstellen. |
## Fehlerbehebung
### SAM-CLI-Fehler: „Gültige Parameterwerte für die Richtlinienvorlage '< policy-template-name >' müssen angegeben werden“
Bei der Ausführung von `sam build` wird der folgende Fehler angezeigt:
```
"Must specify valid parameter values for policy template ''"
```
Das bedeutet, dass Sie bei der Deklaration einer Richtlinienvorlage, die keine Platzhalterwerte enthält, kein leeres Objekt übergeben haben.
Um dieses Problem zu beheben, deklarieren Sie die Richtlinie wie im folgenden Beispiel für. [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy)
```
1. MyFunction:
2. Policies:
3. - CloudWatchPutMetricPolicy: {}
```
# AWS SAM Liste der Richtlinienvorlagen
Im Folgenden sind die verfügbaren Richtlinienvorlagen zusammen mit den Berechtigungen aufgeführt, die auf die einzelnen Vorlagen angewendet werden. AWS Serverless Application Model (AWS SAM) füllt die Platzhalterelemente (wie AWS Region und Konto-ID) automatisch mit den entsprechenden Informationen aus.
**Topics**
+ [AcmGetCertificatePolicy](#acm-get-certificate-policy)
+ [AMIDescribePolicy](#ami-describe-policy)
+ [AthenaQueryPolicy](#athena-query-policy)
+ [AWSSecretsManagerGetSecretValuePolicy](#secrets-manager-get-secret-value-policy)
+ [AWSSecretsManagerRotationPolicy](#secrets-manager-rotation-policy)
+ [CloudFormationDescribeStacksPolicy](#cloud-formation-describe-stacks-policy)
+ [CloudWatchDashboardPolicy](#cloudwatch-dashboard-policy)
+ [CloudWatchDescribeAlarmHistoryPolicy](#cloudwatch-describe-alarm-history-policy)
+ [CloudWatchPutMetricPolicy](#cloudwatch-put-metric-policy)
+ [CodePipelineLambdaExecutionPolicy](#code-pipeline-lambda-execution-policy)
+ [CodePipelineReadOnlyPolicy](#code-pipeline-readonly-policy)
+ [CodeCommitCrudPolicy](#codecommit-crud-policy)
+ [CodeCommitReadPolicy](#codecommit-read-policy)
+ [ComprehendBasicAccessPolicy](#comprehend-basic-access-policy)
+ [CostExplorerReadOnlyPolicy](#cost-explorer-readonly-policy)
+ [DynamoDBBackupFullAccessPolicy](#ddb-back-full-policy)
+ [DynamoDBCrudPolicy](#dynamo-db-crud-policy)
+ [DynamoDBReadPolicy](#dynamo-db-read-policy)
+ [DynamoDBReconfigurePolicy](#dynamo-db-reconfigure-policy)
+ [DynamoDBRestoreFromBackupPolicy](#ddb-restore-from-backup-policy)
+ [DynamoDBStreamReadPolicy](#dynamo-db-stream-read-policy)
+ [DynamoDBWritePolicy](#dynamo-db-write-policy)
+ [EC2CopyImagePolicy](#ec2-copy-image-policy)
+ [EC2DescribePolicy](#ec2-describe-policy)
+ [EcsRunTaskPolicy](#ecs-run-task-policy)
+ [EFSWriteAccessPolicy](#efs-write-access-policy)
+ [EKSDescribePolicy](#eks-describe-policy)
+ [ElasticMapReduceAddJobFlowStepsPolicy](#elastic-map-reduce-add-job-flows-policy)
+ [ElasticMapReduceCancelStepsPolicy](#elastic-map-reduce-cancel-steps-policy)
+ [ElasticMapReduceModifyInstanceFleetPolicy](#elastic-map-reduce-modify-instance-fleet-policy)
+ [ElasticMapReduceModifyInstanceGroupsPolicy](#elastic-map-reduce-modify-instance-groups-policy)
+ [ElasticMapReduceSetTerminationProtectionPolicy](#elastic-map-reduce-set-termination-protection-policy)
+ [ElasticMapReduceTerminateJobFlowsPolicy](#elastic-map-reduce-terminate-job-flows-policy)
+ [ElasticsearchHttpPostPolicy](#elastic-search-http-post-policy)
+ [EventBridgePutEventsPolicy](#eventbridge-put-events-policy)
+ [FilterLogEventsPolicy](#filter-log-events-policy)
+ [FirehoseCrudPolicy](#firehose-crud-policy)
+ [FirehoseWritePolicy](#firehose-write-policy)
+ [KinesisCrudPolicy](#kinesis-crud-policy)
+ [KinesisStreamReadPolicy](#kinesis-stream-read-policy)
+ [KMSDecryptPolicy](#kms-decrypt-policy)
+ [KMSEncryptPolicy](#kms-encrypt-policy)
+ [LambdaInvokePolicy](#lambda-invoke-policy)
+ [MobileAnalyticsWriteOnlyAccessPolicy](#mobile-analytics-write-only-access-policy)
+ [OrganizationsListAccountsPolicy](#organizations-list-accounts-policy)
+ [PinpointEndpointAccessPolicy](#pinpoint-endpoint-access-policy)
+ [PollyFullAccessPolicy](#polly-full-access-policy)
+ [RekognitionDetectOnlyPolicy](#rekognition-detect-only-policy)
+ [RekognitionFacesManagementPolicy](#rekognition-face-management-policy)
+ [RekognitionFacesPolicy](#rekognition-faces-policy)
+ [RekognitionLabelsPolicy](#rekognition-labels-policy)
+ [RekognitionNoDataAccessPolicy](#rekognition-no-data-access-policy)
+ [RekognitionReadPolicy](#rekognition-read-policy)
+ [RekognitionWriteOnlyAccessPolicy](#rekognition-write-only-access-policy)
+ [Route53ChangeResourceRecordSetsPolicy](#route53-change-resource-record-sets-policy)
+ [S3CrudPolicy](#s3-crud-policy)
+ [S3FullAccessPolicy](#s3-full-access-policy)
+ [S3ReadPolicy](#s3-read-policy)
+ [S3WritePolicy](#s3-write-policy)
+ [SageMakerCreateEndpointConfigPolicy](#sagemaker-create-endpoint-config-policy)
+ [SageMakerCreateEndpointPolicy](#sagemaker-create-endpoint-policy)
+ [ServerlessRepoReadWriteAccessPolicy](#serverlessrepo-read-write-access-policy)
+ [SESBulkTemplatedCrudPolicy](#ses-bulk-templated-crud-policy)
+ [SESBulkTemplatedCrudPolicy\$1v2](#ses-bulk-templated-crud-policy-v2)
+ [SESCrudPolicy](#ses-crud-policy)
+ [SESEmailTemplateCrudPolicy](#ses-email-template-crud-policy)
+ [SESSendBouncePolicy](#ses-send-bounce-policy)
+ [SNSCrudPolicy](#sns-crud-policy)
+ [SNSPublishMessagePolicy](#sqs-publish-message-policy)
+ [SQSPollerPolicy](#sqs-poller-policy)
+ [SQSSendMessagePolicy](#sqs-send-message-policy)
+ [SSMParameterReadPolicy](#ssm-parameter-read-policy)
+ [SSMParameterWithSlashPrefixReadPolicy](#ssm-parameter-slash-read-policy)
+ [StepFunctionsExecutionPolicy](#stepfunctions-execution-policy)
+ [TextractDetectAnalyzePolicy](#textract-detect-analyze-policy)
+ [TextractGetResultPolicy](#textract-get-result-policy)
+ [TextractPolicy](#textract-policy)
+ [VPCAccessPolicy](#vpc-access-policy)
## AcmGetCertificatePolicy
Erteilt die Berechtigung zum Lesen eines Zertifikats von. AWS Certificate Manager
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"acm:GetCertificate"
],
"Resource": {
"Fn::Sub": [
"${certificateArn}",
{
"certificateArn": {
"Ref": "CertificateArn"
}
}
]
}
}
]
```
## AMIDescribePolicy
Erteilt die Erlaubnis, Amazon Machine Images (AMIs) zu beschreiben.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeImages"
],
"Resource": "*"
}
]
```
## AthenaQueryPolicy
Erteilt Berechtigungen zur Ausführung von Athena-Abfragen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"athena:ListWorkGroups",
"athena:GetExecutionEngine",
"athena:GetExecutionEngines",
"athena:GetNamespace",
"athena:GetCatalogs",
"athena:GetNamespaces",
"athena:GetTables",
"athena:GetTable"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"athena:StartQueryExecution",
"athena:GetQueryResults",
"athena:DeleteNamedQuery",
"athena:GetNamedQuery",
"athena:ListQueryExecutions",
"athena:StopQueryExecution",
"athena:GetQueryResultsStream",
"athena:ListNamedQueries",
"athena:CreateNamedQuery",
"athena:GetQueryExecution",
"athena:BatchGetNamedQuery",
"athena:BatchGetQueryExecution",
"athena:GetWorkGroup"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:athena:${AWS::Region}:${AWS::AccountId}:workgroup/${workgroupName}",
{
"workgroupName": {
"Ref": "WorkGroupName"
}
}
]
}
}
]
```
## AWSSecretsManagerGetSecretValuePolicy
Erteilt die Erlaubnis, den geheimen Wert für das angegebene AWS Secrets Manager Geheimnis abzurufen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": {
"Fn::Sub": [
"${secretArn}",
{
"secretArn": {
"Ref": "SecretArn"
}
}
]
}
}
]
```
## AWSSecretsManagerRotationPolicy
Erteilt die Erlaubnis, ein Geheimnis zu wechseln AWS Secrets Manager.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:DescribeSecret",
"secretsmanager:GetSecretValue",
"secretsmanager:PutSecretValue",
"secretsmanager:UpdateSecretVersionStage"
],
"Resource": {
"Fn::Sub": "arn:${AWS::Partition}:secretsmanager:${AWS::Region}:${AWS::AccountId}:secret:*"
},
"Condition": {
"StringEquals": {
"secretsmanager:resource/AllowRotationLambdaArn": {
"Fn::Sub": [
"arn:${AWS::Partition}:lambda:${AWS::Region}:${AWS::AccountId}:function:${functionName}",
{
"functionName": {
"Ref": "FunctionName"
}
}
]
}
}
}
},
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetRandomPassword"
],
"Resource": "*"
}
]
```
## CloudFormationDescribeStacksPolicy
Erteilt die Erlaubnis, CloudFormation Stapel zu beschreiben.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudformation:DescribeStacks"
],
"Resource": {
"Fn::Sub": "arn:${AWS::Partition}:cloudformation:${AWS::Region}:${AWS::AccountId}:stack/*"
}
}
]
```
## CloudWatchDashboardPolicy
Erteilt die Erlaubnis, Metriken auf CloudWatch Dashboards zu platzieren.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:GetDashboard",
"cloudwatch:ListDashboards",
"cloudwatch:PutDashboard",
"cloudwatch:ListMetrics"
],
"Resource": "*"
}
]
```
## CloudWatchDescribeAlarmHistoryPolicy
Erlaubt die Beschreibung des CloudWatch Amazon-Alarmverlaufs.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:DescribeAlarmHistory"
],
"Resource": "*"
}
]
```
## CloudWatchPutMetricPolicy
Erteilt die Erlaubnis, Metriken an zu senden CloudWatch.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricData"
],
"Resource": "*"
}
]
```
## CodePipelineLambdaExecutionPolicy
Erteilt die Erlaubnis für eine Lambda-Funktion, die von aufgerufen wird AWS CodePipeline , um den Status des Jobs zu melden.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:PutJobSuccessResult",
"codepipeline:PutJobFailureResult"
],
"Resource": "*"
}
]
```
## CodePipelineReadOnlyPolicy
Erteilt die Leseberechtigung zum Abrufen von Details zu einer CodePipeline Pipeline.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:ListPipelineExecutions"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:codepipeline:${AWS::Region}:${AWS::AccountId}:${pipelinename}",
{
"pipelinename": {
"Ref": "PipelineName"
}
}
]
}
}
]
```
## CodeCommitCrudPolicy
Erteilt Berechtigungen zum Erstellen, Lesen, Aktualisieren und Löschen von Objekten innerhalb eines bestimmten CodeCommit Repositorys.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:GitPull",
"codecommit:GitPush",
"codecommit:CreateBranch",
"codecommit:DeleteBranch",
"codecommit:GetBranch",
"codecommit:ListBranches",
"codecommit:MergeBranchesByFastForward",
"codecommit:MergeBranchesBySquash",
"codecommit:MergeBranchesByThreeWay",
"codecommit:UpdateDefaultBranch",
"codecommit:BatchDescribeMergeConflicts",
"codecommit:CreateUnreferencedMergeCommit",
"codecommit:DescribeMergeConflicts",
"codecommit:GetMergeCommit",
"codecommit:GetMergeOptions",
"codecommit:BatchGetPullRequests",
"codecommit:CreatePullRequest",
"codecommit:DescribePullRequestEvents",
"codecommit:GetCommentsForPullRequest",
"codecommit:GetCommitsFromMergeBase",
"codecommit:GetMergeConflicts",
"codecommit:GetPullRequest",
"codecommit:ListPullRequests",
"codecommit:MergePullRequestByFastForward",
"codecommit:MergePullRequestBySquash",
"codecommit:MergePullRequestByThreeWay",
"codecommit:PostCommentForPullRequest",
"codecommit:UpdatePullRequestDescription",
"codecommit:UpdatePullRequestStatus",
"codecommit:UpdatePullRequestTitle",
"codecommit:DeleteFile",
"codecommit:GetBlob",
"codecommit:GetFile",
"codecommit:GetFolder",
"codecommit:PutFile",
"codecommit:DeleteCommentContent",
"codecommit:GetComment",
"codecommit:GetCommentsForComparedCommit",
"codecommit:PostCommentForComparedCommit",
"codecommit:PostCommentReply",
"codecommit:UpdateComment",
"codecommit:BatchGetCommits",
"codecommit:CreateCommit",
"codecommit:GetCommit",
"codecommit:GetCommitHistory",
"codecommit:GetDifferences",
"codecommit:GetObjectIdentifier",
"codecommit:GetReferences",
"codecommit:GetTree",
"codecommit:GetRepository",
"codecommit:UpdateRepositoryDescription",
"codecommit:ListTagsForResource",
"codecommit:TagResource",
"codecommit:UntagResource",
"codecommit:GetRepositoryTriggers",
"codecommit:PutRepositoryTriggers",
"codecommit:TestRepositoryTriggers",
"codecommit:GetBranch",
"codecommit:GetCommit",
"codecommit:UploadArchive",
"codecommit:GetUploadArchiveStatus",
"codecommit:CancelUploadArchive"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:codecommit:${AWS::Region}:${AWS::AccountId}:${repositoryName}",
{
"repositoryName": {
"Ref": "RepositoryName"
}
}
]
}
}
]
```
## CodeCommitReadPolicy
Erteilt Berechtigungen zum Lesen von Objekten innerhalb eines bestimmten CodeCommit Repositorys.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:GitPull",
"codecommit:GetBranch",
"codecommit:ListBranches",
"codecommit:BatchDescribeMergeConflicts",
"codecommit:DescribeMergeConflicts",
"codecommit:GetMergeCommit",
"codecommit:GetMergeOptions",
"codecommit:BatchGetPullRequests",
"codecommit:DescribePullRequestEvents",
"codecommit:GetCommentsForPullRequest",
"codecommit:GetCommitsFromMergeBase",
"codecommit:GetMergeConflicts",
"codecommit:GetPullRequest",
"codecommit:ListPullRequests",
"codecommit:GetBlob",
"codecommit:GetFile",
"codecommit:GetFolder",
"codecommit:GetComment",
"codecommit:GetCommentsForComparedCommit",
"codecommit:BatchGetCommits",
"codecommit:GetCommit",
"codecommit:GetCommitHistory",
"codecommit:GetDifferences",
"codecommit:GetObjectIdentifier",
"codecommit:GetReferences",
"codecommit:GetTree",
"codecommit:GetRepository",
"codecommit:ListTagsForResource",
"codecommit:GetRepositoryTriggers",
"codecommit:TestRepositoryTriggers",
"codecommit:GetBranch",
"codecommit:GetCommit",
"codecommit:GetUploadArchiveStatus"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:codecommit:${AWS::Region}:${AWS::AccountId}:${repositoryName}",
{
"repositoryName": {
"Ref": "RepositoryName"
}
}
]
}
}
]
```
## ComprehendBasicAccessPolicy
Erteilt die Erlaubnis zum Erkennen von Entitäten, Schlüsselbegriffen, Sprachen und Stimmungen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"comprehend:BatchDetectKeyPhrases",
"comprehend:DetectDominantLanguage",
"comprehend:DetectEntities",
"comprehend:BatchDetectEntities",
"comprehend:DetectKeyPhrases",
"comprehend:DetectSentiment",
"comprehend:BatchDetectDominantLanguage",
"comprehend:BatchDetectSentiment"
],
"Resource": "*"
}
]
```
## CostExplorerReadOnlyPolicy
Erlaubt dem Nur-Lese-Zugriff AWS Cost Explorer (Cost Explorer) APIs für die Abrechnungshistorie.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ce:GetCostAndUsage",
"ce:GetDimensionValues",
"ce:GetReservationCoverage",
"ce:GetReservationPurchaseRecommendation",
"ce:GetReservationUtilization",
"ce:GetTags"
],
"Resource": "*"
}
]
```
## DynamoDBBackupFullAccessPolicy
Erteilt Lese- und Schreibberechtigungen für DynamoDB-Backups auf Abruf für eine Tabelle.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:CreateBackup",
"dynamodb:DescribeContinuousBackups"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:DeleteBackup",
"dynamodb:DescribeBackup",
"dynamodb:ListBackups"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/backup/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBCrudPolicy
Erteilt Erstellungs-, Lese-, Aktualisierungs- und Löschberechtigungen für eine Amazon DynamoDB-Tabelle.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:DeleteItem",
"dynamodb:PutItem",
"dynamodb:Scan",
"dynamodb:Query",
"dynamodb:UpdateItem",
"dynamodb:BatchWriteItem",
"dynamodb:BatchGetItem",
"dynamodb:DescribeTable",
"dynamodb:ConditionCheckItem"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
]
}
]
```
## DynamoDBReadPolicy
Erteilt einer DynamoDB-Tabelle nur Leseberechtigungen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:Scan",
"dynamodb:Query",
"dynamodb:BatchGetItem",
"dynamodb:DescribeTable"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
]
}
]
```
## DynamoDBReconfigurePolicy
Erteilt die Erlaubnis, eine DynamoDB-Tabelle neu zu konfigurieren.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:UpdateTable"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBRestoreFromBackupPolicy
Erteilt die Erlaubnis, eine DynamoDB-Tabelle aus einem Backup wiederherzustellen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:RestoreTableFromBackup"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/backup/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:BatchWriteItem"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBStreamReadPolicy
Erlaubt das Beschreiben und Lesen von DynamoDB-Streams und -Datensätzen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:DescribeStream",
"dynamodb:GetRecords",
"dynamodb:GetShardIterator"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/stream/${streamName}",
{
"tableName": {
"Ref": "TableName"
},
"streamName": {
"Ref": "StreamName"
}
}
]
}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:ListStreams"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/stream/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBWritePolicy
Erteilt nur Schreibberechtigungen für eine DynamoDB-Tabelle.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:BatchWriteItem"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
]
}
]
```
## EC2CopyImagePolicy
Erteilt die Erlaubnis, EC2 Amazon-Bilder zu kopieren.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CopyImage"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ec2:${AWS::Region}:${AWS::AccountId}:image/${imageId}",
{
"imageId": {
"Ref": "ImageId"
}
}
]
}
}
]
```
## EC2DescribePolicy
Erteilt die Erlaubnis, Amazon Elastic Compute Cloud (Amazon EC2) -Instances zu beschreiben.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeRegions",
"ec2:DescribeInstances"
],
"Resource": "*"
}
]
```
## EcsRunTaskPolicy
Erteilt die Erlaubnis, eine neue Aufgabe für eine Aufgabendefinition zu starten.
```
"Statement": [
{
"Action": [
"ecs:RunTask"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ecs:${AWS::Region}:${AWS::AccountId}:task-definition/${taskDefinition}",
{
"taskDefinition": {
"Ref": "TaskDefinition"
}
}
]
},
"Effect": "Allow"
}
]
```
## EFSWriteAccessPolicy
Erteilt die Erlaubnis, ein Amazon EFS-Dateisystem mit Schreibzugriff zu mounten.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticfilesystem:ClientMount",
"elasticfilesystem:ClientWrite"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticfilesystem:${AWS::Region}:${AWS::AccountId}:file-system/${FileSystem}",
{
"FileSystem": {
"Ref": "FileSystem"
}
}
]
},
"Condition": {
"StringEquals": {
"elasticfilesystem:AccessPointArn": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticfilesystem:${AWS::Region}:${AWS::AccountId}:access-point/${AccessPoint}",
{
"AccessPoint": {
"Ref": "AccessPoint"
}
}
]
}
}
}
}
]
```
## EKSDescribePolicy
Erteilt die Erlaubnis, Amazon Elastic Kubernetes Service (Amazon EKS) -Cluster zu beschreiben oder aufzulisten.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"eks:DescribeCluster",
"eks:ListClusters"
],
"Resource": "*"
}
]
```
## ElasticMapReduceAddJobFlowStepsPolicy
Erteilt die Erlaubnis, einem laufenden Cluster neue Schritte hinzuzufügen.
```
"Statement": [
{
"Action": "elasticmapreduce:AddJobFlowSteps",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceCancelStepsPolicy
Erteilt die Erlaubnis, einen oder mehrere ausstehende Schritte in einem laufenden Cluster abzubrechen.
```
"Statement": [
{
"Action": "elasticmapreduce:CancelSteps",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceModifyInstanceFleetPolicy
Erteilt die Erlaubnis, Details für Instance-Flotten innerhalb eines Clusters aufzulisten und Kapazitäten zu ändern.
```
"Statement": [
{
"Action": [
"elasticmapreduce:ModifyInstanceFleet",
"elasticmapreduce:ListInstanceFleets"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceModifyInstanceGroupsPolicy
Erteilt die Erlaubnis, Details aufzulisten und Einstellungen für Instanzgruppen innerhalb eines Clusters zu ändern.
```
"Statement": [
{
"Action": [
"elasticmapreduce:ModifyInstanceGroups",
"elasticmapreduce:ListInstanceGroups"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceSetTerminationProtectionPolicy
Erteilt die Erlaubnis, den Kündigungsschutz für einen Cluster festzulegen.
```
"Statement": [
{
"Action": "elasticmapreduce:SetTerminationProtection",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceTerminateJobFlowsPolicy
Erteilt die Erlaubnis, einen Cluster herunterzufahren.
```
"Statement": [
{
"Action": "elasticmapreduce:TerminateJobFlows",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticsearchHttpPostPolicy
Erteilt Amazon OpenSearch Service die POST- und PUT-Berechtigungen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"es:ESHttpPost",
"es:ESHttpPut"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:es:${AWS::Region}:${AWS::AccountId}:domain/${domainName}/*",
{
"domainName": {
"Ref": "DomainName"
}
}
]
}
}
]
```
## EventBridgePutEventsPolicy
Erteilt die Erlaubnis, Ereignisse an Amazon zu senden EventBridge.
```
"Statement": [
{
"Effect": "Allow",
"Action": "events:PutEvents",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:events:${AWS::Region}:${AWS::AccountId}:event-bus/${eventBusName}",
{
"eventBusName": {
"Ref": "EventBusName"
}
}
]
}
}
]
```
## FilterLogEventsPolicy
Erteilt die Erlaubnis, CloudWatch Log-Ereignisse aus einer bestimmten Protokollgruppe zu filtern.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:FilterLogEvents"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:logs:${AWS::Region}:${AWS::AccountId}:log-group:${logGroupName}:log-stream:*",
{
"logGroupName": {
"Ref": "LogGroupName"
}
}
]
}
}
]
```
## FirehoseCrudPolicy
Erteilt die Erlaubnis, einen Firehose-Lieferstream zu erstellen, zu schreiben, zu aktualisieren und zu löschen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"firehose:CreateDeliveryStream",
"firehose:DeleteDeliveryStream",
"firehose:DescribeDeliveryStream",
"firehose:PutRecord",
"firehose:PutRecordBatch",
"firehose:UpdateDestination"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:firehose:${AWS::Region}:${AWS::AccountId}:deliverystream/${deliveryStreamName}",
{
"deliveryStreamName": {
"Ref": "DeliveryStreamName"
}
}
]
}
}
]
```
## FirehoseWritePolicy
Erteilt die Erlaubnis, in einen Firehose-Lieferstream zu schreiben.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"firehose:PutRecord",
"firehose:PutRecordBatch"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:firehose:${AWS::Region}:${AWS::AccountId}:deliverystream/${deliveryStreamName}",
{
"deliveryStreamName": {
"Ref": "DeliveryStreamName"
}
}
]
}
}
]
```
## KinesisCrudPolicy
Erteilt die Erlaubnis, einen Amazon Kinesis Kinesis-Stream zu erstellen, zu veröffentlichen und zu löschen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:AddTagsToStream",
"kinesis:CreateStream",
"kinesis:DecreaseStreamRetentionPeriod",
"kinesis:DeleteStream",
"kinesis:DescribeStream",
"kinesis:DescribeStreamSummary",
"kinesis:GetShardIterator",
"kinesis:IncreaseStreamRetentionPeriod",
"kinesis:ListTagsForStream",
"kinesis:MergeShards",
"kinesis:PutRecord",
"kinesis:PutRecords",
"kinesis:SplitShard",
"kinesis:RemoveTagsFromStream"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/${streamName}",
{
"streamName": {
"Ref": "StreamName"
}
}
]
}
}
]
```
## KinesisStreamReadPolicy
Erteilt die Erlaubnis, einen Amazon Kinesis Kinesis-Stream aufzulisten und zu lesen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:ListStreams",
"kinesis:DescribeLimits"
],
"Resource": {
"Fn::Sub": "arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/*"
}
},
{
"Effect": "Allow",
"Action": [
"kinesis:DescribeStream",
"kinesis:DescribeStreamSummary",
"kinesis:GetRecords",
"kinesis:GetShardIterator"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/${streamName}",
{
"streamName": {
"Ref": "StreamName"
}
}
]
}
}
]
```
## KMSDecryptPolicy
Erteilt die Erlaubnis zum Entschlüsseln mit einem AWS Key Management Service (AWS KMS) -Schlüssel. Beachten Sie, dass es sich um eine AWS KMS Schlüssel-ID und nicht um einen Schlüsselalias handeln `keyId` muss.
```
"Statement": [
{
"Action": "kms:Decrypt",
"Effect": "Allow",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kms:${AWS::Region}:${AWS::AccountId}:key/${keyId}",
{
"keyId": {
"Ref": "KeyId"
}
}
]
}
}
]
```
## KMSEncryptPolicy
Erteilt die Erlaubnis, mit einem AWS KMS Schlüssel zu verschlüsseln. Beachten Sie, dass KeyID eine AWS KMS Schlüssel-ID und kein Schlüsselalias sein muss.
```
"Statement": [
{
"Action": "kms:Encrypt",
"Effect": "Allow",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kms:${AWS::Region}:${AWS::AccountId}:key/${keyId}",
{
"keyId": {
"Ref": "KeyId"
}
}
]
}
}
]
```
## LambdaInvokePolicy
Erteilt die Erlaubnis, eine AWS Lambda Funktion, einen Alias oder eine Version aufzurufen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:lambda:${AWS::Region}:${AWS::AccountId}:function:${functionName}*",
{
"functionName": {
"Ref": "FunctionName"
}
}
]
}
}
]
```
## MobileAnalyticsWriteOnlyAccessPolicy
Erteilt Schreibzugriff zum Speichern von Ereignisdaten für alle Anwendungsressourcen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"mobileanalytics:PutEvents"
],
"Resource": "*"
}
]
```
## OrganizationsListAccountsPolicy
Erlaubt die Nur-Lese-Berechtigung zum Auflisten der Kontonamen von Kindern und. IDs
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"organizations:ListAccounts"
],
"Resource": "*"
}
]
```
## PinpointEndpointAccessPolicy
Erteilt die Erlaubnis, Endpunkte für eine Amazon Pinpoint Pinpoint-Anwendung abzurufen und zu aktualisieren.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"mobiletargeting:GetEndpoint",
"mobiletargeting:UpdateEndpoint",
"mobiletargeting:UpdateEndpointsBatch"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:mobiletargeting:${AWS::Region}:${AWS::AccountId}:apps/${pinpointApplicationId}/endpoints/*",
{
"pinpointApplicationId": {
"Ref": "PinpointApplicationId"
}
}
]
}
}
]
```
## PollyFullAccessPolicy
Gewährt vollen Zugriff auf Amazon Polly Polly-Lexikonressourcen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"polly:GetLexicon",
"polly:DeleteLexicon"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:polly:${AWS::Region}:${AWS::AccountId}:lexicon/${lexiconName}",
{
"lexiconName": {
"Ref": "LexiconName"
}
}
]
}
]
},
{
"Effect": "Allow",
"Action": [
"polly:DescribeVoices",
"polly:ListLexicons",
"polly:PutLexicon",
"polly:SynthesizeSpeech"
],
"Resource": [
{
"Fn::Sub": "arn:${AWS::Partition}:polly:${AWS::Region}:${AWS::AccountId}:lexicon/*"
}
]
}
]
```
## RekognitionDetectOnlyPolicy
Erteilt die Erlaubnis, Gesichter, Beschriftungen und Text zu erkennen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:DetectFaces",
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels",
"rekognition:DetectText"
],
"Resource": "*"
}
]
```
## RekognitionFacesManagementPolicy
Erlaubt das Hinzufügen, Löschen und Suchen von Gesichtern in einer Amazon Rekognition Rekognition-Sammlung.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:IndexFaces",
"rekognition:DeleteFaces",
"rekognition:SearchFaces",
"rekognition:SearchFacesByImage",
"rekognition:ListFaces"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## RekognitionFacesPolicy
Erlaubt das Vergleichen und Erkennen von Gesichtern und Beschriftungen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:CompareFaces",
"rekognition:DetectFaces"
],
"Resource": "*"
}
]
```
## RekognitionLabelsPolicy
Erteilt die Erlaubnis, Objekt- und Moderationsbezeichnungen zu erkennen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels"
],
"Resource": "*"
}
]
```
## RekognitionNoDataAccessPolicy
Erlaubt das Vergleichen und Erkennen von Gesichtern und Labels.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:CompareFaces",
"rekognition:DetectFaces",
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## RekognitionReadPolicy
Erlaubt das Auflisten und Suchen von Gesichtern.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:ListCollections",
"rekognition:ListFaces",
"rekognition:SearchFaces",
"rekognition:SearchFacesByImage"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## RekognitionWriteOnlyAccessPolicy
Erteilt die Erlaubnis, Gesichter in einer Sammlung zu erstellen und zu indexieren.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:CreateCollection",
"rekognition:IndexFaces"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## Route53ChangeResourceRecordSetsPolicy
Erteilt die Erlaubnis, Ressourcendatensätze in Route 53 zu ändern.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"route53:ChangeResourceRecordSets"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:route53:::hostedzone/${HostedZoneId}",
{
"HostedZoneId": {
"Ref": "HostedZoneId"
}
}
]
}
}
]
```
## S3CrudPolicy
Erteilt Erstellungs-, Lese-, Aktualisierungs- und Löschberechtigungen, um auf die Objekte in einem Amazon S3 S3-Bucket zu reagieren.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:GetBucketLocation",
"s3:GetObjectVersion",
"s3:PutObject",
"s3:PutObjectAcl",
"s3:GetLifecycleConfiguration",
"s3:PutLifecycleConfiguration",
"s3:DeleteObject"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## S3FullAccessPolicy
Erteilt die volle Zugriffsberechtigung, um auf die Objekte in einem Amazon S3 S3-Bucket zu reagieren.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectAcl",
"s3:GetObjectVersion",
"s3:PutObject",
"s3:PutObjectAcl",
"s3:DeleteObject",
"s3:DeleteObjectTagging",
"s3:DeleteObjectVersionTagging",
"s3:GetObjectTagging",
"s3:GetObjectVersionTagging",
"s3:PutObjectTagging",
"s3:PutObjectVersionTagging"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketLocation",
"s3:GetLifecycleConfiguration",
"s3:PutLifecycleConfiguration"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## S3ReadPolicy
Erteilt nur Leseberechtigungen zum Lesen von Objekten in einem Amazon Simple Storage Service (Amazon S3) -Bucket.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:GetBucketLocation",
"s3:GetObjectVersion",
"s3:GetLifecycleConfiguration"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## S3WritePolicy
Erteilt Schreibberechtigungen zum Schreiben von Objekten in einen Amazon S3 S3-Bucket.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:PutObjectAcl",
"s3:PutLifecycleConfiguration"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## SageMakerCreateEndpointConfigPolicy
Erteilt die Erlaubnis, eine Endpunktkonfiguration in SageMaker AI zu erstellen.
```
"Statement": [
{
"Action": [
"sagemaker:CreateEndpointConfig"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sagemaker:${AWS::Region}:${AWS::AccountId}:endpoint-config/${endpointConfigName}",
{
"endpointConfigName": {
"Ref": "EndpointConfigName"
}
}
]
},
"Effect": "Allow"
}
]
```
## SageMakerCreateEndpointPolicy
Erteilt die Erlaubnis, einen Endpunkt in SageMaker KI zu erstellen.
```
"Statement": [
{
"Action": [
"sagemaker:CreateEndpoint"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sagemaker:${AWS::Region}:${AWS::AccountId}:endpoint/${endpointName}",
{
"endpointName": {
"Ref": "EndpointName"
}
}
]
},
"Effect": "Allow"
}
]
```
## ServerlessRepoReadWriteAccessPolicy
Erteilt die Erlaubnis, Anwendungen im Dienst AWS Serverless Application Repository (AWS SAM) zu erstellen und aufzulisten.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"serverlessrepo:CreateApplication",
"serverlessrepo:CreateApplicationVersion",
"serverlessrepo:GetApplication",
"serverlessrepo:ListApplications",
"serverlessrepo:ListApplicationVersions"
],
"Resource": [
{
"Fn::Sub": "arn:${AWS::Partition}:serverlessrepo:${AWS::Region}:${AWS::AccountId}:applications/*"
}
]
}
]
```
## SESBulkTemplatedCrudPolicy
Erteilt die Erlaubnis, Amazon SES SES-E-Mails, E-Mail-Vorlagen und Massen-E-Mails mit Vorlagen zu senden und die Identität zu überprüfen.
**Anmerkung**
Für die `ses:SendTemplatedEmail` Aktion ist ein Template-ARN erforderlich. Verwenden Sie stattdessen `SESBulkTemplatedCrudPolicy_v2`.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:GetIdentityVerificationAttributes",
"ses:SendEmail",
"ses:SendRawEmail",
"ses:SendTemplatedEmail",
"ses:SendBulkTemplatedEmail",
"ses:VerifyEmailIdentity"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
}
}
]
```
## SESBulkTemplatedCrudPolicy\$1v2
Erteilt die Erlaubnis, Amazon SES SES-E-Mails, E-Mail-Vorlagen und Massen-E-Mails mit Vorlagen zu senden und die Identität zu überprüfen.
```
"Statement": [
{
"Action": [
"ses:SendEmail",
"ses:SendRawEmail",
"ses:SendTemplatedEmail",
"ses:SendBulkTemplatedEmail"
],
"Effect": "Allow",
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:template/${templateName}",
{
"templateName": {
"Ref": "TemplateName"
}
}
]
}
]
},
{
"Action": [
"ses:GetIdentityVerificationAttributes",
"ses:VerifyEmailIdentity"
],
"Effect": "Allow",
"Resource": "*"
}
]
```
## SESCrudPolicy
Erteilt die Erlaubnis, E-Mails zu senden und die Identität zu überprüfen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:GetIdentityVerificationAttributes",
"ses:SendEmail",
"ses:SendRawEmail",
"ses:VerifyEmailIdentity"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
}
}
]
```
## SESEmailTemplateCrudPolicy
Erteilt die Erlaubnis, Amazon SES SES-E-Mail-Vorlagen zu erstellen, abzurufen, aufzulisten, zu aktualisieren und zu löschen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:CreateTemplate",
"ses:GetTemplate",
"ses:ListTemplates",
"ses:UpdateTemplate",
"ses:DeleteTemplate",
"ses:TestRenderTemplate"
],
"Resource": "*"
}
]
```
## SESSendBouncePolicy
SendBounce Erteilt die Erlaubnis für eine Amazon Simple Email Service (Amazon SES) -Identität.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:SendBounce"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
}
}
]
```
## SNSCrudPolicy
Erteilt die Erlaubnis, Amazon SNS SNS-Themen zu erstellen, zu veröffentlichen und zu abonnieren.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sns:ListSubscriptionsByTopic",
"sns:CreateTopic",
"sns:SetTopicAttributes",
"sns:Subscribe",
"sns:Publish"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sns:${AWS::Region}:${AWS::AccountId}:${topicName}*",
{
"topicName": {
"Ref": "TopicName"
}
}
]
}
}
]
```
## SNSPublishMessagePolicy
Erteilt die Erlaubnis, eine Nachricht zu einem Amazon Simple Notification Service (Amazon SNS) -Thema zu veröffentlichen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sns:Publish"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sns:${AWS::Region}:${AWS::AccountId}:${topicName}",
{
"topicName": {
"Ref": "TopicName"
}
}
]
}
}
]
```
## SQSPollerPolicy
Erteilt die Erlaubnis, eine Amazon Simple Queue Service (Amazon SQS) -Warteschlange abzufragen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sqs:ChangeMessageVisibility",
"sqs:ChangeMessageVisibilityBatch",
"sqs:DeleteMessage",
"sqs:DeleteMessageBatch",
"sqs:GetQueueAttributes",
"sqs:ReceiveMessage"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sqs:${AWS::Region}:${AWS::AccountId}:${queueName}",
{
"queueName": {
"Ref": "QueueName"
}
}
]
}
}
]
```
## SQSSendMessagePolicy
Erteilt die Erlaubnis, Nachrichten an eine Amazon SQS SQS-Warteschlange zu senden.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sqs:SendMessage*"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sqs:${AWS::Region}:${AWS::AccountId}:${queueName}",
{
"queueName": {
"Ref": "QueueName"
}
}
]
}
}
]
```
## SSMParameterReadPolicy
Erteilt die Erlaubnis, auf einen Parameter aus einem Amazon EC2 Systems Manager (SSM) -Parameterspeicher zuzugreifen, um Geheimnisse in dieses Konto zu laden. Wird verwendet, wenn der Parametername kein Schrägstrich-Präfix hat.
**Anmerkung**
Wenn Sie keinen Standardschlüssel verwenden, benötigen Sie auch die `KMSDecryptPolicy` Richtlinie.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:DescribeParameters"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ssm:GetParameters",
"ssm:GetParameter",
"ssm:GetParametersByPath"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ssm:${AWS::Region}:${AWS::AccountId}:parameter/${parameterName}",
{
"parameterName": {
"Ref": "ParameterName"
}
}
]
}
}
]
```
## SSMParameterWithSlashPrefixReadPolicy
Erteilt die Erlaubnis, auf einen Parameter aus einem Amazon EC2 Systems Manager (SSM) -Parameterspeicher zuzugreifen, um Geheimnisse in dieses Konto zu laden. Wird verwendet, wenn der Parametername ein Schrägstrich-Präfix hat.
**Anmerkung**
Wenn Sie keinen Standardschlüssel verwenden, benötigen Sie auch die `KMSDecryptPolicy` Richtlinie.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:DescribeParameters"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ssm:GetParameters",
"ssm:GetParameter",
"ssm:GetParametersByPath"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ssm:${AWS::Region}:${AWS::AccountId}:parameter${parameterName}",
{
"parameterName": {
"Ref": "ParameterName"
}
}
]
}
}
]
```
## StepFunctionsExecutionPolicy
Erteilt die Erlaubnis, die Ausführung einer Step Functions Functions-Zustandsmaschine zu starten.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"states:StartExecution"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:states:${AWS::Region}:${AWS::AccountId}:stateMachine:${stateMachineName}",
{
"stateMachineName": {
"Ref": "StateMachineName"
}
}
]
}
}
]
```
## TextractDetectAnalyzePolicy
Ermöglicht den Zugriff auf die Erkennung und Analyse von Dokumenten mit Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:DetectDocumentText",
"textract:StartDocumentTextDetection",
"textract:StartDocumentAnalysis",
"textract:AnalyzeDocument"
],
"Resource": "*"
}
]
```
## TextractGetResultPolicy
Ermöglicht den Zugriff auf erkannte und analysierte Dokumente von Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:GetDocumentTextDetection",
"textract:GetDocumentAnalysis"
],
"Resource": "*"
}
]
```
## TextractPolicy
Gewährt vollen Zugriff auf Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:*"
],
"Resource": "*"
}
]
```
## VPCAccessPolicy
Ermöglicht das Erstellen, Löschen, Beschreiben und Trennen von Elastic Network-Schnittstellen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DeleteNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DetachNetworkInterface"
],
"Resource": "*"
}
]
```
# Verwaltung von AWS SAM Berechtigungen mit CloudFormation Mechanismen
Um den Zugriff auf AWS Ressourcen zu kontrollieren, kann AWS Serverless Application Model (AWS SAM) dieselben Mechanismen verwenden wie. CloudFormation Weitere Informationen finden Sie unter [Steuern des Zugriffs mit AWS Identity and Access Management](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) im *Benutzerhandbuch für AWS CloudFormation *.
Es gibt drei Hauptoptionen, um einem Benutzer die Berechtigung zur Verwaltung serverloser Anwendungen zu erteilen. Jede Option bietet Benutzern unterschiedliche Stufen der Zugriffskontrolle.
+ Gewähren Sie Administratorrechte.
+ Hängen Sie die erforderlichen AWS verwalteten Richtlinien an.
+ Erteilen Sie spezifische AWS Identity and Access Management (IAM-) Berechtigungen.
Je nachdem, welche Option Sie wählen, können Benutzer nur serverlose Anwendungen verwalten, die AWS Ressourcen enthalten, für deren Zugriff sie berechtigt sind.
In den folgenden Abschnitten werden die einzelnen Optionen ausführlicher beschrieben.
## Gewähren Sie Administratorrechte
Wenn Sie einem Benutzer Administratorrechte gewähren, kann er serverlose Anwendungen verwalten, die eine beliebige Kombination von AWS Ressourcen enthalten. Dies ist die einfachste Option, gewährt Benutzern jedoch auch die umfassendsten Berechtigungen, sodass sie Aktionen mit der größten Wirkung ausführen können.
Weitere Informationen zum Erteilen von Administratorberechtigungen für einen Benutzer finden Sie unter [Erstellen Ihres ersten IAM-Administratorbenutzers und Ihrer ersten Gruppe](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) im *IAM-Benutzerhandbuch*.
## Fügen Sie die erforderlichen verwalteten Richtlinien AWS hinzu
Sie können Benutzern mithilfe [AWS verwalteter Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) eine Teilmenge von Berechtigungen gewähren, anstatt ihnen vollständige Administratorrechte zu gewähren. Wenn Sie diese Option verwenden, stellen Sie sicher, dass der Satz AWS verwalteter Richtlinien alle Aktionen und Ressourcen abdeckt, die für die serverlosen Anwendungen erforderlich sind, die die Benutzer verwalten.
Die folgenden AWS verwalteten Richtlinien reichen beispielsweise aus, um [die Hello World-Beispielanwendung bereitzustellen](serverless-getting-started-hello-world.md):
+ AWSCloudFormationFullAccess
+ IAMFullZugriff
+ AWSLambda\$1FullAccess
+ APIGatewayAmazon-Administrator
+ Amazon S3 FullAccess
+ Amazon EC2 ContainerRegistryFullAccess
Informationen zum Anhängen von Richtlinien an einen IAM-Benutzer finden Sie unter [Ändern der Berechtigungen für einen IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html) im *IAM-Benutzerhandbuch*.
## Erteilen Sie bestimmte IAM-Berechtigungen
[Für eine möglichst detaillierte Zugriffskontrolle können Sie Benutzern mithilfe von Richtlinienanweisungen bestimmte IAM-Berechtigungen gewähren.](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_statement.html) Wenn Sie diese Option verwenden, stellen Sie sicher, dass die Richtlinienanweisung alle Aktionen und Ressourcen enthält, die für die serverlosen Anwendungen erforderlich sind, die die Benutzer verwalten.
Die bewährte Methode bei dieser Option besteht darin, Benutzern die Berechtigung zum Erstellen von Rollen zu verweigern, einschließlich Lambda-Ausführungsrollen, sodass sie sich keine eskalierten Berechtigungen gewähren können. Sie als Administrator müssen also zunächst eine [Lambda-Ausführungsrolle](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) erstellen, die in den serverlosen Anwendungen angegeben wird, die Benutzer verwalten werden. Informationen zum Erstellen von Lambda-Ausführungsrollen finden Sie unter [Ausführungsrolle in der IAM-Konsole erstellen](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html#permissions-executionrole-console).
Für die [Hello World-Beispielanwendung **AWSLambdaBasicExecutionRole**](serverless-getting-started-hello-world.md)reicht es aus, die Anwendung auszuführen. Nachdem Sie eine Lambda-Ausführungsrolle erstellt haben, ändern Sie die AWS SAM Vorlagendatei der Hello World-Beispielanwendung, um der `AWS::Serverless::Function` Ressource die folgende Eigenschaft hinzuzufügen:
```
Role: lambda-execution-role-arn
```
Sobald die geänderte Hello World-Anwendung installiert ist, gewährt die folgende Richtlinienerklärung Benutzern ausreichende Berechtigungen, um die Anwendung bereitzustellen, zu aktualisieren und zu löschen:
**Anmerkung**
Die Beispielrichtlinie in diesem Abschnitt gewährt Ihnen ausreichende Berechtigungen, um die [Hello World-Beispielanwendung](serverless-getting-started-hello-world.md) bereitzustellen, zu aktualisieren und zu löschen. Wenn Sie Ihrer Anwendung zusätzliche Ressourcentypen hinzufügen, müssen Sie die Richtlinienerklärung so aktualisieren, dass sie Folgendes enthält:
Erlaubnis für Ihre Anwendung, die Aktionen des Dienstes aufzurufen.
Der Dienstprinzipal, falls er für die Aktionen des Dienstes benötigt wird.
Wenn Sie beispielsweise einen Step Functions-Workflow hinzufügen, müssen Sie möglicherweise Berechtigungen für die [hier](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsstepfunctions.html#awsstepfunctions-actions-as-permissions) aufgeführten Aktionen und den `states.amazonaws.com` Dienstprinzipal hinzufügen.
Weitere Informationen zu IAM-Richtlinien finden Sie unter [Verwaltung von IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html) im *IAM-Benutzerhandbuch*.
# Kontrollieren Sie den API-Zugriff mit Ihrer AWS SAM Vorlage
Durch die Steuerung des Zugriffs auf Ihr API Gateway wird APIs sichergestellt, dass Ihre serverlose Anwendung sicher ist und nur mit der von Ihnen aktivierten Autorisierung darauf zugegriffen werden kann. Sie können die Autorisierung in Ihrer AWS SAM Vorlage aktivieren, um zu kontrollieren, wer auf Ihr API Gateway zugreifen kann APIs.
AWS SAM unterstützt mehrere Mechanismen zur Steuerung des Zugriffs auf Ihr API Gateway APIs. Die unterstützten Mechanismen unterscheiden `AWS::Serverless::HttpApi` sich je nach `AWS::Serverless::Api` Ressourcentyp.
In der folgenden Tabelle sind die Mechanismen zusammengefasst, die von den einzelnen Ressourcentypen unterstützt werden.
| Mechanismen zur Zugriffskontrolle | AWS::Serverless::HttpApi | AWS::Serverless::Api |
| --- | --- | --- |
| Lambda-Autorisierer | ✓ | ✓ |
| IAM-Berechtigungen | | ✓ |
| Amazon-Cognito-Benutzerpools | ✓ \$1 | ✓ |
| API-Schlüssel | | ✓ |
| Ressourcenrichtlinien | | ✓ |
| OAuth 2.0/JWT-Autorisierer | ✓ | |
\$1 Sie können Amazon Cognito als Aussteller von JSON Web Token (JWT) mit dem `AWS::Serverless::HttpApi` Ressourcentyp verwenden.
+ **Lambda-Autorisierer** — Ein Lambda-Autorisierer (früher bekannt als *benutzerdefinierter Autorisierer*) ist eine Lambda-Funktion, die Sie bereitstellen, um den Zugriff auf Ihre API zu kontrollieren. Wenn Ihre API aufgerufen wird, wird diese Lambda-Funktion mit einem Anforderungskontext oder einem Autorisierungstoken aufgerufen, das die Client-Anwendung bereitstellt. Die Lambda-Funktion gibt an, ob der Aufrufer berechtigt ist, den angeforderten Vorgang auszuführen.
`AWS::Serverless::HttpApi`Sowohl der Ressourcentyp als auch der `AWS::Serverless::Api` Ressourcentyp unterstützen Lambda-Autorisierer.
*Weitere Informationen zu Lambda-Autorisierern mit finden Sie unter [Arbeiten mit `AWS::Serverless::HttpApi`AWS Lambda Autorisierern für HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-lambda-authorizer.html) im API Gateway Developer Guide.* *Weitere Informationen zu Lambda-Autorisierern mit `AWS::Serverless::Api` finden Sie unter [Verwenden von API Gateway-Lambda-Autorisierern im API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) Developer Guide.*
Beispiele für Lambda-Autorisierer für beide Ressourcentypen finden Sie unter. [Beispiele für Lambda-Autorisierer für AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md)
+ **IAM-Berechtigungen** [— Sie können mithilfe von (IAM-) Berechtigungen steuern, wer Ihre API AWS Identity and Access Management aufrufen kann.](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_controlling.html) Benutzer, die Ihre API aufrufen, müssen mit IAM-Anmeldeinformationen authentifiziert werden. Aufrufe Ihrer API sind nur erfolgreich, wenn dem IAM-Benutzer eine IAM-Richtlinie zugeordnet ist, die den API-Aufrufer repräsentiert, eine IAM-Gruppe, die den Benutzer enthält, oder eine IAM-Rolle, die der Benutzer annimmt.
Nur der `AWS::Serverless::Api` Ressourcentyp unterstützt IAM-Berechtigungen.
Weitere Informationen finden Sie unter [Steuern des Zugriffs auf eine API mit IAM-Berechtigungen](https://docs.aws.amazon.com/apigateway/latest/developerguide/permissions.html) im *API Gateway Developer Guide*. Ein Beispiel finden Sie unter [Beispiel für eine IAM-Berechtigung für AWS SAM](serverless-controlling-access-to-apis-permissions.md).
+ **Amazon Cognito-Benutzerpools** — Amazon Cognito Cognito-Benutzerpools sind Benutzerverzeichnisse in Amazon Cognito. Ein Client Ihrer API muss zuerst einen Benutzer beim Benutzerpool anmelden und ein Identitäts- oder Zugriffstoken für den Benutzer erhalten. Dann ruft der Client Ihre API mit einem der zurückgegebenen Token auf. Der API-Aufruf ist nur erfolgreich, wenn das erforderliche Token gültig ist.
Der `AWS::Serverless::Api` Ressourcentyp unterstützt Amazon Cognito Cognito-Benutzerpools. Der `AWS::Serverless::HttpApi` Ressourcentyp unterstützt die Verwendung von Amazon Cognito als JWT-Emittenten.
Weitere Informationen finden Sie unter [Control access to a REST API using Amazon cognito user pools as authorizer](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) (Zugriff auf eine REST-API mit Amazon-Cognito-Benutzerpools als Autorisierer) im *Entwicklerhandbuch von API Gateway*. Ein Beispiel finden Sie unter [Beispiel für einen Amazon Cognito Cognito-Benutzerpool für AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md).
+ **API-Schlüssel** — API-Schlüssel sind alphanumerische Zeichenkettenwerte, die Sie an Kunden von Anwendungsentwicklern verteilen, um Zugriff auf Ihre API zu gewähren.
Nur der `AWS::Serverless::Api` Ressourcentyp unterstützt API-Schlüssel.
Weitere Informationen zu API-Schlüsseln finden Sie unter [Nutzungspläne mit API-Schlüsseln erstellen und verwenden](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) im *API Gateway Developer Guide*. Ein Beispiel für API-Schlüssel finden Sie unter[Beispiel für einen API-Schlüssel AWS SAM](serverless-controlling-access-to-apis-keys.md).
+ **Ressourcenrichtlinien** — Ressourcenrichtlinien sind JSON-Richtliniendokumente, die Sie an eine API Gateway anhängen können. Verwenden Sie Ressourcenrichtlinien, um zu steuern, ob ein bestimmter Prinzipal (normalerweise ein IAM-Benutzer oder eine IAM-Rolle) die API aufrufen kann.
Nur der `AWS::Serverless::Api` Ressourcentyp unterstützt Ressourcenrichtlinien als Mechanismus zur Steuerung des Zugriffs auf API Gateway APIs.
Weitere Informationen zu Ressourcenrichtlinien finden Sie unter [Steuern des Zugriffs auf eine API mit API-Gateway-Ressourcenrichtlinien](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) im *API Gateway Developer Guide*. Ein Beispiel für Ressourcenrichtlinien finden Sie unter[Beispiel für eine Ressourcenrichtlinie für AWS SAM](serverless-controlling-access-to-apis-resource-policies.md).
+ **OAuth 2.0/JWT-Autorisierer** [— Sie können sie JWTs als Teil der [OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) - und OAuth 2.0-Frameworks verwenden, um den Zugriff auf Ihre zu kontrollieren.](https://oauth.net/2/) APIs API Gateway validiert die JWTs , die Clients mit API-Anfragen einreichen, und erlaubt oder lehnt Anfragen auf der Grundlage der Tokenvalidierung und optional der Bereiche im Token ab.
Nur der `AWS::Serverless::HttpApi` Ressourcentyp unterstützt OAuth 2.0/JWT-Autorisierer.
Weitere Informationen finden Sie unter [Steuern des Zugriffs auf HTTP APIs mit JWT-Autorisierern](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) im *API Gateway* Developer Guide. Ein Beispiel finden Sie unter [OAuth 2.0/JWT-Autorisierungsbeispiel für AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md).
## Auswahl eines Mechanismus zur Zugriffskontrolle
Der Mechanismus, den Sie für die Steuerung des Zugriffs auf Ihr API Gateway verwenden, APIs hängt von einigen Faktoren ab. Wenn Sie beispielsweise ein Projekt auf der grünen Wiese haben, für das weder Autorisierung noch Zugriffskontrolle eingerichtet sind, sind Amazon Cognito Cognito-Benutzerpools möglicherweise die beste Option. Das liegt daran, dass Sie bei der Einrichtung von Benutzerpools auch automatisch sowohl die Authentifizierung als auch die Zugriffskontrolle einrichten.
Wenn für Ihre Anwendung jedoch bereits eine Authentifizierung eingerichtet ist, ist die Verwendung von Lambda-Autorisierern möglicherweise die beste Option. Dies liegt daran, dass Sie Ihren bestehenden Authentifizierungsdienst anrufen und auf der Grundlage der Antwort ein Richtliniendokument zurücksenden können. Wenn Ihre Anwendung eine benutzerdefinierte Authentifizierungs- oder Zugriffskontrolllogik erfordert, die Benutzerpools nicht unterstützen, sind Lambda-Autorisierer möglicherweise die beste Option.
Wenn Sie den zu verwendenden Mechanismus ausgewählt haben, finden Sie im entsprechenden Abschnitt unter Informationen AWS SAM zur Konfiguration Ihrer Anwendung [Beispiele](#serverless-controlling-access-to-apis-examples) für die Verwendung dieses Mechanismus.
## Anpassen von Fehlerantworten
Sie können AWS SAM damit den Inhalt einiger API-Gateway-Fehlerantworten anpassen. Nur der `AWS::Serverless::Api` Ressourcentyp unterstützt benutzerdefinierte API-Gateway-Antworten.
Weitere Informationen zu API-Gateway-Antworten finden Sie unter [Gateway-Antworten in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) im *API Gateway Developer Guide*. Ein Beispiel für benutzerdefinierte Antworten finden Sie unter[Beispiel für eine benutzerdefinierte Antwort für AWS SAM](serverless-controlling-access-to-apis-customize-response.md).
## Beispiele
+ [Beispiele für Lambda-Autorisierer für AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md)
+ [Beispiel für eine IAM-Berechtigung für AWS SAM](serverless-controlling-access-to-apis-permissions.md)
+ [Beispiel für einen Amazon Cognito Cognito-Benutzerpool für AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md)
+ [Beispiel für einen API-Schlüssel AWS SAM](serverless-controlling-access-to-apis-keys.md)
+ [Beispiel für eine Ressourcenrichtlinie für AWS SAM](serverless-controlling-access-to-apis-resource-policies.md)
+ [OAuth 2.0/JWT-Autorisierungsbeispiel für AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md)
+ [Beispiel für eine benutzerdefinierte Antwort für AWS SAM](serverless-controlling-access-to-apis-customize-response.md)
# Beispiele für Lambda-Autorisierer für AWS SAM
Der `AWS::Serverless::Api` Ressourcentyp unterstützt zwei Arten von Lambda-Autorisierern: Autorisierer und `TOKEN` Autorisierer. `REQUEST` Der Ressourcentyp unterstützt nur Autorisierer. `AWS::Serverless::HttpApi` `REQUEST` Im Folgenden finden Sie Beispiele für jeden Typ.
## Beispiel für einen `TOKEN` Lambda-Authorizer () AWS::Serverless::Api
Sie können den Zugriff auf Ihre steuern, APIs indem Sie in Ihrer AWS SAM Vorlage einen `TOKEN` Lambda-Autorisierer definieren. Dazu verwenden Sie den [ApiAuth](sam-property-api-apiauth.md) Datentyp.
Im Folgenden finden Sie ein Beispiel für einen AWS SAM Vorlagenabschnitt für einen `TOKEN` Lambda-Autorisierer:
**Anmerkung**
Im folgenden Beispiel wird das SAM implizit `FunctionRole` generiert.
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaTokenAuthorizer
Authorizers:
MyLambdaTokenAuthorizer:
FunctionArn: !GetAtt MyAuthFunction.Arn
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
*Weitere Informationen zu Lambda-Autorisierern finden Sie unter [Verwenden von API Gateway-Lambda-Autorisierern im API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) Developer Guide.*
## Beispiel für einen `REQUEST` Lambda-Authorizer () AWS::Serverless::Api
Sie können den Zugriff auf Ihre steuern, APIs indem Sie in Ihrer AWS SAM Vorlage einen `REQUEST` Lambda-Autorisierer definieren. Dazu verwenden Sie den [ApiAuth](sam-property-api-apiauth.md) Datentyp.
Im Folgenden finden Sie ein Beispiel für einen AWS SAM Vorlagenabschnitt für einen `REQUEST` Lambda-Autorisierer:
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaRequestAuthorizer
Authorizers:
MyLambdaRequestAuthorizer:
FunctionPayloadType: REQUEST
FunctionArn: !GetAtt MyAuthFunction.Arn
Identity:
QueryStrings:
- auth
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
*Weitere Informationen zu Lambda-Autorisierern finden Sie unter [Verwenden von API Gateway-Lambda-Autorisierern im API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) Developer Guide.*
## Beispiel für einen Lambda-Authorizer () AWS::Serverless::HttpApi
Sie können den Zugriff auf Ihr HTTP steuern, APIs indem Sie in Ihrer AWS SAM Vorlage einen Lambda-Authorizer definieren. Dazu verwenden Sie den [HttpApiAuth](sam-property-httpapi-httpapiauth.md) Datentyp.
Im Folgenden finden Sie ein Beispiel für einen AWS SAM Vorlagenabschnitt für einen Lambda-Autorisierer:
```
Resources:
MyApi:
Type: AWS::Serverless::HttpApi
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaRequestAuthorizer
Authorizers:
MyLambdaRequestAuthorizer:
FunctionArn: !GetAtt MyAuthFunction.Arn
FunctionInvokeRole: !GetAtt MyAuthFunctionRole.Arn
Identity:
Headers:
- Authorization
AuthorizerPayloadFormatVersion: 2.0
EnableSimpleResponses: true
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: HttpApi
Properties:
ApiId: !Ref MyApi
Path: /
Method: get
PayloadFormatVersion: "2.0"
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
# Beispiel für eine IAM-Berechtigung für AWS SAM
Sie können den Zugriff auf Ihre steuern, APIs indem Sie IAM-Berechtigungen in Ihrer AWS SAM Vorlage definieren. Dazu verwenden Sie den [ApiAuth](sam-property-api-apiauth.md) Datentyp.
Im Folgenden finden Sie eine AWS SAM Beispielvorlage, die für IAM-Berechtigungen verwendet wird:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Description: 'API with IAM authorization'
Auth:
DefaultAuthorizer: AWS_IAM #sets AWS_IAM auth for all methods in this API
MyFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.10
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
InlineCode: |
def handler(event, context):
return {'body': 'Hello World!', 'statusCode': 200}
```
Weitere Informationen zu IAM-Berechtigungen finden Sie unter [Zugriffskontrolle für das Aufrufen einer API im API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html) *Gateway Developer Guide*.
# Beispiel für einen Amazon Cognito Cognito-Benutzerpool für AWS SAM
Sie können den Zugriff auf Ihre steuern, APIs indem Sie Amazon Cognito Cognito-Benutzerpools in Ihrer AWS SAM Vorlage definieren. Dazu verwenden Sie den [ApiAuth](sam-property-api-apiauth.md) Datentyp.
Im Folgenden finden Sie ein Beispiel für einen AWS SAM Vorlagenabschnitt für einen Benutzerpool:
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Cors: "'*'"
Auth:
DefaultAuthorizer: MyCognitoAuthorizer
Authorizers:
MyCognitoAuthorizer:
UserPoolArn: !GetAtt MyCognitoUserPool.Arn
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: lambda.handler
Runtime: nodejs12.x
Events:
Root:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: GET
MyCognitoUserPool:
Type: AWS::Cognito::UserPool
Properties:
UserPoolName: !Ref CognitoUserPoolName
Policies:
PasswordPolicy:
MinimumLength: 8
UsernameAttributes:
- email
Schema:
- AttributeDataType: String
Name: email
Required: false
MyCognitoUserPoolClient:
Type: AWS::Cognito::UserPoolClient
Properties:
UserPoolId: !Ref MyCognitoUserPool
ClientName: !Ref CognitoUserPoolClientName
GenerateSecret: false
```
Weitere Informationen zu Amazon Cognito Cognito-Benutzerpools finden Sie unter [Steuern des Zugriffs auf eine REST-API mithilfe von Amazon Cognito Cognito-Benutzerpools als Autorisierer](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) im *API Gateway* Developer Guide.
# Beispiel für einen API-Schlüssel AWS SAM
Sie können den Zugriff auf Ihre steuern, APIs indem Sie API-Schlüssel in Ihrer AWS SAM Vorlage angeben. Dazu verwenden Sie den [ApiAuth](sam-property-api-apiauth.md) Datentyp.
Im Folgenden finden Sie ein Beispiel für einen AWS SAM Vorlagenabschnitt für API-Schlüssel:
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
ApiKeyRequired: true # sets for all methods
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: index.handler
Runtime: nodejs12.x
Events:
ApiKey:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
Auth:
ApiKeyRequired: true
```
Weitere Informationen zu API-Schlüsseln finden Sie unter [Nutzungspläne mit API-Schlüsseln erstellen und verwenden](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) im *API Gateway Developer Guide*.
# Beispiel für eine Ressourcenrichtlinie für AWS SAM
Sie können den Zugriff auf Ihre steuern, APIs indem Sie Ihrer AWS SAM Vorlage eine Ressourcenrichtlinie anhängen. Dazu verwenden Sie den [ApiAuth](sam-property-api-apiauth.md) Datentyp.
Im Folgenden finden Sie eine AWS SAM Beispielvorlage für eine private API. Eine private API muss über eine Ressourcenrichtlinie verfügen, damit sie bereitgestellt werden kann.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyPrivateApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
EndpointConfiguration: PRIVATE # Creates a private API. Resource policies are required for all private APIs.
Auth:
ResourcePolicy:
CustomStatements:
- Effect: 'Allow'
Action: 'execute-api:Invoke'
Resource: ['execute-api:/*/*/*']
Principal: '*'
- Effect: 'Deny'
Action: 'execute-api:Invoke'
Resource: ['execute-api:/*/*/*']
Principal: '*'
MyFunction:
Type: 'AWS::Serverless::Function'
Properties:
InlineCode: |
def handler(event, context):
return {'body': 'Hello World!', 'statusCode': 200}
Handler: index.handler
Runtime: python3.10
Events:
AddItem:
Type: Api
Properties:
RestApiId:
Ref: MyPrivateApi
Path: /
Method: get
```
Weitere Informationen zu Ressourcenrichtlinien finden Sie unter [Steuern des Zugriffs auf eine API mit API-Gateway-Ressourcenrichtlinien](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) im *API Gateway Developer Guide*. Weitere Informationen zu Private APIs finden Sie unter [Creating a private API in Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-apis.html) im *API Gateway Developer Guide*.
# OAuth 2.0/JWT-Autorisierungsbeispiel für AWS SAM
[Sie können den Zugriff auf Ihre APIs Nutzung JWTs als Teil der Frameworks [OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) und OAuth 2.0 kontrollieren.](https://oauth.net/2/) Dazu verwenden Sie den Datentyp. [HttpApiAuth](sam-property-httpapi-httpapiauth.md)
Im Folgenden finden Sie ein Beispiel für einen AWS SAM Vorlagenabschnitt für einen OAuth 2.0/JWT-Authorizer:
```
Resources:
MyApi:
Type: AWS::Serverless::HttpApi
Properties:
Auth:
Authorizers:
MyOauth2Authorizer:
AuthorizationScopes:
- scope
IdentitySource: $request.header.Authorization
JwtConfiguration:
audience:
- audience1
- audience2
issuer: "https://www.example.com/v1/connect/oidc"
DefaultAuthorizer: MyOauth2Authorizer
StageName: Prod
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Events:
GetRoot:
Properties:
ApiId: MyApi
Method: get
Path: /
PayloadFormatVersion: "2.0"
Type: HttpApi
Handler: index.handler
Runtime: nodejs12.x
```
*Weitere Informationen zu OAuth 2.0/JWT-Autorisierern finden Sie unter [Steuern des Zugriffs auf HTTP APIs mit JWT-Autorisierern](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) im API Gateway Developer Guide.*
# Beispiel für eine benutzerdefinierte Antwort für AWS SAM
Sie können einige API-Gateway-Fehlerantworten anpassen, indem Sie Antwortheader in Ihrer AWS SAM Vorlage definieren. Dazu verwenden Sie den Datentyp [Gateway Response Object](https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#gateway-response-object).
Im Folgenden finden Sie eine AWS SAM Beispielvorlage, die eine benutzerdefinierte Antwort für den `DEFAULT_5XX` Fehler erstellt.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
GatewayResponses:
DEFAULT_5XX:
ResponseParameters:
Headers:
Access-Control-Expose-Headers: "'WWW-Authenticate'"
Access-Control-Allow-Origin: "'*'"
ErrorHeader: "'MyCustomErrorHeader'"
ResponseTemplates:
application/json: "{\"message\": \"Error on the $context.resourcePath resource\" }"
GetFunction:
Type: AWS::Serverless::Function
Properties:
Runtime: python3.10
Handler: index.handler
InlineCode: |
def handler(event, context):
raise Exception('Check out the new response!')
Events:
GetResource:
Type: Api
Properties:
Path: /error
Method: get
RestApiId: !Ref MyApi
```
Weitere Informationen zu API-Gateway-Antworten finden Sie unter [Gateway-Antworten in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) im *API Gateway Developer Guide*.
# Steigern Sie die Effizienz mithilfe von Lambda-Schichten mit AWS SAM
Mithilfe von AWS SAM können Sie Ebenen in Ihre serverlosen Anwendungen einbeziehen. AWS Lambda Ebenen ermöglichen es Ihnen, Code aus einer Lambda-Funktion in eine Lambda-Schicht zu extrahieren, die dann für mehrere Lambda-Funktionen verwendet werden kann. Auf diese Weise können Sie die Größe Ihrer Bereitstellungspakete reduzieren, die Logik der Kernfunktionen von Abhängigkeiten trennen und Abhängigkeiten für mehrere Funktionen gemeinsam nutzen. Weitere Informationen zu Layern finden Sie unter [Lambda-Schichten](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) im *AWS Lambda Developer Guide*.
Dieses Thema enthält Informationen zu folgenden Themen:
+ Ebenen in Ihre Anwendung einbeziehen
+ Wie werden Ebenen lokal zwischengespeichert
Informationen zum Erstellen von benutzerdefinierten Layern finden Sie unter[Aufbau von Lambda-Schichten in AWS SAM](building-layers.md).
## Ebenen in Ihre Anwendung einbeziehen
Verwenden Sie die `Layers` Eigenschaft des [AWS::Serverless::Function](sam-resource-function.md) Ressourcentyps, um Ebenen in Ihre Anwendung aufzunehmen.
Im Folgenden finden Sie eine AWS SAM Beispielvorlage mit einer Lambda-Funktion, die eine Ebene enthält:
```
ServerlessFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: my_handler
Runtime: Python3.7
Layers:
-
```
## Wie werden Ebenen lokal zwischengespeichert
Wenn Sie Ihre Funktion mit einem der `sam local` Befehle aufrufen, wird das Layer-Paket Ihrer Funktion heruntergeladen und auf Ihrem lokalen Host zwischengespeichert.
Die folgende Tabelle zeigt die Standard-Cache-Verzeichnisspeicherorte für verschiedene Betriebssysteme.
****
| BS | Speicherort |
| --- | --- |
| Windows 7 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| Windows 8 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| Windows 10 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| macOS | \$1/.aws-sam/layers-pkg |
| Unix | \$1/.aws-sam/layers-pkg |
Nachdem das Paket zwischengespeichert wurde, werden die Ebenen auf ein Docker-Image AWS SAMCLI überlagert, das zum Aufrufen Ihrer Funktion verwendet wird. Das AWS SAMCLI generiert die Namen der Bilder, die es erstellt, sowie der Bilder, LayerVersions die im Cache gespeichert sind. Weitere Informationen zum Schema finden Sie in den folgenden Abschnitten.
Um die überlagerten Ebenen zu untersuchen, führen Sie den folgenden Befehl aus, um eine Bash-Sitzung in dem Bild zu starten, das Sie untersuchen möchten:
```
docker run -it --entrypoint=/bin/bash samcli/lambda: -i
```
**Layer-Caching: Namensschema für Verzeichnisse**
Bei gegebener LayerVersionArn Angabe, die in Ihrer Vorlage definiert ist, AWS SAMCLI extrahiert das die LayerName und Version aus dem ARN. Es erstellt ein Verzeichnis, in dem der Layer-Inhalt abgelegt wird`LayerName-Version-`.
Beispiel:
```
ARN = arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1
Directory name = myLayer-1-926eeb5ff1
```
**Tag-Schema für Docker Images**
Um den eindeutigen Layer-Hash zu berechnen, kombinieren Sie alle eindeutigen Layer-Namen mit dem Trennzeichen '-', nehmen Sie den SHA256 Hash und dann die ersten 10 Zeichen.
Beispiel:
```
ServerlessFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: my_handler
Runtime: Python3.7
Layers:
- arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1
- arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1
```
Eindeutige Namen werden genauso berechnet wie das Namensschema für das Layer-Caching-Verzeichnis:
```
arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1 = myLayer-1-926eeb5ff1
arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1 = mySecondLayer-1-6bc1022bdf
```
Um den eindeutigen Layer-Hash zu berechnen, kombinieren Sie alle eindeutigen Layer-Namen mit dem Trennzeichen '-', nehmen Sie den SHA256-Hash und dann die ersten 25 Zeichen:
```
myLayer-1-926eeb5ff1-mySecondLayer-1-6bc1022bdf = 2dd7ac5ffb30d515926aef
```
Kombinieren Sie dann diesen Wert mit der Laufzeit und Architektur der Funktion mit dem Trennzeichen '-':
```
python3.7-x86_64-2dd7ac5ffb30d515926aefffd
```
# Verwenden Sie Code und Ressourcen mithilfe verschachtelter Anwendungen in AWS SAM
Eine serverlose Anwendung kann eine oder mehrere **verschachtelte** Anwendungen enthalten. Eine verschachtelte Anwendung ist Teil einer größeren Anwendung und kann entweder als eigenständiges Artefakt oder als Komponente einer größeren Anwendung gepackt und bereitgestellt werden. Verschachtelte Anwendungen ermöglichen es Ihnen, häufig verwendeten Code in eine eigene Anwendung umzuwandeln, die dann in einer größeren serverlosen Anwendung oder mehreren serverlosen Anwendungen wiederverwendet werden kann.
Wenn Ihre serverlosen Architekturen wachsen, entstehen in der Regel allgemeine Muster, bei denen dieselben Komponenten in mehreren Anwendungsvorlagen definiert sind. Verschachtelte Anwendungen ermöglichen es Ihnen, gemeinsamen Code, Funktionen, Ressourcen und Konfigurationen in separaten AWS SAM Vorlagen wiederzuverwenden, sodass Sie nur Code aus einer einzigen Quelle verwalten müssen. Dadurch werden doppelter Code und Konfigurationen reduziert. Darüber hinaus optimiert dieser modulare Ansatz die Entwicklung, verbessert die Codeorganisation und erleichtert die Konsistenz serverloser Anwendungen. Mit verschachtelten Anwendungen können Sie sich mehr auf die Geschäftslogik konzentrieren, die für Ihre Anwendung einzigartig ist.
Verwenden Sie den Ressourcentyp, um eine verschachtelte Anwendung in Ihrer serverlosen Anwendung zu definieren. [AWS::Serverless::Application](sam-resource-application.md)
Sie können verschachtelte Anwendungen aus den folgenden zwei Quellen definieren:
+ Eine **AWS Serverless Application Repository Anwendung** — Sie können verschachtelte Anwendungen definieren, indem Sie Anwendungen verwenden, die für Ihr Konto in verfügbar sind. AWS Serverless Application Repository Dies können *private* Anwendungen in Ihrem Konto sein, Anwendungen, die *privat mit Ihrem Konto geteilt* werden, oder Anwendungen, die *öffentlich in der AWS Serverless Application Repository geteilt* werden. Weitere Informationen zu den verschiedenen Stufen der Bereitstellungsberechtigungen finden Sie unter [Berechtigungen zur Anwendungsbereitstellung](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#application-deployment-permissions) und [Veröffentlichung von Anwendungen](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-publishing-applications.html) im *AWS Serverless Application Repository Entwicklerhandbuch*.
+ Eine **lokale Anwendung** — Sie können verschachtelte Anwendungen definieren, indem Sie Anwendungen verwenden, die in Ihrem lokalen Dateisystem gespeichert sind.
In den folgenden Abschnitten finden Sie Einzelheiten AWS SAM zur Definition dieser beiden Arten von verschachtelten Anwendungen in Ihrer serverlosen Anwendung.
**Anmerkung**
Die maximale Anzahl von Anwendungen, die in einer serverlosen Anwendung verschachtelt werden können, beträgt 200.
Die maximale Anzahl von Parametern, die eine verschachtelte Anwendung haben kann, beträgt 60.
## Definition einer verschachtelten Anwendung aus dem AWS Serverless Application Repository
Sie können verschachtelte Anwendungen definieren, indem Sie Anwendungen verwenden, die in der verfügbar sind. AWS Serverless Application Repository Sie können Anwendungen, die verschachtelte Anwendungen enthalten, auch mithilfe von speichern und verteilen. AWS Serverless Application Repository Um die Details einer verschachtelten Anwendung in der zu überprüfen AWS Serverless Application Repository, können Sie das AWS SDK, die oder die AWS CLI Lambda-Konsole verwenden.
Um eine Anwendung zu definieren, die AWS Serverless Application Repository in der AWS SAM Vorlage Ihrer serverlosen Anwendung gehostet wird, klicken Sie auf der Detailseite jeder Anwendung auf die Schaltfläche **Als SAM-Ressource kopieren**. AWS Serverless Application Repository Führen Sie dazu die folgenden Schritte aus:
1. Stellen Sie sicher, dass Sie bei der angemeldet sind. AWS-Managementkonsole
1. Suchen Sie die Anwendung, in der Sie sich verschachteln möchten, AWS Serverless Application Repository indem Sie die Schritte im Abschnitt „[Anwendungen durchsuchen, suchen und bereitstellen](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#browse-and-search-applications )“ des *AWS Serverless Application Repository Entwicklerhandbuchs* ausführen.
1. Wählen Sie die Schaltfläche **Als SAM-Ressource kopieren**. Der SAM-Vorlagenbereich für die Anwendung, die Sie gerade ansehen, befindet sich jetzt in Ihrer Zwischenablage.
1. Fügen Sie den Abschnitt mit der SAM-Vorlage in den `Resources:` Abschnitt der SAM-Vorlagendatei für die Anwendung ein, die Sie in dieser Anwendung verschachteln möchten.
Im Folgenden finden Sie ein Beispiel für einen SAM-Vorlagenabschnitt für eine verschachtelte Anwendung, die AWS Serverless Application Repository in folgender Datei gehostet wird:
```
Transform: AWS::Serverless-2016-10-31
Resources:
applicationaliasname:
Type: AWS::Serverless::Application
Properties:
Location:
ApplicationId: arn:aws:serverlessrepo:us-east-1:123456789012:applications/application-alias-name
SemanticVersion: 1.0.0
Parameters:
# Optional parameter that can have default value overridden
# ParameterName1: 15 # Uncomment to override default value
# Required parameter that needs value to be provided
ParameterName2: YOUR_VALUE
```
Wenn keine Parametereinstellungen erforderlich sind, können Sie den `Parameters:` Abschnitt der Vorlage weglassen.
**Wichtig**
Anwendungen, die verschachtelte Anwendungen enthalten, die in der gehostet werden, AWS Serverless Application Repository übernehmen die Freigabebeschränkungen der verschachtelten Anwendungen.
Nehmen wir beispielsweise an, eine Anwendung ist öffentlich freigegeben, sie enthält jedoch eine verschachtelte Anwendung, die nur privat mit dem AWS Konto geteilt wird, mit dem die übergeordnete Anwendung erstellt wurde. In diesem Fall können Sie die übergeordnete Anwendung nicht bereitstellen, wenn Ihr AWS Konto nicht berechtigt ist, die verschachtelte Anwendung bereitzustellen. Weitere Informationen zu Berechtigungen für die Bereitstellung von Anwendungen finden Sie unter [Berechtigungen zur Anwendungsbereitstellung](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#application-deployment-permissions) und [Veröffentlichung von Anwendungen](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-publishing-applications.html) im *AWS Serverless Application Repository Entwicklerhandbuch*.
## Definieren einer verschachtelten Anwendung aus dem lokalen Dateisystem
Sie können verschachtelte Anwendungen definieren, indem Sie Anwendungen verwenden, die in Ihrem lokalen Dateisystem gespeichert sind. Dazu geben Sie den Pfad zur AWS SAM Vorlagendatei an, die in Ihrem lokalen Dateisystem gespeichert ist.
Im Folgenden finden Sie ein Beispiel für einen SAM-Vorlagenabschnitt für eine verschachtelte lokale Anwendung:
```
Transform: AWS::Serverless-2016-10-31
Resources:
applicationaliasname:
Type: AWS::Serverless::Application
Properties:
Location: ../my-other-app/template.yaml
Parameters:
# Optional parameter that can have default value overridden
# ParameterName1: 15 # Uncomment to override default value
# Required parameter that needs value to be provided
ParameterName2: YOUR_VALUE
```
Wenn es keine Parametereinstellungen gibt, können Sie den `Parameters:` Abschnitt der Vorlage weglassen.
## Bereitstellen verschachtelter Anwendungen
Sie können Ihre verschachtelte Anwendung mithilfe des AWS SAMCLI Befehls bereitstellen. `sam deploy` Weitere Details finden Sie unter [Stellen Sie Ihre Anwendung und Ressourcen bereit mit AWS SAM](serverless-deploying.md).
**Anmerkung**
Wenn Sie eine Anwendung bereitstellen, die verschachtelte Anwendungen enthält, müssen Sie bestätigen, dass sie verschachtelte Anwendungen enthält. Sie tun dies, indem Sie `CAPABILITY_AUTO_EXPAND` es an die [CreateCloudFormationChangeSet API](https://docs.aws.amazon.com/goto/WebAPI/serverlessrepo-2017-09-08/CreateCloudFormationChangeSet) übergeben oder den [https://docs.aws.amazon.com/cli/latest/reference/serverlessrepo/create-cloud-formation-change-set.html](https://docs.aws.amazon.com/cli/latest/reference/serverlessrepo/create-cloud-formation-change-set.html) AWS CLI Befehl verwenden.
*Weitere Informationen zur Bestätigung verschachtelter Anwendungen finden Sie unter [Bestätigung von IAM-Rollen, Ressourcenrichtlinien und verschachtelten Anwendungen bei der Bereitstellung von Anwendungen](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/acknowledging-application-capabilities.html) im Entwicklerhandbuch.AWS Serverless Application Repository *
# Verwalten Sie zeitbasierte Ereignisse mit dem EventBridge Scheduler in AWS SAM
Der Inhalt dieses Themas enthält Informationen darüber, was Amazon EventBridge Scheduler ist, was Support AWS SAM bietet, wie Sie Scheduler-Ereignisse erstellen können, und Beispiele, auf die Sie beim Erstellen von Scheduler-Ereignissen zurückgreifen können.
## Was ist Amazon EventBridge Scheduler?
Verwenden Sie EventBridge Scheduler, um Ereignisse in Ihren AWS SAM Vorlagen zu planen. Amazon EventBridge Scheduler ist ein Planungsservice, mit dem Sie zig Millionen Ereignisse und Aufgaben für alle AWS Services erstellen, initiieren und verwalten können. Dieser Service ist besonders nützlich für zeitbezogene Ereignisse. Sie können ihn verwenden, um Ereignisse und wiederkehrende zeitbasierte Aufrufe zu planen. Es unterstützt auch einmalige Ereignisse sowie Rate- und Chron-Ausdrücke mit Start- und Endzeit.
Weitere Informationen zu Amazon EventBridge Scheduler finden Sie unter [Was ist Amazon EventBridge Scheduler](https://docs.aws.amazon.com/scheduler/latest/UserGuide/what-is-scheduler.html)? im *EventBridge Scheduler-Benutzerhandbuch*.
**Topics**
+ [Was ist Amazon EventBridge Scheduler?](#using-eventbridge-scheduler-intro)
+ [EventBridge Scheduler-Unterstützung in AWS SAM](#using-eventbridge-scheduler-sam-support)
+ [EventBridge Scheduler-Ereignisse erstellen in AWS SAM](#using-eventbridge-scheduler-sam-create)
+ [Beispiele](#using-eventbridge-scheduler-examples)
+ [Weitere Informationen](#using-eventbridge-scheduler-learn)
## EventBridge Scheduler-Unterstützung in AWS SAM
Die Vorlagenspezifikation AWS Serverless Application Model (AWS SAM) bietet eine einfache Kurzsyntax, die Sie verwenden können, um Ereignisse mit dem EventBridge Scheduler für und zu planen. AWS Lambda AWS Step Functions
## EventBridge Scheduler-Ereignisse erstellen in AWS SAM
Legen Sie die `ScheduleV2` Eigenschaft in Ihrer AWS SAM Vorlage als Ereignistyp fest, um Ihr EventBridge Scheduler-Ereignis zu definieren. Diese Eigenschaft unterstützt die `AWS::Serverless::StateMachine` Ressourcentypen `AWS::Serverless::Function` und.
```
MyFunction:
Type: AWS::Serverless::Function
Properties:
Events:
CWSchedule:
Type: ScheduleV2
Properties:
ScheduleExpression: 'rate(1 minute)'
Name: TestScheduleV2Function
Description: Test schedule event
MyStateMachine:
Type: AWS::Serverless::StateMachine
Properties:
Events:
CWSchedule:
Type: ScheduleV2
Properties:
ScheduleExpression: 'rate(1 minute)'
Name: TestScheduleV2StateMachine
Description: Test schedule event
```
EventBridge Die Scheduler-Ereignisplanung unterstützt auch *Dead-Letter-Warteschlangen (DLQ*) für unverarbeitete Ereignisse. *Weitere Informationen zu Warteschlangen mit uneingeschränkten Briefen finden Sie im Scheduler-Benutzerhandbuch unter [Konfiguration einer Warteschlange für unzustellbare Nachrichten für Scheduler](https://docs.aws.amazon.com/scheduler/latest/UserGuide/configuring-schedule-dlq.html). EventBridge EventBridge *
Wenn ein DLQ-ARN angegeben ist, werden die Berechtigungen für den Scheduler-Zeitplan zum Senden von Nachrichten an den DLQ AWS SAM konfiguriert. Wenn kein DLQ-ARN angegeben ist, AWS SAM wird die DLQ-Ressource erstellt.
## Beispiele
### Einfaches Beispiel für die Definition eines EventBridge Scheduler-Ereignisses mit AWS SAM
```
Transform: AWS::Serverless-2016-10-31
Resources:
MyLambdaFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.8
InlineCode: |
def handler(event, context):
print(event)
return {'body': 'Hello World!', 'statusCode': 200}
MemorySize: 128
Events:
Schedule:
Type: ScheduleV2
Properties:
ScheduleExpression: rate(1 minute)
Input: '{"hello": "simple"}'
MySFNFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.8
InlineCode: |
def handler(event, context):
print(event)
return {'body': 'Hello World!', 'statusCode': 200}
MemorySize: 128
StateMachine:
Type: AWS::Serverless::StateMachine
Properties:
Type: STANDARD
Definition:
StartAt: MyLambdaState
States:
MyLambdaState:
Type: Task
Resource: !GetAtt MySFNFunction.Arn
End: true
Policies:
- LambdaInvokePolicy:
FunctionName: !Ref MySFNFunction
Events:
Schedule:
Type: ScheduleV2
Properties:
ScheduleExpression: rate(1 minute)
Input: '{"hello": "simple"}'
```
## Weitere Informationen
Weitere Informationen zur Definition der `ScheduleV2` EventBridge Scheduler-Eigenschaft finden Sie unter:
+ [ScheduleV2](sam-property-function-schedulev2.md)für`AWS::Serverless::Function`.
+ [ScheduleV2](sam-property-statemachine-statemachineschedulev2.md)für`AWS::Serverless::StateMachine`.
# Orchestrierung von AWS SAM Ressourcen mit AWS Step Functions
Sie können [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/)es verwenden, um AWS Lambda Funktionen und andere AWS Ressourcen zu orchestrieren, um komplexe und robuste Workflows zu erstellen. Step Functions, um Ihrer Anwendung mitzuteilen, wann und unter welchen Bedingungen Ihre AWS Ressourcen, wie AWS Lambda Funktionen, verwendet werden. Dies vereinfacht den Prozess der Erstellung komplexer und robuster Workflows. Mit [AWS::Serverless::StateMachine](sam-resource-statemachine.md) dieser Methode definieren Sie die einzelnen Schritte in Ihrem Workflow, ordnen jedem Schritt Ressourcen zu und ordnen diese Schritte dann zusammen. Außerdem fügen Sie dort, wo sie benötigt werden, Übergänge und Bedingungen hinzu. Dies vereinfacht den Prozess der Erstellung eines komplexen und robusten Workflows.
**Anmerkung**
Um AWS SAM Vorlagen zu verwalten, die Step Functions Functions-Zustandsmaschinen enthalten, müssen Sie Version 0.52.0 oder höher von verwenden. AWS SAMCLI Um zu überprüfen, welche Version Sie haben, führen Sie den Befehl `sam --version` aus.
Step Functions basiert auf den Konzepten von [Aufgaben](https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-task-state.html) und [Zustandsmaschinen](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-states.html). Sie definieren Zustandsmaschinen mithilfe der JSON-basierten [Amazon States-Sprache.](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html) Die [Step Functions Functions-Konsole](https://console.aws.amazon.com/states/home?region=us-east-1#/) zeigt eine grafische Ansicht der Struktur Ihrer Zustandsmaschine an, sodass Sie die Logik Ihrer Zustandsmaschine visuell überprüfen und Ausführungen überwachen können.
Mit der Unterstützung von Step Functions in AWS Serverless Application Model (AWS SAM) können Sie Folgendes tun:
+ Definieren Sie Zustandsmaschinen, entweder direkt in einer AWS SAM Vorlage oder in einer separaten Datei
+ Erstellen Sie Rollen für die Ausführung von Zustandsmaschinen mithilfe von AWS SAM Richtlinienvorlagen, Inline-Richtlinien oder verwalteten Richtlinien
+ Triggern Sie State-Machine-Ausführungen mit API Gateway- oder EventBridge Amazon-Ereignissen, nach einem Zeitplan innerhalb einer AWS SAM Vorlage oder durch direkten Aufruf APIs
+ Verwenden Sie verfügbare [AWS SAM Richtlinienvorlagen](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-policy-templates.html) für allgemeine Step Functions Functions-Entwicklungsmuster.
## Beispiel
Der folgende Beispielausschnitt aus einer AWS SAM Vorlagendatei definiert eine Step Functions Functions-Zustandsmaschine in einer Definitionsdatei. Beachten Sie, dass die `my_state_machine.asl.json` Datei in der [Sprache der Amazon-Staaten](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html) verfasst sein muss.
```
AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
Description: Sample SAM template with Step Functions State Machine
Resources:
MyStateMachine:
Type: AWS::Serverless::StateMachine
Properties:
DefinitionUri: statemachine/my_state_machine.asl.json
...
```
Informationen zum Herunterladen einer AWS SAM Beispielanwendung, die eine Step Functions-Zustandsmaschine enthält, finden [Sie AWS SAM im AWS Step Functions Entwicklerhandbuch unter Create a Step Functions State Machine](https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-state-machine-using-sam.html) *Using*.
## Weitere Informationen
Weitere Informationen zu Step Functions und deren Verwendung mit AWS SAM finden Sie im Folgenden:
+ [Funktionsweise von AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/how-step-functions-works.html)
+ [AWS Step Functions und AWS Serverless Application Model](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-sam-sfn.html)
+ [Tutorial: Erstellen Sie eine Step Functions Functions-Zustandsmaschine mit AWS SAM](https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-state-machine-using-sam.html)
+ [AWS SAM Spezifikation: AWS::Serverless::StateMachine](sam-resource-statemachine.md)
# Richten Sie die Codesignatur für Ihre AWS SAM Anwendung ein
Um sicherzustellen, dass nur vertrauenswürdiger Code bereitgestellt wird, können Sie AWS SAM die Codesignatur für Ihre serverlosen Anwendungen aktivieren. Durch das Signieren Ihres Codes können Sie sicherstellen, dass der Code seit dem Signieren nicht geändert wurde und dass nur signierte Codepakete von vertrauenswürdigen Herausgebern in Ihren Lambda-Funktionen ausgeführt werden. Dadurch werden Unternehmen von der Last befreit, Gatekeeper-Komponenten in ihren Bereitstellungspipelines zu erstellen.
Weitere Informationen zur Codesignatur finden Sie unter [Configuring Code Signing for Lambda-Funktionen](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html) im *AWS Lambda Developer Guide*.
Bevor Sie die Codesignatur für Ihre serverlose Anwendung konfigurieren können, müssen Sie mit Signer ein Signaturprofil erstellen AWS . Sie verwenden dieses Signaturprofil für die folgenden Aufgaben:
1. **Codesignaturkonfiguration erstellen** — Deklarieren Sie eine [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html)Ressource, um die Signaturprofile vertrauenswürdiger Herausgeber anzugeben und die Richtlinienaktion für Validierungsprüfungen festzulegen. Sie können dieses Objekt in derselben AWS SAM Vorlage wie Ihre serverlose Funktion, in einer anderen AWS SAM Vorlage oder in einer CloudFormation Vorlage deklarieren. Anschließend aktivieren Sie die Codesignatur für eine serverlose Funktion, indem Sie der [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-codesigningconfigarn](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-codesigningconfigarn)Eigenschaft die Funktion mit dem Amazon-Ressourcennamen (ARN) einer [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html)Ressource angeben.
1. **Signieren Sie Ihren Code** — Verwenden Sie den [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html)Befehl [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html)oder mit der `--signing-profiles` Option.
**Anmerkung**
Um Ihren Code erfolgreich mit den `sam deploy` Befehlen `sam package` oder zu signieren, muss die Versionierung für den Amazon S3 S3-Bucket aktiviert sein, den Sie mit diesen Befehlen verwenden. Wenn Sie den Amazon S3 S3-Bucket verwenden, der für Sie AWS SAM erstellt, wird die Versionierung automatisch aktiviert. Weitere Informationen zur Amazon S3 S3-Bucket-Versionierung und Anweisungen zur Aktivierung der Versionierung in einem von Ihnen bereitgestellten Amazon S3 S3-Bucket finden Sie unter [Verwenden der Versionierung in Amazon S3 S3-Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) im *Amazon Simple Storage Service-Benutzerhandbuch*.
Wenn Sie eine serverlose Anwendung bereitstellen, führt Lambda Validierungsprüfungen für alle Funktionen durch, für die Sie die Codesignatur aktiviert haben. Lambda führt auch Validierungsprüfungen auf allen Ebenen durch, von denen diese Funktionen abhängen. Weitere Informationen zu den Validierungsprüfungen von Lambda finden Sie unter [Signaturvalidierung](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html#config-codesigning-valid) im *AWS Lambda Entwicklerhandbuch*.
## Beispiel
### Ein Signaturprofil erstellen
Führen Sie den folgenden Befehl aus, um ein Signaturprofil zu erstellen:
```
aws signer put-signing-profile --platform-id "AWSLambda-SHA384-ECDSA" --profile-name MySigningProfile
```
Wenn der vorherige Befehl erfolgreich war, wird der ARN des Signaturprofils zurückgegeben. Beispiel:
```
{
"arn": "arn:aws:signer:us-east-1:111122223333:/signing-profiles/MySigningProfile",
"profileVersion": "SAMPLEverx",
"profileVersionArn": "arn:aws:signer:us-east-1:111122223333:/signing-profiles/MySigningProfile/SAMPLEverx"
}
```
Das `profileVersionArn` Feld enthält den ARN, der verwendet werden soll, wenn Sie die Codesignaturkonfiguration erstellen.
### Eine Codesignaturkonfiguration erstellen und die Codesignatur für eine Funktion aktivieren
Die folgende AWS SAM Beispielvorlage deklariert eine [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html)Ressource und aktiviert die Codesignatur für eine Lambda-Funktion. In diesem Beispiel gibt es ein vertrauenswürdiges Profil, und Bereitstellungen werden abgelehnt, wenn die Signaturprüfungen fehlschlagen.
```
Resources:
HelloWorld:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.7
CodeSigningConfigArn: !Ref MySignedFunctionCodeSigningConfig
MySignedFunctionCodeSigningConfig:
Type: AWS::Lambda::CodeSigningConfig
Properties:
Description: "Code Signing for MySignedLambdaFunction"
AllowedPublishers:
SigningProfileVersionArns:
- MySigningProfile-profileVersionArn
CodeSigningPolicies:
UntrustedArtifactOnDeployment: "Enforce"
```
### Signieren Sie Ihren Code
Sie können Ihren Code signieren, wenn Sie Ihre Anwendung verpacken oder bereitstellen. Geben Sie die `--signing-profiles` Option entweder mit dem `sam deploy` Befehl `sam package` oder an, wie in den folgenden Beispielbefehlen gezeigt.
Signieren Sie Ihren Funktionscode beim Paketieren Ihrer Anwendung:
```
sam package --signing-profiles HelloWorld=MySigningProfile --s3-bucket amzn-s3-demo-bucket --output-template-file packaged.yaml
```
Signieren Sie beim Verpacken Ihrer Anwendung sowohl Ihren Funktionscode als auch eine Ebene, von der Ihre Funktion abhängt:
```
sam package --signing-profiles HelloWorld=MySigningProfile MyLayer=MySigningProfile --s3-bucket amzn-s3-demo-bucket --output-template-file packaged.yaml
```
Signieren Sie Ihren Funktionscode und eine Ebene und führen Sie dann eine Bereitstellung durch:
```
sam deploy --signing-profiles HelloWorld=MySigningProfile MyLayer=MySigningProfile --s3-bucket amzn-s3-demo-bucket --template-file packaged.yaml --stack-name --region us-east-1 --capabilities CAPABILITY_IAM
```
**Anmerkung**
Um Ihren Code erfolgreich mit den `sam deploy` Befehlen `sam package` oder zu signieren, muss die Versionierung für den Amazon S3 S3-Bucket aktiviert sein, den Sie mit diesen Befehlen verwenden. Wenn Sie den Amazon S3 S3-Bucket verwenden, der für Sie AWS SAM erstellt, wird die Versionierung automatisch aktiviert. Weitere Informationen zur Amazon S3 S3-Bucket-Versionierung und Anweisungen zur Aktivierung der Versionierung in einem von Ihnen bereitgestellten Amazon S3 S3-Bucket finden Sie unter [Verwenden der Versionierung in Amazon S3 S3-Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) im *Amazon Simple Storage Service-Benutzerhandbuch*.
## Bereitstellung von Signaturprofilen mit `sam deploy --guided`
Wenn Sie den `sam deploy --guided` Befehl mit einer serverlosen Anwendung ausführen, die mit Codesignatur konfiguriert ist, werden Sie AWS SAM aufgefordert, das Signaturprofil anzugeben, das für die Codesignatur verwendet werden soll. Weitere Informationen zu `sam deploy --guided` Eingabeaufforderungen finden Sie [sam deploy](sam-cli-command-reference-sam-deploy.md) in der AWS SAMCLI Befehlsreferenz.
# AWS SAM Vorlagendateien validieren
Validieren Sie Ihre Vorlagen mit`sam validate`. Derzeit überprüft dieser Befehl, ob es sich bei der bereitgestellten Vorlage um eine gültige JSON/YAML-Vorlage handelt. Wie bei den meisten AWS SAMCLI Befehlen sucht er standardmäßig nach einer `template.[yaml|yml]` Datei in Ihrem aktuellen Arbeitsverzeichnis. file/location Mit der `--template` Option `-t` oder können Sie eine andere Vorlage angeben.
Beispiel:
```
$ sam validate
/template.yaml is a valid SAM Template
```
**Anmerkung**
Für den `sam validate` Befehl müssen AWS Anmeldeinformationen konfiguriert werden. Weitere Informationen finden Sie unter [Konfiguration der AWS SAMCLI](using-sam-cli-configure.md).
# 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
```