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.
# Anderen AWS Entitäten Zugriff auf Ihre Lambda-Funktionen gewähren
Um anderen AWS-Konten Organisationen und Diensten Berechtigungen für den Zugriff auf Ihre Lambda-Ressourcen zu erteilen, haben Sie mehrere Möglichkeiten:
+ Sie können [identitätsbasierte Richtlinien](access-control-identity-based.md) verwenden, um anderen Benutzern Zugriff auf Ihre Lambda-Ressourcen zu gewähren. Identitätsbasierte Richtlinien können direkt auf Benutzer oder auf Gruppen und Rollen angewendet werden, die einem Benutzer zugeordnet sind.
+ Sie können [ressourcenbasierte Richtlinien](access-control-resource-based.md) verwenden, um anderen Konten und AWS-Services Berechtigungen für den Zugriff auf Ihre Lambda-Ressourcen zu gewähren. Wenn ein Benutzer versucht, auf eine Lambda-Ressource zuzugreifen, berücksichtigt Lambda sowohl die identitätsbasierten Richtlinien des Benutzers als auch die ressourcenbasierte Richtlinie der Ressource. Wenn ein AWS Service wie Amazon Simple Storage Service (Amazon S3) Ihre Lambda-Funktion aufruft, berücksichtigt Lambda nur die ressourcenbasierte Richtlinie.
+ Sie können ein [attributbasiertes Zugriffskontrollmodell (ABAC)](attribute-based-access-control.md) verwenden, um den Zugriff auf Ihre Lambda-Funktionen zu steuern. Mit ABAC können Sie Tags an eine Lambda-Funktion anhängen, sie in bestimmten API-Anforderungen übergeben oder sie an den IAM-Prinzipal anfügen, der die Anforderung stellt. Geben Sie dieselben Tags im Bedingungselement einer IAM-Richtlinie an, um den Funktionszugriff zu steuern.
Um Ihnen bei der Optimierung Ihrer Berechtigungen für den Zugriff mit den geringsten Rechten zu helfen, bietet Lambda einige zusätzliche Bedingungen, die Sie in Ihre Richtlinien aufnehmen können. Weitere Informationen finden Sie unter [Feinabstimmung der Abschnitte „Ressourcen“ und „Bedingungen“ der Richtlinien](lambda-api-permissions-ref.md).
# Identitätsbasierte IAM-Richtlinien für Lambda
Sie können identitätsbasierte Richtlinien in AWS Identity and Access Management (IAM) verwenden, um Benutzern in Ihrem Konto Zugriff auf Lambda zu gewähren. Identitätsbasierte Richtlinien können sich auf Benutzer, Benutzergruppen oder Rollen beziehen. Sie können auch Benutzern in einem anderen Konto die Berechtigung erteilen, eine Rolle in Ihrem Konto zu übernehmen und auf Ihre Lambda-Ressourcen zuzugreifen.
Lambda bietet AWS verwaltete Richtlinien, die Zugriff auf Lambda-API-Aktionen und in einigen Fällen Zugriff auf andere AWS Dienste gewähren, die zur Entwicklung und Verwaltung von Lambda-Ressourcen verwendet werden. Lambda aktualisiert je nach Bedarf die verwalteten Richtlinien, um sicherzustellen, dass Ihre Benutzer Zugriff auf neue Funktionen haben, sobald diese veröffentlicht werden.
+ [AWSLambda\$1FullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambda_FullAccess.html)— Gewährt vollen Zugriff auf Lambda-Aktionen und andere AWS Dienste, die zur Entwicklung und Wartung von Lambda-Ressourcen verwendet werden.
+ [AWSLambda\$1ReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambda_ReadOnlyAccess.html)— Gewährt schreibgeschützten Zugriff auf Lambda-Ressourcen.
+ [AWSLambdaRolle](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaRole.html) — Erteilt Berechtigungen zum Aufrufen von Lambda-Funktionen.
AWS verwaltete Richtlinien gewähren Berechtigungen für API-Aktionen, ohne die Lambda-Funktionen oder -Layer einzuschränken, die ein Benutzer ändern kann. Für eine feinere Steuerung können Sie eigene Richtlinien erstellen, die den Umfang der Berechtigungen eines Benutzers einschränken.
**Topics**
+ [Benutzern den Zugriff auf eine Lambda-Funktion gewähren](permissions-user-function.md)
+ [Benutzern den Zugriff auf eine Lambda-Ebene gewähren](permissions-user-layer.md)
# Benutzern den Zugriff auf eine Lambda-Funktion gewähren
Verwenden Sie [identitätsbasierte Richtlinien](access-control-identity-based.md), um Benutzern, Benutzergruppen oder Rollen die Durchführung von Vorgängen mit Lambda-Funktionen zu ermöglichen.
**Anmerkung**
Für eine als Container-Image definierte Funktion muss die Benutzerberechtigung für den Zugriff auf das Image in Amazon Elastic Container Registry (Amazon ECR) konfiguriert werden. Ein Beispiel finden Sie unter [Amazon ECR-Repository-Richtlinien](images-create.md#configuration-images-permissions).
Im Folgenden finden Sie ein Beispiel für eine Berechtigungsrichtlinie mit eingeschränktem Umfang. Sie ermöglicht Benutzern das Erstellen und Verwalten von Lambda-Funktionen mit einem bestimmten Präfix (`intern-`), die mit einer bestimmten Ausführungsrolle konfiguriert sind.
**Example Richtlinie für die Funktionsentwicklung**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ReadOnlyPermissions",
"Effect": "Allow",
"Action": [
"lambda:GetAccountSettings",
"lambda:GetEventSourceMapping",
"lambda:GetFunction",
"lambda:GetFunctionConfiguration",
"lambda:GetFunctionCodeSigningConfig",
"lambda:GetFunctionConcurrency",
"lambda:ListEventSourceMappings",
"lambda:ListFunctions",
"lambda:ListTags",
"iam:ListRoles"
],
"Resource": "*"
},
{
"Sid": "DevelopFunctions",
"Effect": "Allow",
"NotAction": [
"lambda:AddPermission",
"lambda:PutFunctionConcurrency"
],
"Resource": "arn:aws:lambda:*:*:function:intern-*"
},
{
"Sid": "DevelopEventSourceMappings",
"Effect": "Allow",
"Action": [
"lambda:DeleteEventSourceMapping",
"lambda:UpdateEventSourceMapping",
"lambda:CreateEventSourceMapping"
],
"Resource": "*",
"Condition": {
"ArnLike": {
"lambda:FunctionArn": "arn:aws:lambda:*:*:function:intern-*"
}
}
},
{
"Sid": "PassExecutionRole",
"Effect": "Allow",
"Action": [
"iam:ListRolePolicies",
"iam:ListAttachedRolePolicies",
"iam:GetRole",
"iam:GetRolePolicy",
"iam:PassRole",
"iam:SimulatePrincipalPolicy"
],
"Resource": "arn:aws:iam::*:role/intern-lambda-execution-role"
},
{
"Sid": "ViewLogs",
"Effect": "Allow",
"Action": [
"logs:*"
],
"Resource": "arn:aws:logs:*:*:log-group:/aws/lambda/intern-*"
}
]
}
```
Die Berechtigungen in der Richtlinie sind in Anweisungen basierend auf den [Ressourcen und Bedingungen](lambda-api-permissions-ref.md) organisiert, die sie unterstützen.
+ `ReadOnlyPermissions` – Die Lambda-Konsole verwendet diese Berechtigungen, wenn Sie Funktionen durchsuchen und anzeigen. Sie unterstützen keine Ressourcenmuster oder -bedingungen.
```
"Action": [
"lambda:GetAccountSettings",
"lambda:GetEventSourceMapping",
"lambda:GetFunction",
"lambda:GetFunctionConfiguration",
"lambda:GetFunctionCodeSigningConfig",
"lambda:GetFunctionConcurrency",
"lambda:ListEventSourceMappings",
"lambda:ListFunctions",
"lambda:ListTags",
"iam:ListRoles"
],
"Resource": "*"
```
+ `DevelopFunctions` – Verwendet eine beliebige Lambda-Aktion, die auf Funktionen mit dem Präfix `intern-` ausgeführt wird, außer `AddPermission` und `PutFunctionConcurrency`. `AddPermission` ändert die [ressourcenbasierte Richtlinie](access-control-resource-based.md) der Funktion und kann mögliche Sicherheitsprobleme darstellen. `PutFunctionConcurrency` reserviert Skalierungskapazitäten für eine Funktion und kann anderen Funktionen Kapazitäten wegnehmen.
```
"NotAction": [
"lambda:AddPermission",
"lambda:PutFunctionConcurrency"
],
"Resource": "arn:aws:lambda:*:*:function:intern-*"
```
+ `DevelopEventSourceMappings` – Verwaltet Ereignis-Quellzuweisungen für Funktionen mit dem Präfix `intern-`. Diese Aktionen werden für Ereignis-Quellzuweisungen angewendet. Sie können sie jedoch mit einer *Bedingung* nach Funktion einschränken.
```
"Action": [
"lambda:DeleteEventSourceMapping",
"lambda:UpdateEventSourceMapping",
"lambda:CreateEventSourceMapping"
],
"Resource": "*",
"Condition": {
"StringLike": {
"lambda:FunctionArn": "arn:aws:lambda:*:*:function:intern-*"
}
}
```
+ `PassExecutionRole` – Zeigt und übergibt nur eine Rolle namens `intern-lambda-execution-role`, die von einem Benutzer mit IAM-Berechtigungen erstellt und verwaltet werden muss. `PassRole` wird verwendet, wenn Sie eine Ausführungsrolle einer Funktion zuweisen.
```
"Action": [
"iam:ListRolePolicies",
"iam:ListAttachedRolePolicies",
"iam:GetRole",
"iam:GetRolePolicy",
"iam:PassRole",
"iam:SimulatePrincipalPolicy"
],
"Resource": "arn:aws:iam::*:role/intern-lambda-execution-role"
```
+ `ViewLogs`— Verwenden Sie CloudWatch Logs, um Logs für Funktionen anzuzeigen, denen das Präfix vorangestellt ist. `intern-`
```
"Action": [
"logs:*"
],
"Resource": "arn:aws:logs:*:*:log-group:/aws/lambda/intern-*"
```
Diese Richtlinie erlaubt es einem Benutzer, Lambda zu verwenden, ohne die Ressourcen anderer Benutzer zu gefährden. Es erlaubt einem Benutzer nicht, eine Funktion so zu konfigurieren, dass sie von anderen AWS Diensten ausgelöst wird oder diese aufruft, wofür umfassendere IAM-Berechtigungen erforderlich sind. Es beinhaltet auch keine Genehmigung für Dienste, die keine Richtlinien mit begrenztem Geltungsbereich unterstützen, wie X-Ray CloudWatch . Verwenden Sie die schreibgeschützten Richtlinien für diese Services, um dem Benutzer Zugriff auf Metriken und Ablaufverfolgungsdaten zu gewähren.
Wenn Sie Auslöser für Ihre Funktion konfigurieren, benötigen Sie Zugriff, um den AWS Dienst verwenden zu können, der Ihre Funktion aufruft. Wenn Sie z. B. einen Amazon-S3-Auslöser konfigurieren, müssen Sie zur Verwendung der Amazon-S3-Aktionen berechtigt sein, mit denen Bucket-Benachrichtigungen verwaltet werden. Viele dieser Berechtigungen sind in der [AWSLambda\$1FullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambda_FullAccess.html)verwalteten Richtlinie enthalten.
# Benutzern den Zugriff auf eine Lambda-Ebene gewähren
Verwenden Sie [identitätsbasierte Richtlinien](access-control-identity-based.md), um Benutzern, Benutzergruppen oder Rollen die Durchführung von Vorgängen mit Lambda-Ebenen zu ermöglichen. Die folgende Richtlinie erteilt einem Benutzer die Berechtigung, Ebenen zu erstellen und sie mit Funktionen zu verwenden. Die Ressourcenmuster ermöglichen es dem Benutzer, in jeder AWS-Region beliebigen Layer-Version zu arbeiten, sofern der Name der Ebene mit beginnt`test-`.
**Example Richtlinie für die Ebenenentwicklung**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "PublishLayers",
"Effect": "Allow",
"Action": [
"lambda:PublishLayerVersion"
],
"Resource": "arn:aws:lambda:*:*:layer:test-*"
},
{
"Sid": "ManageLayerVersions",
"Effect": "Allow",
"Action": [
"lambda:GetLayerVersion",
"lambda:DeleteLayerVersion"
],
"Resource": "arn:aws:lambda:*:*:layer:test-*:*"
}
]
}
```
Sie können die Ebenenverwendung auch bei der Erstellung und Konfiguration von Funktionen mit der `lambda:Layer`-Bedingung erzwingen. Sie können beispielsweise Benutzer daran hindern, Ebenen zu verwenden, die von anderen Konten veröffentlicht wurden. Die folgende Richtlinie fügt eine Bedingung zu den Aktionen `CreateFunction` und `UpdateFunctionConfiguration` hinzu, um zu verlangen, dass alle angegebenen Ebenen vom Konto `123456789012` stammen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ConfigureFunctions",
"Effect": "Allow",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Resource": "*",
"Condition": {
"ForAllValues:StringLike": {
"lambda:Layer": [
"arn:aws:lambda:*:123456789012:layer:*:*"
]
}
}
}
]
}
```
------
Um sicherzustellen, dass die Bedingung angewendet wird, stellen Sie sicher, dass keine anderen Anweisungen dem Benutzer die Berechtigung für diese Aktionen erteilen.
# Anzeigen von ressourcenbasierten IAM-Richtlinien in Lambda
Lambda unterstützt ressourcenbasierte Berechtigungsrichtlinien für Lambda-Funktionen und -Ebenen. Sie können ressourcenbasierte Richtlinien verwenden, um anderen [AWS Konten](permissions-function-cross-account.md), [Organisationen](permissions-function-organization.md) oder [Diensten](permissions-function-services.md) Zugriff zu gewähren. Ressourcenbasierte Richtlinien gelten für einzelne Funktionen, Versionen, Aliasnamen oder Ebenenversionen.
------
#### [ Console ]
**So zeigen Sie die ressourcenbasierte Richtlinie einer Funktion an**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie eine Funktion aus.
1. Wählen Sie **Konfiguration** und anschließend **Berechtigungen** aus.
1. Scrollen Sie nach unten zu **Ressourcenbasierte Richtlinie** und wählen Sie dann **Richtliniendokument anzeigen** aus. Die ressourcenbasierte Richtlinie zeigt die Berechtigungen, die angewendet werden, wenn ein anderes Konto oder AWS Dienst versucht, auf die Funktion zuzugreifen. Das folgende Beispiel zeigt eine Anweisung, mit der Amazon S3 eine Funktion mit dem Namen `my-function` für einen Bucket mit dem Namen `amzn-s3-demo-bucket` im Konto `123456789012` aufrufen kann.
**Example Ressourcenbasierte Richtlinie**
****
```
{
"Version":"2012-10-17",
"Id": "default",
"Statement": [
{
"Sid": "lambda-allow-s3-my-function",
"Effect": "Allow",
"Principal": {
"Service": "s3.amazonaws.com"
},
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"Condition": {
"StringEquals": {
"AWS:SourceAccount": "123456789012"
},
"ArnLike": {
"AWS:SourceArn": "arn:aws:s3:::amzn-s3-demo-bucket"
}
}
}
]
}
```
------
#### [ AWS CLI ]
Um die ressourcenbasierte Richtlinie einer Funktion anzuzeigen, verwenden Sie den Befehl `get-policy`.
```
aws lambda get-policy \
--function-name my-function \
--output text
```
Die Ausgabe sollte folgendermaßen aussehen:
****
```
{"Version":"2012-10-17", "Id":"default","Statement":[{"Sid":"sns","Effect":"Allow","Principal":{"Service":"s3.amazonaws.com"},"Action":"lambda:InvokeFunction","Resource":"arn:aws:lambda:us-east-2:123456789012:function:my-function","Condition":{"ArnLike":{"AWS:SourceArn":"arn:aws:sns:us-east-2:123456789012:lambda*"}}}]}
```
Fügen Sie bei Versionen und Aliassen die Versionsnummer oder den Alias an den Funktionsnamen an.
```
aws lambda get-policy --function-name my-function:PROD
```
Um Berechtigungen von Ihrer Funktion zu entfernen, verwenden Sie `remove-permission`.
```
aws lambda remove-permission \
--function-name example \
--statement-id sns
```
Verwenden Sie den Befehl `get-layer-version-policy`, um die Berechtigungen für einen Layer anzuzeigen.
```
aws lambda get-layer-version-policy \
--layer-name my-layer \
--version-number 3 \
--output text
```
Die Ausgabe sollte folgendermaßen aussehen:
```
b0cd9796-d4eb-4564-939f-de7fe0b42236 {"Sid":"engineering-org","Effect":"Allow","Principal":"*","Action":"lambda:GetLayerVersion","Resource":"arn:aws:lambda:us-west-2:123456789012:layer:my-layer:3","Condition":{"StringEquals":{"aws:PrincipalOrgID":"o-t194hfs8cz"}}}"
```
Verwenden Sie `remove-layer-version-permission`, um Anweisungen aus der Richtlinie zu entfernen.
```
aws lambda remove-layer-version-permission --layer-name my-layer --version-number 3 --statement-id engineering-org
```
------
## Unterstützte API-Aktionen
Die folgenden Lambda-API-Aktionen unterstützen ressourcenbasierte Richtlinien:
+ [CreateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_CreateAlias.html)
+ [DeleteAlias](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteAlias.html)
+ [DeleteFunction](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteFunction.html)
+ [DeleteFunctionConcurrency](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteFunctionConcurrency.html)
+ [DeleteFunctionEventInvokeConfig](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteFunctionEventInvokeConfig.html)
+ [DeleteProvisionedConcurrencyConfig](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteProvisionedConcurrencyConfig.html)
+ [GetAlias](https://docs.aws.amazon.com/lambda/latest/api/API_GetAlias.html)
+ [GetFunction](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html)
+ [GetFunctionConcurrency](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConcurrency.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [GetFunctionEventInvokeConfig](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionEventInvokeConfig.html)
+ [GetPolicy](https://docs.aws.amazon.com/lambda/latest/api/API_GetPolicy.html)
+ [GetProvisionedConcurrencyConfig](https://docs.aws.amazon.com/lambda/latest/api/API_GetProvisionedConcurrencyConfig.html)
+ [Invoke](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html)
+ [InvokeFunctionUrl](urls-auth.md)(nur mit Genehmigung)
+ [ListAliases](https://docs.aws.amazon.com/lambda/latest/api/API_ListAliases.html)
+ [ListFunctionEventInvokeConfigs](https://docs.aws.amazon.com/lambda/latest/api/API_ListFunctionEventInvokeConfigs.html)
+ [ListProvisionedConcurrencyConfigs](https://docs.aws.amazon.com/lambda/latest/api/API_ListProvisionedConcurrencyConfigs.html)
+ [ListTags](https://docs.aws.amazon.com/lambda/latest/api/API_ListTags.html)
+ [ListVersionsByFunction](https://docs.aws.amazon.com/lambda/latest/api/API_ListVersionsByFunction.html)
+ [PublishVersion](https://docs.aws.amazon.com/lambda/latest/api/API_PublishVersion.html)
+ [PutFunctionConcurrency](https://docs.aws.amazon.com/lambda/latest/api/API_PutFunctionConcurrency.html)
+ [PutFunctionEventInvokeConfig](https://docs.aws.amazon.com/lambda/latest/api/API_PutFunctionEventInvokeConfig.html)
+ [PutProvisionedConcurrencyConfig](https://docs.aws.amazon.com/lambda/latest/api/API_PutProvisionedConcurrencyConfig.html)
+ [TagResource](https://docs.aws.amazon.com/lambda/latest/api/API_TagResource.html)
+ [UntagResource](https://docs.aws.amazon.com/lambda/latest/api/API_UntagResource.html)
+ [UpdateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateAlias.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)
+ [UpdateFunctionEventInvokeConfig](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionEventInvokeConfig.html)
# Lambda-Funktionszugriff gewähren für AWS-Services
Wenn Sie [einen AWS Dienst verwenden, um Ihre Funktion aufzurufen](lambda-services.md), erteilen Sie die Erlaubnis in einer Erklärung zu einer ressourcenbasierten Richtlinie. Sie können die Anweisung auf die gesamte Funktion anwenden oder die Anweisung auf eine einzelne Version oder einen einzelnen Alias beschränken.
**Anmerkung**
Wenn Sie Ihrer Funktion mit der Lambda-Konsole einen Auslöser hinzufügen, aktualisiert die Konsole die ressourcenbasierte Richtlinie der Funktion, damit der Service sie aufrufen kann. Um Berechtigungen für andere Konten oder Services zu erteilen, die in der Lambda-Konsole nicht verfügbar sind, verwenden Sie die AWS CLI-CLI.
Fügen Sie eine Anweisung mit dem Befehl [add-permission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/add-permission.html) hinzu. Die einfachste ressourcenbasierte Richtlinienanweisung ermöglicht es einem Service, eine Funktion aufzurufen. Der folgende Befehl gewährt die Amazon-Simple Notification Service-Berechtigung zum Aufrufen einer Funktion namens `my-function`.
```
aws lambda add-permission \
--function-name my-function \
--action lambda:InvokeFunction \
--statement-id sns \
--principal sns.amazonaws.com \
--output text
```
Die Ausgabe sollte folgendermaßen aussehen:
```
{"Sid":"sns","Effect":"Allow","Principal":{"Service":"sns.amazonaws.com"},"Action":"lambda:InvokeFunction","Resource":"arn:aws:lambda:us-east-2:123456789012:function:my-function"}
```
Auf diese Weise kann Amazon SNS die API-Aktion [Aufruf](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html) für die Funktion aufrufen, ohne das Amazon-SNS-Thema einzuschränken, durch das der Aufruf ausgelöst wird. Um sicherzustellen, dass Ihre Funktion nur von einer bestimmten Ressource aufgerufen wird, geben Sie den Amazon-Ressourcennamen (ARN) der Ressource mit der Option `source-arn` an. Der folgende Befehl erlaubt Amazon SNS nur das Aufrufen der Funktion für Abonnements für ein Thema namens `my-topic`.
```
aws lambda add-permission \
--function-name my-function \
--action lambda:InvokeFunction \
--statement-id sns-my-topic \
--principal sns.amazonaws.com \
--source-arn arn:aws:sns:us-east-2:123456789012:my-topic
```
Einige Services können Funktionen in anderen Konten aufrufen. Wenn Sie einen Quell-ARN angeben, der Ihre Konto-ID enthält, ist das kein Problem. Für Amazon S3 ist die Quelle jedoch ein Bucket, dessen ARN nicht über eine Konto-ID verfügt. Es ist möglich, dass Sie den Bucket löschen und ein anderes Konto einen Bucket mit demselben Namen erstellt. Verwenden Sie die Option `source-account` mit Ihrer Konto-ID, um sicherzustellen, dass nur Ressourcen in Ihrem Konto die Funktion aufrufen können.
```
aws lambda add-permission \
--function-name my-function \
--action lambda:InvokeFunction \
--statement-id s3-account \
--principal s3.amazonaws.com \
--source-arn arn:aws:s3:::amzn-s3-demo-bucket \
--source-account 123456789012
```
# Gewähren des Funktionszugriffs auf eine Organisation
Um einer Organisation Berechtigungen in [AWS Organizations](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_introduction.html) zu gewähren, geben Sie die Organisations-ID als `principal-org-id` an. Der folgende [add-permission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/add-permission.html)-Befehl gewährt allen Benutzern in der Organisation `o-a1b2c3d4e5f` Aufrufzugriff.
```
aws lambda add-permission \
--function-name example \
--statement-id PrincipalOrgIDExample \
--action lambda:InvokeFunction \
--principal * \
--principal-org-id o-a1b2c3d4e5f
```
**Anmerkung**
In diesem Befehl ist `Principal` `*`. Dies bedeutet, dass alle Benutzer in der Organisation `o-a1b2c3d4e5f` Berechtigungen für den Funktionsaufruf erhalten. Wenn Sie eine AWS-Konto Oder-Rolle als angeben`Principal`, erhält nur dieser Prinzipal die Zugriffsberechtigungen für den Funktionsaufruf, aber nur, wenn er auch Teil der Organisation ist. `o-a1b2c3d4e5f`
Dieser Befehl erstellt eine ressourcenbasierte Richtlinie, die wie folgt aussieht:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "PrincipalOrgIDExample",
"Effect": "Allow",
"Principal": "*",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-east-2:123456789012:function:example",
"Condition": {
"StringEquals": {
"aws:PrincipalOrgID": "o-a1b2c3d4e5f"
}
}
}
]
}
```
------
Weitere Informationen finden Sie unter [aws: PrincipalOrg ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalorgid) im *IAM-Benutzerhandbuch*.
# Gewähren des Lambda-Funktionszugriffs für andere Konten
Um eine Funktion mit einer anderen gemeinsam zu nutzen AWS-Konto, fügen Sie der [ressourcenbasierten](access-control-resource-based.md) Richtlinie der Funktion eine kontoübergreifende Berechtigungsanweisung hinzu. Führen Sie den Befehl [add-permission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/add-permission.html) aus und geben Sie die Konto-ID als `principal` an. Im folgenden Beispiel wird dem Konto `111122223333` die Berechtigung zum Aufrufen von `my-function` mit dem Alias `prod` erteilt.
```
aws lambda add-permission \
--function-name my-function:prod \
--statement-id xaccount \
--action lambda:InvokeFunction \
--principal 111122223333 \
--output text
```
Die Ausgabe sollte folgendermaßen aussehen:
```
{"Sid":"xaccount","Effect":"Allow","Principal":{"AWS":"arn:aws:iam::111122223333:root"},"Action":"lambda:InvokeFunction","Resource":"arn:aws:lambda:us-east-1:123456789012:function:my-function"}
```
Die ressourcenbasierte Richtlinie erteilt dem anderen Konto die Berechtigung für den Zugriff auf die Funktion, erlaubt den Benutzern in diesem Konto jedoch nicht, ihre Berechtigungen zu überschreiten. Benutzer in dem anderen Konto müssen über die entsprechenden [Benutzerberechtigungen](access-control-identity-based.md) verfügen, um die Lambda-API verwenden zu können.
Um den Zugriff auf einen Benutzer oder eine Rolle in einem anderen Konto einzuschränken, geben Sie den vollständigen ARN der Identität als Prinzipal an. Beispiel, `arn:aws:iam::123456789012:user/developer`.
Der [Alias](configuration-aliases.md) schränkt ein, welche Version das andere Konto aufrufen kann. Dies erfordert, dass das andere Konto den Alias in den ARN der Funktion einschließt.
```
aws lambda invoke \
--function-name arn:aws:lambda:us-east-2:123456789012:function:my-function:prod out
```
Die Ausgabe sollte folgendermaßen aussehen:
```
{
"StatusCode": 200,
"ExecutedVersion": "1"
}
```
Der Funktionsbesitzer kann dann den Alias so aktualisieren, dass er auf eine neue Version verweist, ohne dass der Aufrufer die Methode ändern muss, mit der er Ihre Funktion aufruft. Dadurch wird sichergestellt, dass das andere Konto seinen Code nicht ändern muss, um die neue Version zu verwenden, und nur zum Aufruf der Version der Funktion berechtigt ist, die dem Alias zugeordnet ist.
Sie können kontoübergreifenden Zugriff für die meisten API-Aktionen erteilen, die für eine vorhandene Funktion ausgeführt werden. Beispielsweise könnten Sie Zugriff auf `lambda:ListAliases` gewähren, damit ein Konto eine Liste der Aliasse abrufen kann, oder `lambda:GetFunction`, damit es Ihren Funktionscode herunterladen kann. Fügen Sie jede Berechtigung separat hinzu oder verwenden Sie `lambda:*`, um Zugriff auf alle Aktionen der angegebenen Funktion zu gewähren.
Um anderen Konten Berechtigungen für mehrere Funktionen oder für Aktionen zu erteilen, die nicht für eine Funktion ausgeführt werden, empfehlen wir die Verwendung von [IAM-Rollen](access-control-identity-based.md).
# Gewähren des Lambda-Ebenenzugriffs für andere Konten
Um eine Ebene mit einer anderen gemeinsam zu nutzen AWS-Konto, fügen Sie der [ressourcenbasierten](access-control-resource-based.md) Richtlinie der Ebene eine kontoübergreifende Berechtigungserklärung hinzu. Führen Sie den [add-layer-version-permission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/add-layer-version-permission.html)Befehl aus und geben Sie die Konto-ID als. `principal` In jeder Anweisung können Sie einem einzelnen Konto, allen Konten oder einer Organisation in [AWS Organizations](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_introduction.html) eine Berechtigung erteilen.
Im folgenden Beispiel wird dem Konto 111122223333 Zugriff auf Version 2 der `bash-runtime`-Ebene gewährt.
```
aws lambda add-layer-version-permission \
--layer-name bash-runtime \
--version-number 2 \
--statement-id xaccount \
--action lambda:GetLayerVersion \
--principal 111122223333 \
--output text
```
Die Ausgabe sollte folgendermaßen oder ähnlich aussehen:
```
{"Sid":"xaccount","Effect":"Allow","Principal":{"AWS":"arn:aws:iam::111122223333:root"},"Action":"lambda:GetLayerVersion","Resource":"arn:aws:lambda:us-east-1:123456789012:layer:bash-runtime:2"}
```
Berechtigungen gelten nur für eine Version mit einer Ebene. Wiederholen Sie den Vorgang bei jeder Erstellung einer neuen Ebenenversion.
Um Berechtigungen für alle Konten in einer [AWS Organizations](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_introduction.html) Organisation zu erteilen, verwenden Sie die Option `organization-id`. Im folgenden Beispiel wird allen Konten in Organisation `o-t194hfs8cz` die Berechtigung für die Verwendung von Version 3 einer `my-layer` erteilt.
```
aws lambda add-layer-version-permission \
--layer-name my-layer \
--version-number 3 \
--statement-id engineering-org \
--principal '*' \
--action lambda:GetLayerVersion \
--organization-id o-t194hfs8cz \
--output text
```
Die Ausgabe sollte folgendermaßen aussehen:
```
{"Sid":"engineering-org","Effect":"Allow","Principal":"*","Action":"lambda:GetLayerVersion","Resource":"arn:aws:lambda:us-east-2:123456789012:layer:my-layer:3","Condition":{"StringEquals":{"aws:PrincipalOrgID":"o-t194hfs8cz"}}}"
```
Um die Berechtigung für mehrere Konten oder Organisationen zu erteilen, müssen Sie mehrere Bescheinigungen hinzufügen.
# Verwendung der attributbasierten Zugriffskontrolle in Lambda
Mit [attributbasierter Zugriffskontrolle (ABAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html) können Sie Tags verwenden, um den Zugriff auf Ihre Lambda-Ressourcen zu steuern. Sie können Tags an bestimmte Lambda-Ressourcen anhängen, sie an bestimmte API-Anfragen anhängen oder sie an den AWS Identity and Access Management (IAM-) Principal anhängen, der die Anfrage stellt. *Weitere Informationen darüber, wie attributebasierten Zugriff AWS gewährt wird, finden Sie im IAM-Benutzerhandbuch unter [Steuern des Zugriffs auf AWS Ressourcen mithilfe von Tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html).*
Sie können ABAC verwenden, um die [geringsten Berechtigungen zu gewähren](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege), ohne einen Amazon-Ressourcennamen (ARN) oder ein ARN-Muster in der IAM-Richtlinie anzugeben. Stattdessen können Sie ein Tag im [Bedingungselement](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) einer IAM-Richtlinie angeben, um den Zugriff zu steuern. Die Skalierung ist mit ABAC einfacher, da Sie Ihre IAM-Richtlinien nicht aktualisieren müssen, wenn Sie neue Ressourcen erstellen. Fügen Sie stattdessen Tags zu den neuen Ressourcen hinzu, um den Zugriff zu steuern.
In Lambda funktionieren Tags für die folgenden Ressourcen:
+ Funktionen – Weitere Informationen zu Tagging-Funktionen finden Sie unter [Verwenden von Tags für Lambda-Funktionen](configuration-tags.md).
+ Codesignaturkonfigurationen – Weitere Informationen zum Markieren von Codesignaturkonfigurationen finden Sie unter [Verwendung von Tags in Codesignatur-Konfigurationen](tags-csc.md).
+ Zuordnungen von Ereignisquellen – Weitere Informationen zum Markieren von Zuordnungen von Ereignisquellen finden Sie unter [Verwendung von Tags für Zuordnungen von Ereignisquellen](tags-esm.md).
Tags werden für Ebenen nicht unterstützt.
Sie können die folgenden Bedingungsschlüssel verwenden, um auf Tag basierende IAM-Richtlinienregeln zu schreiben:
+ [aws: ResourceTag /tag-key](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourcetag): Steuert den Zugriff anhand der Tags, die an eine Lambda-Ressource angehängt sind.
+ [aws: RequestTag /tag-key](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requesttag): Erfordert, dass Tags in einer Anfrage vorhanden sind, z. B. beim Erstellen einer neuen Funktion.
+ [aws: PrincipalTag /tag-key](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltag) [https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags_users.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags_users.html)
+ [aws:TagKeys:](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tagkeys) Steuert, ob bestimmte Tag-Schlüssel in einer Anfrage verwendet werden können.
Sie können nur Bedingungen für Aktionen angeben, die diese Bedingungen unterstützen. Eine Liste der Bedingungen, die von jeder Lambda-Aktion unterstützt werden, finden Sie unter [Aktionen, Ressourcen und Bedingungsschlüssel für AWS Lambda](https://docs.aws.amazon.com//service-authorization/latest/reference/list_awslambda.html) in der Referenz zur Dienstautorisierung. Informationen zur Unterstützung von **aws: ResourceTag /tag-key** finden Sie unter „Ressourcentypen definiert von“. AWS Lambda Informationen zu **aws: RequestTag /tag-key** und **aws: TagKeys** support finden Sie unter „Aktionen definiert von“. AWS Lambda
**Topics**
+ [Sichern Sie Ihre Funktionen per Tag](attribute-based-access-control-example.md)
# Sichern Sie Ihre Funktionen per Tag
Die folgenden Schritte zeigen eine Möglichkeit, wie Sie mit ABAC Berechtigungen für Funktionen einrichten können. In diesem Beispielszenario erstellen Sie vier IAM-Berechtigungsrichtlinien. Anschließend fügen Sie diese Richtlinien einer neuen IAM-Rolle hinzu. Schließlich erstellen Sie einen IAM-Benutzer und erteilen diesem Benutzer die Berechtigung, die neue Rolle zu übernehmen.
**Topics**
+ [Voraussetzungen](#abac-prerequisites)
+ [Schritt 1: Tags für neue Funktionen anfordern](#require-tag-on-create)
+ [Schritt 2: Aktionen basierend auf Tags zulassen, die einer Lambda-Funktion und einem IAM-Prinzipal zugeordnet sind](#restrict-actions-function-tags)
+ [Schritt 3: Erteilen von Listenberechtigungen](#abac-list-permissions)
+ [Schritt 4: Erteilen von IAM-Berechtigungen](#abac-iam-permissions)
+ [Schritt 5: Erstellen der IAM-Rolle](#abac-create-role)
+ [Schritt 6: Erstellen eines IAM-Benutzers](#abac-create-user)
+ [Schritt 7: Testen der Berechtigungen](#abac-test)
+ [Schritt 8: Bereinigen Ihrer Ressourcen](#abac-clean-up)
## Voraussetzungen
Stellen Sie sicher, dass Sie über eine [Lambda-Ausführungsrolle](lambda-intro-execution-role.md) verfügen. Sie verwenden diese Rolle, wenn Sie IAM-Berechtigungen erteilen und eine Lambda-Funktion erstellen.
## Schritt 1: Tags für neue Funktionen anfordern
Wenn Sie ABAC mit Lambda verwenden, empfiehlt es sich, dass alle Funktionen über Tags verfügen. Auf diese Weise können Sie sicherstellen, dass Ihre ABAC-Berechtigungsrichtlinien wie erwartet funktionieren.
[Erstellen Sie eine IAM-Richtlinie](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html#access_policies_create-json-editor) ähnlich dem folgenden Beispiel. Diese Richtlinie verwendet die TagKeys Bedingungsschlüssel [aws: RequestTag /tag-key](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requesttag), [aws: ResourceTag /tag-key und [aws:](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tagkeys)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourcetag), um zu verlangen, dass sowohl neue Funktionen als auch der IAM-Prinzipal, der die Funktionen erstellt, das Tag haben. `project` Der `ForAllValues`-Modifikator stellt sicher, dass `project` das einzige zulässige Tag ist. Wenn Sie den `ForAllValues`-Modifikator nicht angeben, können die Benutzer der Funktion andere Tags hinzufügen, solange diese auch `project` übergeben.
**Example – Tags für neue Funktionen anfordern**
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": [
"lambda:CreateFunction",
"lambda:TagResource"
],
"Resource": "arn:aws:lambda:*:*:function:*",
"Condition": {
"StringEquals": {
"aws:RequestTag/project": "${aws:PrincipalTag/project}",
"aws:ResourceTag/project": "${aws:PrincipalTag/project}"
},
"ForAllValues:StringEquals": {
"aws:TagKeys": "project"
}
}
}
}
```
## Schritt 2: Aktionen basierend auf Tags zulassen, die einer Lambda-Funktion und einem IAM-Prinzipal zugeordnet sind
Erstellen Sie eine zweite IAM-Richtlinie mithilfe des [ResourceTagBedingungsschlüssels aws: /tag-key](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourcetag), um zu verlangen, dass das Tag des Prinzipals mit dem Tag übereinstimmt, das an die Funktion angehängt ist. Die folgende Beispielrichtlinie erlaubt es Prinzipalen mit dem `project`-Tag, Funktionen mit dem `project`-Tag aufzurufen. Wenn eine Funktion andere Tags hat, wird die Aktion verweigert.
**Example – Erfordert übereinstimmende Tags für Funktion und IAM-Prinzipal**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction",
"lambda:GetFunction"
],
"Resource": "arn:aws:lambda:*:*:function:*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/project": "${aws:PrincipalTag/project}"
}
}
}
]
}
```
## Schritt 3: Erteilen von Listenberechtigungen
Erstellen Sie eine Richtlinie, die es dem Prinzipal ermöglicht, Lambda-Funktionen und IAM-Rollen aufzulisten. Dadurch kann der Prinzipal alle Lambda-Funktionen und IAM-Rollen auf der Konsole und beim Aufrufen der API-Aktionen sehen.
**Example – Erteilen von Lambda- und IAM-Listenberechtigungen**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllResourcesLambdaNoTags",
"Effect": "Allow",
"Action": [
"lambda:GetAccountSettings",
"lambda:ListFunctions",
"iam:ListRoles"
],
"Resource": "*"
}
]
}
```
## Schritt 4: Erteilen von IAM-Berechtigungen
**Erstellen Sie eine Richtlinie, die iam: zulässt. PassRole** Diese Berechtigung ist erforderlich, wenn Sie einer Funktion eine Ausführungsrolle zuweisen. Ersetzen Sie in der folgenden Beispielrichtlinie den Beispiel-ARN durch den ARN Ihrer Lambda-Ausführungsrolle.
**Anmerkung**
Verwenden Sie den `ResourceTag`-Bedingungsschlüssel nicht in einer Richtlinie mit der `iam:PassRole`-Aktion. Sie können das Tag nicht für eine IAM-Rolle verwenden, um zu steuern, wer Zugriff zur Weiterleitung diese Rolle haben soll. Weitere Informationen zu den Berechtigungen, die für die Übergabe einer Rolle an einen Dienst erforderlich sind, finden Sie unter [Einem Benutzer Berechtigungen zur Übergabe einer Rolle an einen AWS Dienst gewähren](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html).
**Example – Erteilt die Berechtigung zum Übergeben der Ausführungsrolle**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": "arn:aws:iam::111122223333:role/lambda-ex"
}
]
}
```
## Schritt 5: Erstellen der IAM-Rolle
Es hat sich bewährt, [Rollen zum Delegieren von Berechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#delegate-using-roles) zu verwenden. [Erstellen Sie eine IAM-Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html#roles-creatingrole-user-console) mit dem Namen `abac-project-role`:
+ In **Schritt 1: Vertrauenswürdige Entität auswählen**: Wählen Sie wählen **AWS -Konto** und wählen Sie dann **Dieses Konto**.
+ In **Schritt 2: Hinzufügen von Berechtigungen**: Fügen Sie die vier IAM-Richtlinien hinzu, die Sie in den vorherigen Schritten erstellt haben.
+ In **Schritt 3: Benennen, Überprüfen und Erstellen**: Wählen Sie **Tag hinzufügen**. Geben Sie für **Key (Schlüssel)** `project` ein. Geben Sie keinen **Value** (Wert) ein.
## Schritt 6: Erstellen eines IAM-Benutzers
[Erstellen Sie einen IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html#id_users_create_console) mit dem Namen `abac-test-user`. Wählen Sie im Abschnitt **Set permissions** (Berechtigungen festlegen) die Option **Attach existing policies directly** (Vorhandene Richtlinien direkt anhängen) und dann **Create policy** (Richtlinie erstellen) aus. Geben Sie die folgende Richtliniendefinition ein. Ersetzen Sie *111122223333* durch Ihre [AWS -Konto-ID](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html#FindingYourAccountIdentifiers). Diese Richtlinie erlaubt es `abac-test-user`, `abac-project-role` anzunehmen.
**Example – IAM-Benutzer die Übernahme der ABAC-Rolle erlauben**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111122223333:role/abac-project-role"
}
}
```
------
## Schritt 7: Testen der Berechtigungen
1. Melden Sie sich an der AWS Konsole an als`abac-test-user`. Weitere Informationen finden Sie unter [Anmeldung als IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/console.html#user-sign-in-page).
1. Wechseln Sie zur `abac-project-role`-Rolle. Weitere Informationen finden Sie unter [Wechseln zu einer Rolle (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html).
1. [Erstellen einer Lambda-Funktion](configuration-tags.md#using-tags-with-the-console):
+ Wählen Sie unter **Permissions** (Berechtigungen) die Option **Change default execution role** (Standardausführungsrolle ändern) und dann unter **Execution role** (Ausführungsrolle) die Option **Use an existing role** (Vorhandene Rolle verwenden). Wählen Sie dieselbe Ausführungsrolle aus, die Sie in [Schritt 4: Erteilen von IAM-Berechtigungen](#abac-iam-permissions) verwendet haben.
+ Wählen Sie unter **Advanced settings** (Erweiterte Einstellungen) die Option **Enable tags** (Tags ermöglichen) und wählen Sie dann **Add new tag** (Neues Tag hinzufügen). Geben Sie für **Key (Schlüssel)** `project` ein. Geben Sie keinen **Value** (Wert) ein.
1. [Testen der Funktion](testing-functions.md).
1. Erstellen Sie eine zweite Lambda-Funktion und fügen Sie ein anderes Tag hinzu, z. B. `environment`. Dieser Vorgang sollte fehlschlagen, da die ABAC-Richtlinie, die Sie in [Schritt 1: Tags für neue Funktionen anfordern](#require-tag-on-create) erstellt haben, dem Prinzipal nur erlaubt, Funktionen mit dem `project`-Tag zu erstellen.
1. Erstellen Sie eine dritte Funktion ohne Tags. Dieser Vorgang sollte fehlschlagen, weil die ABAC-Richtlinie, die Sie in [Schritt 1: Tags für neue Funktionen anfordern](#require-tag-on-create) erstellt haben, dem Prinzipal nicht erlaubt, Funktionen ohne Tags zu erstellen.
Mit dieser Autorisierungsstrategie können Sie den Zugriff steuern, ohne für jeden neuen Benutzer neue Richtlinien erstellen zu müssen. Um neuen Benutzern Zugriff zu gewähren, erteilen Sie ihnen einfach die Berechtigung, die Rolle zu übernehmen, die ihrem zugewiesenen Projekt entspricht.
## Schritt 8: Bereinigen Ihrer Ressourcen
**Löschen Sie die IAM-Rolle wie folgt:**
1. Öffnen Sie die Seite [Roles (Rollen)](https://console.aws.amazon.com/iam/home#/roles) in der IAM-Konsole.
1. Wählen Sie die Rolle aus, die Sie im [Schritt 5](#abac-create-role) erstellt haben.
1. Wählen Sie **Löschen** aus.
1. Geben Sie den Namen der Rolle in das Texteingabefeld ein, um den Löschvorgang zu bestätigen.
1. Wählen Sie **Löschen** aus.
**So löschen Sie den IAM-Benutzer**
1. Öffnen Sie die [Seite Users](https://console.aws.amazon.com/iam/home#/users) in der IAM-Konsole.
1. Wählen Sie den IAM-Benutzer aus, den Sie in [Schritt 6](#abac-create-user) erstellt haben.
1. Wählen Sie **Löschen** aus.
1. Geben Sie den Namen des Benutzers in das Texteingabefeld ein, um den Löschvorgang zu bestätigen.
1. Wählen Sie **Benutzer löschen**.
**So löschen Sie die Lambda-Funktion:**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie die Funktion aus, die Sie erstellt haben.
1. Wählen Sie **Aktionen**, **Löschen** aus.
1. Geben Sie **confirm** in das Texteingabefeld ein und wählen Sie **Delete** (Löschen) aus.
# Feinabstimmung der Abschnitte „Ressourcen“ und „Bedingungen“ der Richtlinien
Sie können den Umfang der Berechtigungen eines Benutzers einschränken, indem Sie Ressourcen und Bedingungen in einer AWS Identity and Access Management (IAM)-Richtlinie angeben. Jede Aktion in einer Richtlinie unterstützt eine Kombination aus Ressourcen- und Bedingungstypen, die je nach Verhalten der Aktion variiert.
Jede IAM-Richtlinienanweisung erteilt die Berechtigung für eine Aktion, die auf eine Ressource ausgeführt wird. Wenn die Aktion nicht auf eine benannte Ressource reagiert oder Sie die Berechtigung zum Ausführen der Aktion für alle Ressourcen erteilen, wird der Wert der Ressource in der Richtlinie als Platzhalter () dargeste (`*`). Für viele Aktionen können Sie die Ressourcen einschränken, die ein Benutzer ändern kann, indem Sie den Amazon-Ressourcennamen (ARN) einer Ressource oder ein ARN-Muster angeben, das mehreren Ressourcen entspricht.
Je nach Ressourcentyp lässt sich der Umfang einer Maßnahme generell wie folgt einschränken:
+ Funktionen–Aktionen, die auf eine Funktion wirken, können auf eine bestimmte Funktion nach Funktion, Version oder Alias-ARN beschränkt werden.
+ Zuordnungen von Ereignisquellen – Aktionen können per ARN auf bestimmte Ressourcen zur Zuordnung von Ereignisquellen beschränkt werden. Zuordnungen von Ereignisquellen sind immer mit einer Funktion verknüpft. Sie können auch die `lambda:FunctionArn`-Bedingung verwenden, um Aktionen durch die zugehörige Funktion einzuschränken.
+ Ebenen – Aktionen, die sich auf die Verwendung von Ebenen und Berechtigungen beziehen, wirken sich auf eine Version einer Ebene aus.
+ Codesignaturkonfiguration – Aktionen können per ARN auf bestimmte Codesignatur-Konfigurationsressourcen beschränkt werden.
+ Tags – Verwenden Sie standardmäßige Tag-Bedingungen. Weitere Informationen finden Sie unter [Verwendung der attributbasierten Zugriffskontrolle in Lambda](attribute-based-access-control.md).
Zum Einschränken von Berechtigungen nach Ressource bestimmen Sie die Ressource unter Angabe des ARN.
**Format des Lambda-Ressourcen-ARN**
+ Funktion – `arn:aws:lambda:us-west-2:123456789012:function:my-function`
+ Funktionsversion – `arn:aws:lambda:us-west-2:123456789012:function:my-function:1`
+ Funktionsalias – `arn:aws:lambda:us-west-2:123456789012:function:my-function:TEST`
+ Mapping von Ereignisquellen – `arn:aws:lambda:us-west-2:123456789012:event-source-mapping:fa123456-14a1-4fd2-9fec-83de64ad683de6d47`
+ Ebene – `arn:aws:lambda:us-west-2:123456789012:layer:my-layer`
+ Ebenenversion – `arn:aws:lambda:us-west-2:123456789012:layer:my-layer:1`
+ Codesignaturkonfiguration – `arn:aws:lambda:us-west-2:123456789012:code-signing-config:my-csc`
Die folgende Richtlinie ermöglicht es einem Benutzer beispielsweise, eine Funktion AWS-Konto `123456789012` aufzurufen, die `my-function` in der AWS Region USA West (Oregon) benannt ist.
**Example Aufrufen der Funktionsrichtlinie**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Invoke",
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:us-west-2:123456789012:function:my-function"
}
]
}
```
Dies ist ein Sonderfall, da sich die Aktionskennung (`lambda:InvokeFunction`) von der API-Operation ([Invoke](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html)) unterscheidet. Bei anderen Aktionen ist die Aktionskennung der Operationsname mit dem Präfix `lambda:`.
**Topics**
+ [Den Abschnitt „Bedingungen“ in Richtlinien verstehen](#authorization-conditions)
+ [Referenzierung von Funktionen im Abschnitt „Ressourcen“ von Richtlinien](#function-resources)
+ [Unterstützte IAM-Aktionen und Funktionsverhalten](#permissions-resources)
## Den Abschnitt „Bedingungen“ in Richtlinien verstehen
Bedingungen sind ein optionales Richtlinienelement, das zusätzliche Logik anwendet, um zu bestimmen, ob eine Aktion zulässig ist. Zusätzlich zu [gemeinsamen](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) Bedingungen, die alle Aktionen unterstützen, definiert Lambda Bedingungstypen, die Sie verwenden können, um die Werte zusätzlicher Parameter für einige Aktionen einzuschränken.
Mit der Bedingung `lambda:Principal` können Sie beispielsweise den Service oder das Konto beschränken, für das ein Benutzer in der [ressourcenbasierten Richtlinie](access-control-resource-based.md) einer Funktion Aufrufzugriff gewähren kann. Mit der folgenden Richtlinie kann ein Benutzer Amazon Simple Notification Service (Amazon SNS)-Themen die Berechtigung erteilen, eine Funktion mit dem Namen `test` aufzurufen.
**Example Verwalten von Berechtigungen für Funktionsrichtlinien**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ManageFunctionPolicy",
"Effect": "Allow",
"Action": [
"lambda:AddPermission",
"lambda:RemovePermission"
],
"Resource": "arn:aws:lambda:us-west-2:123456789012:function:test:*",
"Condition": {
"StringEquals": {
"lambda:Principal": "sns.amazonaws.com"
}
}
}
]
}
```
Die Bedingung erfordert, dass der Prinzipal Amazon SNS und kein anderer Service bzw. kein anderes Konto ist. Das Ressourcenmuster erfordert, dass der Funktionsname `test` lautet und eine Versionsnummer oder einen Alias enthält. Beispiel, `test:v1`.
Weitere Informationen zu Ressourcen und Bedingungen für Lambda und andere AWS Dienste finden Sie unter [Aktionen, Ressourcen und Bedingungsschlüssel für AWS Dienste](https://docs.aws.amazon.com/service-authorization/latest/reference/reference_policies_actions-resources-contextkeys.html) in der *Service Authorization Reference.*
## Referenzierung von Funktionen im Abschnitt „Ressourcen“ von Richtlinien
Sie referenzieren eine Lambda-Funktion in einer Richtlinienanweisung mithilfe eines Amazon-Ressourcennamens (ARN). Das Format des ARN für eine Funktion hängt davon ab, ob Sie die gesamte Funktion, eine [Funktionsversion (unqualifiziert), eine Funktionsversion](configuration-versions.md) oder einen [Alias](configuration-aliases.md) referenzieren.
Bei Lambda-API-Aufrufen können Benutzer eine Version oder einen Alias angeben, indem sie einen Versions-ARN oder Alias-ARN im [GetFunction](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html)`FunctionName`Parameter übergeben oder einen Wert im [GetFunction](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html)`Qualifier`Parameter festlegen. Lambda trifft Autorisierungsentscheidungen, indem es das Ressourcenelement in der IAM-Richtlinie sowohl mit dem in API-Aufrufen übergebenen `FunctionName`n als auch dem `Qualifier` vergleicht. Wenn es keine Übereinstimmung gibt, lehnt Lambda die Anforderung ab.
Unabhängig davon, ob Sie eine Aktion für Ihre Funktion zulassen oder verweigern, müssen Sie die richtigen ARN-Typen für Funktionen in Ihrer Richtlinienanweisung verwenden, um die erwarteten Ergebnisse zu erzielen. Wenn Ihre Richtlinie beispielsweise auf den unqualifizierten ARN verweist, akzeptiert Lambda Anfragen, die auf den unqualifizierten ARN verweisen, lehnt jedoch Anfragen ab, die auf einen qualifizierten ARN verweisen.
**Anmerkung**
Sie können kein Platzhalterzeichen (\$1) verwenden, um die Konto-ID abzugleichen. Weitere Informationen zur zulässigen Syntax finden Sie unter [IAM JSON-Richtlinienreferenz](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html) im *IAM-Benutzerhandbuch*.
**Example Zulassen des Aufrufs eines nicht qualifizierten ARN**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-west-2:123456789012:function:myFunction"
}
]
}
```
Wenn Ihre Richtlinie auf einen bestimmten qualifizierten ARN verweist, akzeptiert Lambda Anfragen, die auf diesen ARN verweisen, lehnt aber Anfragen ab, die auf den nicht qualifizierten ARN oder einen anderen qualifizierten ARN verweisen, z. B. `myFunction:2`.
**Example Zulassen des Aufrufs eines bestimmten qualifizierten ARN**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-west-2:123456789012:function:myFunction:1"
}
]
}
```
Wenn Ihre Richtlinie mit `:*` einen qualifizierten ARN referenziert, akzeptiert Lambda alle qualifizierten ARN, lehnt jedoch Anfragen ab, die den unqualifizierten ARN referenzieren.
**Example Zulassen des Aufrufs eines beliebigen qualifizierten ARN**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-west-2:123456789012:function:myFunction:*"
}
]
}
```
Wenn Ihre Richtlinie mit `*` einen ARN referenziert, akzeptiert Lambda alle qualifizierten oder unqualifizierten ARNs.
**Example Zulassen des Aufrufs eines beliebigen qualifizierten oder nicht qualifizierten ARN**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-west-2:123456789012:function:myFunction*"
}
]
}
```
## Unterstützte IAM-Aktionen und Funktionsverhalten
Aktionen definieren, was durch IAM-Richtlinien zugelassen werden kann. Eine Liste der in Lambda unterstützten Aktionen finden Sie unter [Aktionen, Ressourcen und Bedingungsschlüssel für AWS Lambda](https://docs.aws.amazon.com//service-authorization/latest/reference/list_awslambda.html) in der Referenz zur Dienstautorisierung. Wenn eine IAM-Aktion eine Lambda-API-Aktion zulässt, ist der Name der IAM-Aktion in den meisten Fällen derselbe wie der Name der Lambda-API-Aktion, mit den folgenden Ausnahmen:
| API-Aktion | IAM-Aktion |
| --- | --- |
| [Invoke](https://docs.aws.amazon.com//lambda/latest/api/API_Invoke.html) | lambda:InvokeFunction |
| [GetLayerVersion](https://docs.aws.amazon.com//lambda/latest/api/API_GetLayerVersion.html) [GetLayerVersionByArn](https://docs.aws.amazon.com//lambda/latest/api/API_GetLayerVersionByArn.html) | lambda:GetLayerVersion |
Zusätzlich zu den Ressourcen und Bedingungen, die in der [Referenz für die Service-Autorisierung](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awslambda.html) definiert sind, unterstützt Lambda die folgenden Ressourcen und Bedingungen für bestimmte Aktionen. Viele davon beziehen sich auf Referenzfunktionen im Ressourcenbereich der Richtlinien. Aktionen, die für eine Funktion verwender werden, können – wie in der folgenden Tabelle beschrieben – nach Funktion, Version oder Alias-ARN auf eine spezifische Funktion eingeschränkt werden.
| Action | Ressource | Bedingung |
| --- | --- | --- |
| [AddPermission](https://docs.aws.amazon.com/lambda/latest/api/API_AddPermission.html) [RemovePermission](https://docs.aws.amazon.com/lambda/latest/api/API_RemovePermission.html) [Aufrufen](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html) (**Berechtigung:** `lambda:InvokeFunction`) | Funktionsversion Funktionsalias | – |
| [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html) | – | `lambda:CodeSigningConfigArn` |
| [CreateFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunctionUrlConfig.html) [DeleteFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteFunctionUrlConfig.html) [GetFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionUrlConfig.html) [UpdateFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionUrlConfig.html) | Funktionsalias | – |