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