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.
# Identitäts- und Zugriffsmanagement für AWS CodeStar Benachrichtigungen und AWS CodeConnections
AWS Identity and Access Management (IAM) hilft einem Administrator AWS-Service , den Zugriff auf Ressourcen sicher zu AWS kontrollieren. IAM-Administratoren kontrollieren, wer *authentifiziert* (angemeldet) und *autorisiert* werden kann (über Berechtigungen verfügt), AWS CodeStar Benachrichtigungen und Ressourcen zu verwenden. AWS CodeConnections IAM ist ein Programm AWS-Service , das Sie ohne zusätzliche Kosten nutzen können.
**Anmerkung**
Aktionen für Ressourcen, die unter dem neuen Dienstpräfix erstellt wurden, `codeconnections` sind verfügbar. Wenn Sie eine Ressource unter dem neuen Dienstpräfix erstellen, wird sie `codeconnections` im Ressourcen-ARN verwendet. Aktionen und Ressourcen für das `codestar-connections` Dienstpräfix bleiben verfügbar. Wenn Sie eine Ressource in der IAM-Richtlinie angeben, muss das Dienstpräfix mit dem der Ressource übereinstimmen.
**Topics**
+ [Zielgruppe](#security_iam_audience)
+ [Authentifizierung mit Identitäten](#security_iam_authentication)
+ [Verwalten des Zugriffs mit Richtlinien](#security_iam_access-manage)
+ [Funktionsweise von Funktionen in der Entwicklertools-Konsole mit IAM](security_iam_service-with-iam.md)
+ [AWS CodeConnections Referenz zu Berechtigungen](#permissions-reference-connections)
+ [Beispiele für identitätsbasierte Richtlinien](security_iam_id-based-policy-examples.md)
+ [Verwendung von Tags zur Steuerung des Zugriffs auf Ressourcen AWS CodeConnections](connections-tag-based-access-control.md)
+ [Verwenden von Notifications und Connections in der Konsole](#security_iam_id-based-policy-examples-console)
+ [Gewähren der Berechtigung zur Anzeige der eigenen Berechtigungen für Benutzer](#security_iam_id-based-policy-examples-view-own-permissions)
+ [Fehlerbehebung bei AWS CodeStar Benachrichtigungen sowie AWS CodeConnections Identität und Zugriff](security_iam_troubleshoot.md)
+ [Verwenden von serviceverknüpften Rollen für Benachrichtigungen AWS CodeStar](using-service-linked-roles.md)
+ [Verwenden von serviceverknüpften Rollen für AWS CodeConnections](service-linked-role-connections.md)
+ [AWS verwaltete Richtlinien für AWS CodeConnections](security-iam-awsmanpol.md)
## Zielgruppe
Wie Sie AWS Identity and Access Management (IAM) verwenden, hängt von Ihrer Rolle ab:
+ **Servicebenutzer** – Fordern Sie von Ihrem Administrator Berechtigungen an, wenn Sie nicht auf Features zugreifen können (siehe [Fehlerbehebung bei AWS CodeStar Benachrichtigungen sowie AWS CodeConnections Identität und Zugriff](security_iam_troubleshoot.md)).
+ **Serviceadministrator** – Bestimmen Sie den Benutzerzugriff und stellen Sie Berechtigungsanfragen (siehe [Funktionsweise von Funktionen in der Entwicklertools-Konsole mit IAM](security_iam_service-with-iam.md)).
+ **IAM-Administrator** – Schreiben Sie Richtlinien zur Zugriffsverwaltung (siehe [Beispiele für identitätsbasierte Richtlinien](security_iam_id-based-policy-examples.md)).
## Authentifizierung mit Identitäten
Authentifizierung ist die Art und Weise, wie Sie sich AWS mit Ihren Identitätsdaten anmelden. Sie müssen sich als IAM-Benutzer authentifizieren oder eine IAM-Rolle annehmen. Root-Benutzer des AWS-Kontos
Sie können sich als föderierte Identität anmelden, indem Sie Anmeldeinformationen aus einer Identitätsquelle wie AWS IAM Identity Center (IAM Identity Center), Single Sign-On-Authentifizierung oder Anmeldeinformationen verwenden. Google/Facebook Weitere Informationen zum Anmelden finden Sie unter [So melden Sie sich bei Ihrem AWS-Konto an](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html) im *Benutzerhandbuch für AWS-Anmeldung *.
AWS Bietet für den programmatischen Zugriff ein SDK und eine CLI zum kryptografischen Signieren von Anfragen. Weitere Informationen finden Sie unter [AWS Signature Version 4 for API requests](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) im *IAM-Benutzerhandbuch*.
### Root-Benutzer des AWS-Kontos
Wenn Sie eine erstellen AWS-Konto, beginnen Sie mit einer Anmeldeidentität, dem so genannten AWS-Konto *Root-Benutzer*, der vollständigen Zugriff auf alle Ressourcen hat. AWS-Services Wir raten ausdrücklich davon ab, den Root-Benutzer für Alltagsaufgaben zu verwenden. Eine Liste der Aufgaben, für die Sie sich als Root-Benutzer anmelden müssen, finden Sie unter [Tasks that require root user credentials](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks) im *IAM-Benutzerhandbuch*.
### IAM-Benutzer und -Gruppen
Ein *[IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html)* ist eine Identität mit bestimmten Berechtigungen für eine einzelne Person oder Anwendung. Wir empfehlen die Verwendung temporärer Anmeldeinformationen anstelle von IAM-Benutzern mit langfristigen Anmeldeinformationen. Weitere Informationen finden Sie im *IAM-Benutzerhandbuch* unter [Erfordern, dass menschliche Benutzer für den Zugriff AWS mithilfe temporärer Anmeldeinformationen einen Verbund mit einem Identitätsanbieter](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) verwenden müssen.
Eine [https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) spezifiziert eine Sammlung von IAM-Benutzern und erleichtert die Verwaltung von Berechtigungen für große Gruppen von Benutzern. Weitere Informationen finden Sie unter [Anwendungsfälle für IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/gs-identities-iam-users.html) im *IAM-Benutzerhandbuch*.
### IAM-Rollen
Eine *[IAM-Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)* ist eine Identität mit spezifischen Berechtigungen, die temporäre Anmeldeinformationen bereitstellt. Sie können eine Rolle übernehmen, indem Sie [von einer Benutzer- zu einer IAM-Rolle (Konsole) wechseln](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html) oder indem Sie eine AWS Oder-API-Operation AWS CLI aufrufen. Weitere Informationen finden Sie unter [Methoden, um eine Rolle zu übernehmen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage-assume.html) im *IAM-Benutzerhandbuch*.
IAM-Rollen sind nützlich für den Verbundbenutzer-Zugriff, temporäre IAM-Benutzerberechtigungen, kontoübergreifenden Zugriff, serviceübergreifenden Zugriff und Anwendungen, die auf Amazon EC2 laufen. Weitere Informationen finden Sie unter [Kontoübergreifender Ressourcenzugriff in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) im *IAM-Benutzerhandbuch*.
## Verwalten des Zugriffs mit Richtlinien
Sie kontrollieren den Zugriff, AWS indem Sie Richtlinien erstellen und diese an AWS Identitäten oder Ressourcen anhängen. Eine Richtlinie definiert Berechtigungen, wenn sie mit einer Identität oder Ressource verknüpft sind. AWS bewertet diese Richtlinien, wenn ein Principal eine Anfrage stellt. Die meisten Richtlinien werden AWS als JSON-Dokumente gespeichert. Weitere Informationen zu JSON-Richtliniendokumenten finden Sie unter [Übersicht über JSON-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json) im *IAM-Benutzerhandbuch*.
Mit Hilfe von Richtlinien legen Administratoren fest, wer Zugriff auf was hat, indem sie definieren, welches **Prinzipal** welche **Aktionen** auf welchen **Ressourcen**und unter welchen **Bedingungen**durchführen darf.
Standardmäßig haben Benutzer, Gruppen und Rollen keine Berechtigungen. Ein IAM-Administrator erstellt IAM-Richtlinien und fügt sie zu Rollen hinzu, die die Benutzer dann übernehmen können. IAM-Richtlinien definieren Berechtigungen unabhängig von der Methode, die zur Ausführung der Operation verwendet wird.
### Identitätsbasierte Richtlinien
Identitätsbasierte Richtlinien sind JSON-Berechtigungsrichtliniendokumente, die Sie einer Identität (Benutzer, Gruppe oder Rolle) anfügen können. Diese Richtlinien steuern, welche Aktionen Identitäten für welche Ressourcen und unter welchen Bedingungen ausführen können. Informationen zum Erstellen identitätsbasierter Richtlinien finden Sie unter [Definieren benutzerdefinierter IAM-Berechtigungen mit vom Kunden verwalteten Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) im *IAM-Benutzerhandbuch*.
Identitätsbasierte Richtlinien können *Inline-Richtlinien* (direkt in eine einzelne Identität eingebettet) oder *verwaltete Richtlinien* (eigenständige Richtlinien, die mit mehreren Identitäten verbunden sind) sein. Informationen dazu, wie Sie zwischen verwalteten und Inline-Richtlinien wählen, finden Sie unter [Choose between managed policies and inline policies](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-choosing-managed-or-inline.html) im *IAM-Benutzerhandbuch*.
# Funktionsweise von Funktionen in der Entwicklertools-Konsole mit IAM
Bevor Sie IAM für die Verwaltung des Zugriffs auf Funktionen in der Entwicklertools-Konsole verwenden, sollten Sie wissen, welche IAM-Funktionen Sie damit verwenden werden können. Einen allgemeinen Überblick darüber, wie Benachrichtigungen und andere AWS Dienste mit IAM funktionieren, finden Sie im [IAM-Benutzerhandbuch unter AWS Dienste, die mit *IAM* funktionieren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html).
**Topics**
+ [Identitätsbasierte Richtlinien in der Entwicklertools-Konsole](#security_iam_service-with-iam-id-based-policies)
+ [AWS CodeStar Benachrichtigungen und ressourcenbasierte Richtlinien AWS CodeConnections](#security_iam_service-with-iam-resource-based-policies)
+ [Autorisierung auf der Basis von Markierungen](#security_iam_service-with-iam-tags)
+ [IAM-Rollen](#security_iam_service-with-iam-roles)
## Identitätsbasierte Richtlinien in der Entwicklertools-Konsole
Mit identitätsbasierten IAM-Richtlinien können Sie angeben, welche Aktionen und Ressourcen zugelassen oder abgelehnt werden. Darüber hinaus können Sie die Bedingungen festlegen, unter denen Aktionen zugelassen oder abgelehnt werden. AWS CodeStar Benachrichtigungen und AWS CodeConnections Support für spezifische Aktionen, Ressourcen und Bedingungsschlüssel. Informationen zu sämtlichen Elementen, die Sie in einer JSON-Richtlinie verwenden, finden Sie in der [IAM-Referenz für JSON-Richtlinienelemente](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) im *IAM-Benutzerhandbuch*.
### Aktionen
Administratoren können mithilfe von AWS JSON-Richtlinien angeben, wer auf was Zugriff hat. Das heißt, welcher **Prinzipal** **Aktionen** für welche **Ressourcen** und unter welchen **Bedingungen** ausführen kann.
Das Element `Action` einer JSON-Richtlinie beschreibt die Aktionen, mit denen Sie den Zugriff in einer Richtlinie zulassen oder verweigern können. Nehmen Sie Aktionen in eine Richtlinie auf, um Berechtigungen zur Ausführung des zugehörigen Vorgangs zu erteilen.
Richtlinienaktionen für Benachrichtigungen in der Entwicklertools-Konsole verwenden die folgenden Präfixe vor der Aktion: `codestar-notifications and codeconnections`. Um beispielsweise jemandem die Berechtigung zum Anzeigen aller Benachrichtigungsregeln in seinem Konto zu erteilen, fügen Sie die Aktion `codestar-notifications:ListNotificationRules` in seine Richtlinie ein. Richtlinienerklärungen müssen `Action` entweder ein `NotAction` Oder-Element enthalten. AWS CodeStar Benachrichtigungen und AWS CodeConnections definiert eigene Aktionen, die Aufgaben beschreiben, die Sie mit diesem Dienst ausführen können.
Um mehrere AWS CodeStar Benachrichtigungsaktionen in einer einzigen Anweisung anzugeben, trennen Sie sie wie folgt durch Kommas.
```
"Action": [
"codestar-notifications:action1",
"codestar-notifications:action2"
```
Um mehrere AWS CodeConnections Aktionen in einer einzigen Anweisung anzugeben, trennen Sie sie wie folgt durch Kommas.
```
"Action": [
"codeconnections:action1",
"codeconnections:action2"
```
Sie können auch Platzhalter (\$1) verwenden, um mehrere Aktionen anzugeben. Beispielsweise können Sie alle Aktionen festlegen, die mit dem Wort `List` beginnen, einschließlich der folgenden Aktion:
```
"Action": "codestar-notifications:List*"
```
AWS CodeStar Zu den API-Aktionen für Benachrichtigungen gehören:
+ `CreateNotificationRule`
+ `DeleteNotificationRule`
+ `DeleteTarget`
+ `DescribeNotificationRule`
+ `ListEventTypes`
+ `ListNotificationRules`
+ `ListTagsForResource`
+ `ListTargets`
+ `Subscribe`
+ `TagResource`
+ `Unsubscribe`
+ `UntagResource`
+ `UpdateNotificationRule`
AWS CodeConnections Zu den API-Aktionen gehören die folgenden:
+ `CreateConnection`
+ `DeleteConnection`
+ `GetConnection`
+ `ListConnections`
+ `ListTagsForResource`
+ `TagResource`
+ `UntagResource`
Die folgenden Aktionen, die nur für Berechtigungen bestimmt sind, sind erforderlich, AWS CodeConnections um den Auth-Handshake abzuschließen:
+ `GetIndividualAccessToken`
+ `GetInstallationUrl`
+ `ListInstallationTargets`
+ `StartOAuthHandshake`
+ `UpdateConnectionInstallation`
Für die Verwendung einer Verbindung ist die folgende Aktion nur für Berechtigungen erforderlich: AWS CodeConnections
+ `UseConnection`
Die folgende Aktion, bei der nur Berechtigungen erforderlich sind, ist erforderlich, um eine Verbindung AWS CodeConnections zu einem Dienst weiterzuleiten:
+ `PassConnection`
Eine Liste der AWS CodeStar Benachrichtigungen und AWS CodeConnections Aktionen finden Sie unter [Durch AWS CodeStar Benachrichtigungen definierte Aktionen](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_codestarnotifications.html#codestarnotifications-actions-as-permissions) und [Definierte Aktionen von AWS CodeConnections](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_codestarconnections.html#codestarconnections-actions-as-permissions) im *IAM-Benutzerhandbuch*.
### Ressourcen
AWS CodeStar Benachrichtigungen und unterstützen AWS CodeConnections nicht die Angabe von Ressourcen ARNs in einer Richtlinie.
### Bedingungsschlüssel
AWS CodeStar Benachrichtigungen und AWS CodeConnections definieren ihre eigenen Sätze von Bedingungsschlüsseln und unterstützen auch die Verwendung einiger globaler Bedingungsschlüssel. Eine Übersicht aller AWS globalen Bedingungsschlüssel finden Sie unter [Kontext-Schlüssel für AWS globale Bedingungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) im *IAM-Benutzerhandbuch*.
Alle AWS CodeStar Benachrichtigungsaktionen unterstützen den `codestar-notifications:NotificationsForResource` Bedingungsschlüssel. Weitere Informationen finden Sie unter [Beispiele für identitätsbasierte Richtlinien](security_iam_id-based-policy-examples.md).
AWS CodeConnections definieren Sie die folgenden Bedingungsschlüssel, die im `Condition` Element einer IAM-Richtlinie verwendet werden können. Diese Schlüssel können Sie verwenden, um die Bedingungen zu verfeinern, unter denen die Richtlinienanweisung angewendet wird. Weitere Informationen finden Sie unter [AWS CodeConnections Referenz zu Berechtigungen](security-iam.md#permissions-reference-connections).
| Bedingungsschlüssel | Description |
| --- | --- |
| `codeconnections:BranchName` | Filtert den Zugriff nach dem Namen der Verzweigung des Drittanbieter-Repositorys |
| `codeconnections:FullRepositoryId` | Filtert den Zugriff durch das Repository, das in der Anforderung übergeben wird. Gilt nur für UseConnection-Anforderungen für den Zugriff auf ein bestimmtes Repository |
| codeconnections:InstallationId | Filtert den Zugriff durch die Drittanbieter-ID (z. B. die Bitbucket-App-Installations-ID), die zum Ändern einer Verbindung verwendet wird. Schränkt ein, welche App-Installationen von Drittanbietern zum Herstellen einer Verbindung verwendet werden können |
| codeconnections:OwnerId | Filtert den Zugriff nach der ID vom Besitzer bzw. Konto des Drittanbieters |
| `codeconnections:PassedToService` | Filtert den Zugriff nach dem Service, an den der Prinzipal eine Verbindung übergeben darf |
| `codeconnections:ProviderAction` | Filtert den Zugriff nach der Anbieteraktion in einer UseConnection-Anforderung wie ListRepositories. |
| codeconnections:ProviderPermissionsRequired | Filtert den Zugriff nach dem Typ der Drittanbieter-Berechtigungen |
| `codeconnections:ProviderType` | Filtert den Zugriff nach dem Typ des Drittanbieters, der in der Anforderung übergeben wurde |
| codeconnections:ProviderTypeFilter | Filtert den Zugriff nach dem Typ des Drittanbieters, der zum Filtern der Ergebnisse verwendet wird |
| codeconnections:RepositoryName | Filtert den Zugriff nach dem Namen des Drittanbieter-Repositorys |
### Beispiele
Beispiele für AWS CodeStar Benachrichtigungen und AWS CodeConnections identitätsbasierte Richtlinien finden Sie unter. [Beispiele für identitätsbasierte Richtlinien](security_iam_id-based-policy-examples.md)
## AWS CodeStar Benachrichtigungen und ressourcenbasierte Richtlinien AWS CodeConnections
AWS CodeStar Benachrichtigungen und unterstützen AWS CodeConnections keine ressourcenbasierten Richtlinien.
## Autorisierung auf der Basis von Markierungen
Sie können Tags an AWS CodeStar Benachrichtigungen und AWS CodeConnections Ressourcen anhängen oder Tags in einer Anfrage weitergeben. Um den Zugriff auf der Grundlage von Tags zu steuern, geben Sie im Bedingungselement einer[ Richtlinie Tag-Informationen ](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html)an, indem Sie die Schlüssel `codestar-notifications and codeconnections:ResourceTag/key-name`, `aws:RequestTag/key-name`, oder Bedingung `aws:TagKeys` verwenden. Weitere Informationen zu Tagging-Strategien finden Sie unter Ressourcen [taggen AWS](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html). Weitere Informationen zum Markieren von AWS CodeStar Benachrichtigungen und AWS CodeConnections Ressourcen finden Sie unter. [Ressourcen für Tag-Verbindungen](connections-tag.md)
Ein Beispiel für eine identitätsbasierte Richtlinie zur Einschränkung des Zugriffs auf eine Ressource auf der Grundlage der Markierungen dieser Ressource finden Sie unter [Verwendung von Tags zur Steuerung des Zugriffs auf Ressourcen AWS CodeConnections](connections-tag-based-access-control.md).
## IAM-Rollen
Eine [IAM-Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) ist eine Entität innerhalb Ihres AWS Kontos, die über bestimmte Berechtigungen verfügt.
### Verwenden temporärer Anmeldeinformationen
Sie können temporäre Anmeldeinformationen verwenden, um sich über einen Verbund anzumelden, eine IAM-Rolle anzunehmen oder eine kontenübergreifende Rolle anzunehmen. Sie erhalten temporäre Sicherheitsanmeldedaten, indem Sie AWS STS API-Operationen wie [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)oder [GetFederationToken](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetFederationToken.html)aufrufen.
AWS CodeStar Benachrichtigungen und AWS CodeConnections unterstützt die Verwendung temporärer Anmeldeinformationen.
### Service-verknüpfte Rollen
Mit [dienstbezogenen Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) können AWS Dienste auf Ressourcen in anderen Diensten zugreifen, um eine Aktion in Ihrem Namen auszuführen. Serviceverknüpfte Rollen werden in Ihrem IAM-Konto angezeigt und gehören zum Service. Ein IAM-Administrator kann die Berechtigungen für serviceverknüpfte Rollen anzeigen, aber nicht bearbeiten.
AWS CodeStar Notifications unterstützt dienstbezogene Rollen. Einzelheiten zum Erstellen oder Verwalten von AWS CodeStar Benachrichtigungen und AWS CodeConnections dienstbezogenen Rollen finden Sie unter. [Verwenden von serviceverknüpften Rollen für Benachrichtigungen AWS CodeStar](using-service-linked-roles.md)
CodeConnections unterstützt keine dienstbezogenen Rollen.
## AWS CodeConnections Referenz zu Berechtigungen
In den folgenden Tabellen sind die einzelnen AWS CodeConnections API-Operationen, die entsprechenden Aktionen, für die Sie Berechtigungen erteilen können, und das Format des Ressourcen-ARN aufgeführt, der für die Erteilung von Berechtigungen verwendet werden soll. Sie AWS CodeConnections APIs sind auf der Grundlage des Umfangs der Aktionen, die von dieser API zugelassen sind, in Tabellen gruppiert. Verwenden Sie sie als Referenz, wenn Sie Berechtigungsrichtlinien für eine IAM-Identität (identitätsbasierte Richtlinie) verfassen.
Beim Erstellen einer Berechtigungsrichtlinie geben Sie die Aktionen im Feld `Action` der Richtlinie an. Sie geben den Ressourcenwert im Feld `Resource` der Richtlinie als ARN mit oder ohne Platzhalterzeichen (\$1) an.
Bedingungen in Ihren Verbindungsrichtlinien können Sie mit den Bedingungsschlüsseln ausdrücken, die hier beschrieben und unter [Bedingungsschlüssel](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-conditionkeys) aufgeführt sind. Sie können auch Bedingungsschlüssel für AWS alle Bereiche verwenden. Eine vollständige Liste der AWS-weiten Schlüssel finden Sie unter [Verfügbare Schlüssel](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#AvailableKeys) im *IAM-Benutzerhandbuch*.
Um eine Aktion anzugeben, verwenden Sie das Präfix `codeconnections` gefolgt vom Namen der API-Operation (z. B. `codeconnections:ListConnections` oder `codeconnections:CreateConnection`).
**Verwenden von Platzhaltern **
Sie können ein Platzhalterzeichen (\$1) in Ihrem ARN verwenden, um mehrere Aktionen oder Ressourcen anzugeben. `codeconnections:*`Gibt beispielsweise alle Aktionen an und gibt alle AWS CodeConnections Aktionen `codeconnections:Get*` an, die mit dem Wort beginnen. AWS CodeConnections `Get` Im folgenden Beispiel wird der Zugriff auf alle Ressourcen erteilt, deren Name mit `MyConnection` beginnt.
```
arn:aws:codeconnections:us-west-2:account-ID:connection/*
```
Sie können Platzhalter nur für die in der folgenden Tabelle aufgeführten *connection* Ressourcen verwenden. Sie können Platzhalter nicht zusammen mit *region* Ressourcen verwenden. *account-id* Weitere Informationen zu Platzhaltern finden Sie unter [IAM Identifiers](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html) im *Benutzerhandbuch von IAM*.
**Topics**
+ [Berechtigungen zum Verwalten von Verbindungen](#permissions-reference-connections-managing)
+ [Berechtigungen zum Verwalten von Hosts](#permissions-reference-connections-hosts)
+ [Berechtigungen zum Abschließen von Verbindungen](#permissions-reference-connections-handshake)
+ [Berechtigungen zum Einrichten von Hosts](#connections-permissions-actions-host-registration)
+ [Übergeben einer Verbindung an einen Service](#permissions-reference-connections-passconnection)
+ [Verwenden einer Verbindung](#permissions-reference-connections-use)
+ [Unterstützte Zugriffstypen für `ProviderAction`](#permissions-reference-connections-access)
+ [Unterstütze Berechtigungen für das Markieren von Verbindungsressourcen](#permissions-reference-connections-tagging)
+ [Übergeben einer Verbindung an einen Repository-Link](#permissions-reference-connections-passrepository)
+ [Unterstützter Bedingungsschlüssel für Repository-Links](#permissions-reference-connections-branch)
+ [Unterstützte Berechtigungen für die gemeinsame Nutzung von Verbindungen](#permissions-reference-connections-sharing)
### Berechtigungen zum Verwalten von Verbindungen
Eine Rolle oder ein Benutzer, der das SDK AWS CLI oder das SDK zum Anzeigen, Erstellen oder Löschen von Verbindungen verwendet, sollte über folgende Berechtigungen verfügen.
**Anmerkung**
Sie können in der Konsole keine Verbindung nur mit den folgenden Berechtigungen herstellen oder verwenden. Sie müssen die Berechtigungen in [Berechtigungen zum Abschließen von Verbindungen](#permissions-reference-connections-handshake) hinzufügen.
```
codeconnections:CreateConnection
codeconnections:DeleteConnection
codeconnections:GetConnection
codeconnections:ListConnections
```
Mit den Bildlaufleisten können Sie den Rest der Tabelle sehen.
**AWS CodeConnections erforderliche Berechtigungen für die Verwaltung von Verbindungen**
| AWS CodeConnections Aktionen | Erforderliche Berechtigungen | Ressourcen |
| --- | --- | --- |
| CreateConnection | `codeconnections:CreateConnection` Ist erforderlich, um mit der CLI bzw. der Konsole eine Verbindung zu erstellen. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| DeleteConnection | `codeconnections:DeleteConnection` Ist erforderlich, um mit der CLI bzw. der Konsole eine Verbindung zu löschen. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| GetConnection | `codeconnections:GetConnection` Ist erforderlich, um mit der CLI bzw. der Konsole Details zu einer Verbindung zu sehen. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| ListConnections | `codeconnections:ListConnections` Ist erforderlich, um mit der CLI bzw. der Konsole alle Verbindungen im Konto zu sehen. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
Diese Vorgänge unterstützen die folgenden Bedingungsschlüssel:
| Action | Bedingungsschlüssel |
| --- | --- |
| `codeconnections:CreateConnection` | `codeconnections:ProviderType` |
| codeconnections:DeleteConnection | – |
| codeconnections:GetConnection | – |
| codeconnections:ListConnections | codeconnections:ProviderTypeFilter |
### Berechtigungen zum Verwalten von Hosts
Eine Rolle oder ein Benutzer, der AWS CLI bzw. der das SDK zum Anzeigen, Erstellen oder Löschen von Hosts verwenden soll, sollte über folgende Berechtigungen verfügen.
**Anmerkung**
Sie können im Host keine Verbindung herstellen oder verwenden, wenn nur die folgenden Berechtigungen vorhanden sind. Sie müssen die Berechtigungen in [Berechtigungen zum Einrichten von Hosts](#connections-permissions-actions-host-registration) hinzufügen.
```
codeconnections:CreateHost
codeconnections:DeleteHost
codeconnections:GetHost
codeconnections:ListHosts
```
Mit den Bildlaufleisten können Sie den Rest der Tabelle sehen.
**AWS CodeConnections erforderliche Berechtigungen für die Verwaltung von Hosts**
| AWS CodeConnections Aktionen | Erforderliche Berechtigungen | Ressourcen |
| --- | --- | --- |
| CreateHost | `codeconnections:CreateHost` Ist erforderlich, um mit der CLI bzw. der Konsole einen Host zu erstellen. | arn:aws:codeconnections: ::host/ *region* *account-id* *host-id* |
| DeleteHost | `codeconnections:DeleteHost` Ist erforderlich, um mit der CLI bzw. der Konsole einen Host zu löschen. | Codeverbindungen: ::host/ *region* *account-id* *host-id* |
| GetHost | `codeconnections:GetHost` Ist erforderlich, um mit der CLI bzw. der Konsole Details zu einem Host zu sehen. | *region*arn:aws:codeconnections: ::host/ *account-id* *host-id* |
| ListHosts | `codeconnections:ListHosts` Ist erforderlich, um mit der CLI bzw. der Konsole alle Hosts im Konto zu sehen. | arn:aws:codeconnections: *region* ::host/ *account-id* *host-id* |
Diese Vorgänge unterstützen die folgenden Bedingungsschlüssel:
| Action | Bedingungsschlüssel |
| --- | --- |
| `codeconnections:CreateHost` | `codeconnections:ProviderType` `codeconnections:VpcId` |
| codeconnections:DeleteHost | – |
| codeconnections:GetHost | – |
| codeconnections:ListHosts | codeconnections:ProviderTypeFilter |
Ein Beispiel für eine Richtlinie, die den **VpcId**Bedingungsschlüssel verwendet, finden Sie unter[Beispiel: Beschränken Sie die VPC-Berechtigungen für Hosts mithilfe des **VpcId**Kontextschlüssels](security_iam_id-based-policy-examples-connections.md#security_iam_id-based-policy-examples-connections-vpc).
### Berechtigungen zum Abschließen von Verbindungen
Eine Rolle oder ein Benutzer, die bzw. der zum Verwalten von Verbindungen in der Konsole bestimmt ist, sollte über die erforderlichen Berechtigungen verfügen, um eine Verbindung in der Konsole abzuschließen und eine Installation zu erstellen. Dazu gehören das Autorisieren des Handshakes beim Anbieter und das Erstellen von Installationen für Verbindungen. Verwenden Sie die folgenden Berechtigungen zusätzlich zu den oben genannten Berechtigungen.
Die folgenden IAM-Vorgänge werden von der Konsole verwendet, wenn Sie einen browserbasierten Handshake ausführen. `ListInstallationTargets`, `GetInstallationUrl`, `StartOAuthHandshake`, `UpdateConnectionInstallation` und `GetIndividualAccessToken` sind IAM-Richtlinienberechtigungen. Es handelt sich dabei nicht um API-Aktionen.
```
codeconnections:GetIndividualAccessToken
codeconnections:GetInstallationUrl
codeconnections:ListInstallationTargets
codeconnections:StartOAuthHandshake
codeconnections:UpdateConnectionInstallation
```
Auf dieser Grundlage sind die folgenden Berechtigungen erforderlich, um eine Verbindung in der Konsole zu verwenden, zu erstellen, zu ändern oder zu löschen:
```
codeconnections:CreateConnection
codeconnections:DeleteConnection
codeconnections:GetConnection
codeconnections:ListConnections
codeconnections:UseConnection
codeconnections:ListInstallationTargets
codeconnections:GetInstallationUrl
codeconnections:StartOAuthHandshake
codeconnections:UpdateConnectionInstallation
codeconnections:GetIndividualAccessToken
```
Mit den Bildlaufleisten können Sie den Rest der Tabelle sehen.
**AWS CodeConnections erforderliche Berechtigungen für das Herstellen von Verbindungen**
| AWS CodeConnections Aktionen | Erforderliche Berechtigungen | Ressourcen |
| --- | --- | --- |
| `GetIndividualAccessToken` | `codeconnections:GetIndividualAccessToken` Ist erforderlich, um mit der Konsole eine Verbindung abzuschließen. Dies ist nur eine IAM-Richtlinienberechtigung, keine API-Aktion. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `GetInstallationUrl` | `codeconnections:GetInstallationUrl` Ist erforderlich, um mit der Konsole eine Verbindung abzuschließen. Dies ist nur eine IAM-Richtlinienberechtigung, keine API-Aktion. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `ListInstallationTargets` | `codeconnections:ListInstallationTargets` Ist erforderlich, um mit der Konsole eine Verbindung abzuschließen. Dies ist nur eine IAM-Richtlinienberechtigung, keine API-Aktion. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `StartOAuthHandshake` | `codeconnections:StartOAuthHandshake` Ist erforderlich, um mit der Konsole eine Verbindung abzuschließen. Dies ist nur eine IAM-Richtlinienberechtigung, keine API-Aktion. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `UpdateConnectionInstallation` | `codeconnections:UpdateConnectionInstallation` Ist erforderlich, um mit der Konsole eine Verbindung abzuschließen. Dies ist nur eine IAM-Richtlinienberechtigung, keine API-Aktion. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
Diese Vorgänge unterstützen die folgenden Bedingungsschlüssel:
| Action | Bedingungsschlüssel |
| --- | --- |
| codeconnections:GetIndividualAccessToken | codeconnections:ProviderType |
| codeconnections:GetInstallationUrl | codeconnections:ProviderType |
| `codeconnections:ListInstallationTargets` | – |
| codeconnections:StartOAuthHandshake | codeconnections:ProviderType |
| codeconnections:UpdateConnectionInstallation | codeconnections:InstallationId |
### Berechtigungen zum Einrichten von Hosts
Eine Rolle oder ein Benutzer, die bzw. der zum Verwalten von Verbindungen in der Konsole bestimmt ist, sollte über die erforderlichen Berechtigungen verfügen, um einen Host in der Konsole zu erstellen. Dazu gehören das Autorisieren des Handshakes beim Anbieter und das Installieren der Host-App. Verwenden Sie die folgenden Berechtigungen zusätzlich zu den oben genannten Berechtigungen für Hosts.
Die folgenden IAM-Vorgänge werden von der Konsole verwendet, wenn Sie eine browserbasierte Hostregistrierung durchführen. `RegisterAppCode` und `StartAppRegistrationHandshake` sind IAM-Richtlinienberechtigungen. Es handelt sich dabei nicht um API-Aktionen.
```
codeconnections:RegisterAppCode
codeconnections:StartAppRegistrationHandshake
```
Dementsprechend sind die folgenden Berechtigungen erforderlich, damit Sie eine Verbindung in der Konsole verwenden, erstellen, ändern oder löschen können, für die ein Host erforderlich ist (z. B. installierte Anbietertypen).
```
codeconnections:CreateConnection
codeconnections:DeleteConnection
codeconnections:GetConnection
codeconnections:ListConnections
codeconnections:UseConnection
codeconnections:ListInstallationTargets
codeconnections:GetInstallationUrl
codeconnections:StartOAuthHandshake
codeconnections:UpdateConnectionInstallation
codeconnections:GetIndividualAccessToken
codeconnections:RegisterAppCode
codeconnections:StartAppRegistrationHandshake
```
Mit den Bildlaufleisten können Sie den Rest der Tabelle sehen.
**AWS CodeConnections erforderliche Berechtigungen für den Abschluss des Host-Setups**
| Verbindungen und Aktionen | Erforderliche Berechtigungen | Ressourcen |
| --- | --- | --- |
| `RegisterAppCode` | `codeconnections:RegisterAppCode` Erforderlich, um die Hosteinrichtung mit der Konsole abzuschließen. Dies ist nur eine IAM-Richtlinienberechtigung, keine API-Aktion. | arn:aws:codeconnections: ::host/ *region* *account-id* *host-id* |
| `StartAppRegistrationHandshake` | `codeconnections:StartAppRegistrationHandshake` Erforderlich, um die Hosteinrichtung mit der Konsole abzuschließen. Dies ist nur eine IAM-Richtlinienberechtigung, keine API-Aktion. | arn:aws:codeconnections: *region* ::host/ *account-id* *host-id* |
Diese Vorgänge unterstützen die folgenden Bedingungsschlüssel:
### Übergeben einer Verbindung an einen Service
Wenn eine Verbindung an einen Service übergeben wird (z. B. wenn ein Verbindungs-ARN in einer Pipeline-Definition bereitgestellt wird, um eine Pipeline zu erstellen oder zu ändern), muss der Benutzer über die `codeconnections:PassConnection`-Berechtigung verfügen.
Mit den Bildlaufleisten können Sie den Rest der Tabelle sehen.
**AWS CodeConnections erforderliche Berechtigungen für die Weitergabe einer Verbindung**
| AWS CodeConnections Aktionen | Erforderliche Berechtigungen | Ressourcen |
| --- | --- | --- |
| `PassConnection` | `codeconnections:PassConnection` Ist erforderlich, um eine Verbindung an einen Service zu übergeben. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
Dieser Vorgang unterstützt auch den folgenden Bedingungsschlüssel:
+ `codeconnections:PassedToService`
**Unterstützte Werte für Bedingungsschlüssel**
| Key (Schlüssel) | Gültige Aktionsanbieter |
| --- | --- |
| `codeconnections:PassedToService` | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/dtconsole/latest/userguide/security-iam.html) |
### Verwenden einer Verbindung
Wenn ein Dienst wie eine Verbindung CodePipeline verwendet, muss die Dienstrolle über die `codeconnections:UseConnection` Berechtigung für eine bestimmte Verbindung verfügen.
Um Verbindungen in der Konsole zu verwalten, muss die Benutzerrichtlinie die `codeconnections:UseConnection`-Berechtigung haben.
Mit den Bildlaufleisten können Sie den Rest der Tabelle sehen.
**AWS CodeConnections erforderliche Aktion für die Verwendung von Verbindungen**
| AWS CodeConnections Aktionen | Erforderliche Berechtigungen | Ressourcen |
| --- | --- | --- |
| `UseConnection` | `codeconnections:UseConnection` Ist erforderlich zum Verwenden einer Verbindung. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
Dieser Vorgang unterstützt auch die folgenden Bedingungsschlüssel:
+ `codeconnections:BranchName`
+ `codeconnections:FullRepositoryId`
+ `codeconnections:OwnerId`
+ `codeconnections:ProviderAction`
+ `codeconnections:ProviderPermissionsRequired`
+ `codeconnections:RepositoryName`
**Unterstützte Werte für Bedingungsschlüssel**
| Key (Schlüssel) | Gültige Aktionsanbieter |
| --- | --- |
| `codeconnections:FullRepositoryId` | Der Benutzername und der Repository-Name eines Repositorys, wie etwa `my-owner/my-repository`. Wird nur unterstützt, wenn die Verbindung für den Zugriff auf ein bestimmtes Repository verwendet wird. |
| `codeconnections:ProviderPermissionsRequired` | read\$1only oder read\$1write |
| `codeconnections:ProviderAction` | `GetBranch`, `ListRepositories`, `ListOwners`, `ListBranches`, `StartUploadArchiveToS3`, `GitPush`, `GitPull`, `GetUploadArchiveToS3Status`, `CreatePullRequestDiffComment`, `GetPullRequest`, `ListBranchCommits`, `ListCommitFiles`, `ListPullRequestComments`, `ListPullRequestCommits`. Weitere Informationen finden Sie im folgenden Abschnitt. |
Die erforderlichen Bedingungsschlüssel für einige Funktionen können sich im Laufe der Zeit ändern. Es wird empfohlen, den Zugriff auf eine Verbindung mit `codeconnections:UseConnection` zu kontrollieren, es sei denn, Ihre Zugriffskontrollanforderungen erfordern andere Berechtigungen.
### Unterstützte Zugriffstypen für `ProviderAction`
Wenn eine Verbindung von einem AWS Dienst verwendet wird, führt dies dazu, dass API-Aufrufe an Ihren Quellcode-Anbieter getätigt werden. Beispielsweise kann ein Service Repositorys für eine Bitbucket-Verbindung auflisten, indem er die `https://api.bitbucket.org/2.0/repositories/username`-API aufruft.
Mit dem `ProviderAction` Bedingungsschlüssel können Sie einschränken, welcher APIs Anbieter aufgerufen werden kann. Da der API-Pfad möglicherweise dynamisch generiert wird und der Pfad von Anbieter zu Anbieter variiert, wird der `ProviderAction`-Wert einem abstrakten Aktionsnamen und nicht der URL der API zugeordnet. Auf diese Weise können Sie Richtlinien schreiben, die unabhängig vom Anbietertyp für die Verbindung dieselbe Wirkung haben.
Im Folgenden sind die Zugriffstypen aufgeführt, die für jeden der unterstützten `ProviderAction`-Werte gewährt werden. Das folgende Beispiel zeigt IAM-Richtlinienberechtigungen. Es handelt sich dabei nicht um API-Aktionen.
Mit den Bildlaufleisten können Sie den Rest der Tabelle sehen.
**AWS CodeConnections unterstützte Zugriffsarten für `ProviderAction`**
| AWS CodeConnections Erlaubnis | Erforderliche Berechtigungen | Ressourcen |
| --- | --- | --- |
| `GetBranch` | ` codeconnections:GetBranch` Ist erforderlich zum Zugreifen auf Informationen über eine Verzweigung, z. B. das letzte Commit für diese Verzweigung. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `ListRepositories` | ` codeconnections:ListRepositories` Ist erforderlich zum Abrufen einer Liste von öffentlichen und privaten Repositorys, einschließlich Details zu den Repositorys, die einem Besitzer gehören. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `ListOwners` | `codeconnections:ListOwners` Ist erforderlich zum Aufrufen einer Liste von Besitzern, auf die die Verbindung Zugriff hat. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `ListBranches` | ` codeconnections:ListBranches` Ist erforderlich zum Abrufen einer Liste der Verzweigungen, die in einem bestimmten Repository vorhanden sind. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `StartUploadArchiveToS3` | ` codeconnections:StartUploadArchiveToS3` Ist erforderlich, um den Quellcode zu lesen und auf Amazon S3 hochzuladen. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `GitPush` | ` codeconnections:GitPush` Ist erforderlich zum Schreiben eines Repositorys mit Git. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `GitPull` | ` codeconnections:GitPull` Ist erforderlich zum Lesen eines Git aus einem Repository. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| GetUploadArchiveToS3Status | ` codeconnections:GetUploadArchiveToS3Status` Ist erforderlich zum Aufrufen des Status eines Uploads, einschließlich aller Fehlermeldungen, die von `StartUploadArchiveToS3` gestartet werden. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| CreatePullRequestDiffComment | ` codeconnections:CreatePullRequestDiffComment` Ist erforderlich für den Zugriff auf Kommentare zu einer Pull-Anforderung. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| GetPullRequest | ` codeconnections:GetPullRequest` Ist erforderlich zum Anzeigen von Pull-Anforderungen für ein Repository. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `ListBranchCommits` | ` codeconnections:ListBranchCommits` Ist erforderlich zum Anzeigen einer Liste von Commits für eine Repository-Verzweigung. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `ListCommitFiles` | ` codeconnections:ListCommitFiles` Ist erforderlich zum Anzeigen einer Liste von Dateien für ein Commit. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `ListPullRequestComments` | ` codeconnections:ListPullRequestComments` Ist erforderlich zum Anzeigen einer Liste mit Kommentaren für eine Pull-Anforderung. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `ListPullRequestCommits` | ` codeconnections:ListPullRequestCommits` Ist erforderlich zum Anzeigen einer Liste von Commits für eine Pull-Anforderung. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
### Unterstütze Berechtigungen für das Markieren von Verbindungsressourcen
Die folgenden IAM-Vorgänge werden beim Markieren von Verbindungsressourcen verwendet.
```
codeconnections:ListTagsForResource
codeconnections:TagResource
codeconnections:UntagResource
```
Mit den Bildlaufleisten können Sie den Rest der Tabelle sehen.
**AWS CodeConnections erforderliche Aktionen zum Markieren von Verbindungsressourcen**
| AWS CodeConnections Aktionen | Erforderliche Berechtigungen | Ressourcen |
| --- | --- | --- |
| `ListTagsForResource` | `codeconnections:ListTagsForResource` Ist erforderlich zum Anzeigen einer Liste von Markierungen, die mit der Verbindungsressource verknüpft sind. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id*,arn:aws:codeconnections: *region* ::host/ *account-id* *host-id* |
| `TagResource` | `codeconnections:TagResource` Ist erforderlich zum Markieren einer Verbindungsressource. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id*,arn:aws:codeconnections: *region* ::host/ *account-id* *host-id* |
| `UntagResource` | `codeconnections:UntagResource` Ist erforderlich zum Entfernen von Markierungen bei einer Ressource. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id*,arn:aws:codeconnections: *region* ::host/ *account-id* *host-id* |
### Übergeben einer Verbindung an einen Repository-Link
Wenn ein Repository-Link in einer Synchronisierungskonfiguration bereitgestellt wird, muss der Benutzer über die `codeconnections:PassRepository`-Berechtigung für den Repository-Link ARN/die Resource verfügen.
Mit den Bildlaufleisten können Sie den Rest der Tabelle sehen.
**AWS CodeConnections erforderliche Berechtigungen für das Weiterleiten einer Verbindung**
| AWS CodeConnections Aktionen | Erforderliche Berechtigungen | Ressourcen |
| --- | --- | --- |
| `PassRepository` | `codeconnections:PassRepository` Dies ist erforderlich, um einen Repository-Link an eine Synchronisierungskonfiguration zu übergeben. | arn:aws:codeconnections: ::repository-link/ *region* *account-id* *repository-link-id* |
Dieser Vorgang unterstützt auch den folgenden Bedingungsschlüssel:
+ `codeconnections:PassedToService`
**Unterstützte Werte für Bedingungsschlüssel**
| Key (Schlüssel) | Gültige Aktionsanbieter |
| --- | --- |
| `codeconnections:PassedToService` | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/dtconsole/latest/userguide/security-iam.html) |
### Unterstützter Bedingungsschlüssel für Repository-Links
Operationen für Repository-Links und Sync-Konfigurationsressourcen werden durch den folgenden Bedingungsschlüssel unterstützt:
+ `codeconnections:Branch`
Filtert den Zugriff nach dem Zweignamen, der in der Anforderung übergeben wird.
**Unterstützte Aktionen für den Bedingungsschlüssel**
| Key (Schlüssel) | Zulässige Werte |
| --- | --- |
| `codeconnections:Branch` | Die folgenden Aktionen werden für diesen Bedingungsschlüssel unterstützt:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/dtconsole/latest/userguide/security-iam.html) |
### Unterstützte Berechtigungen für die gemeinsame Nutzung von Verbindungen
Die folgenden IAM-Operationen werden beim Teilen von Verbindungen verwendet.
```
codeconnections:GetResourcePolicy
```
Mit den Bildlaufleisten können Sie den Rest der Tabelle sehen.
**AWS CodeConnections erforderliche Aktionen für die gemeinsame Nutzung von Verbindungen**
| AWS CodeConnections Aktionen | Erforderliche Berechtigungen | Ressourcen |
| --- | --- | --- |
| `GetResourcePolicy` | `codeconnections:GetResourcePolicy` Erforderlich, um auf Informationen zur Ressourcenrichtlinie zuzugreifen. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
Weitere Informationen zur gemeinsamen Nutzung von Verbindungen finden Sie unter[Verbindungen teilen mit AWS-Konten](connections-share.md).
# Beispiele für identitätsbasierte Richtlinien
Standardmäßig verfügen IAM-Benutzer und -Rollen, auf die eine der verwalteten Richtlinien für AWS CodeCommit, AWS CodeBuild, oder AWS CodePipeline angewendet wurde AWS CodeDeploy, über Berechtigungen für Verbindungen, Benachrichtigungen und Benachrichtigungsregeln, die der Absicht dieser Richtlinien entsprechen. Beispielsweise haben IAM-Benutzer oder -Rollen, auf die eine der Vollzugriffsrichtlinien (**AWSCodeCommitFullAccess**, **AWSCodeBuildAdminAccess**AWSCodeDeployFullAccess****, oder **AWSCodePipeline\$1FullAccess**) angewendet wurde, auch vollen Zugriff auf Benachrichtigungen und Benachrichtigungsregeln, die für die Ressourcen dieser Dienste erstellt wurden.
Andere IAM-Benutzer und -Rollen sind nicht berechtigt, AWS CodeStar Benachrichtigungen und AWS CodeConnections Ressourcen zu erstellen oder zu ändern. Sie können auch keine Aufgaben mit der AWS-Managementkonsole AWS CLI, oder AWS API ausführen. Ein IAM-Administrator muss IAM-Richtlinien erstellen, die Benutzern und Rollen die Berechtigung zum Ausführen bestimmter API-Operationen für die angegebenen Ressourcen gewähren, die diese benötigen. Der Administrator muss diese Richtlinien anschließend den IAM-Benutzern oder -Gruppen anfügen, die diese Berechtigungen benötigen.
# Berechtigungen und Beispiele für AWS CodeStar Benachrichtigungen
Die folgenden Richtlinienerklärungen und Beispiele können Ihnen bei der Verwaltung von AWS CodeStar Benachrichtigungen helfen.
## Berechtigungen in Zusammenhang mit Benachrichtigungen in verwalteten Vollzugriffsrichtlinien
Die **AWSCodePipeline\$1FullAccess**verwalteten Richtlinien **AWSCodeCommitFullAccess**AWSCodeBuildAdminAccess**AWSCodeDeployFullAccess******,, und enthalten die folgenden Anweisungen, um vollen Zugriff auf Benachrichtigungen in der Developer Tools-Konsole zu ermöglichen. Benutzer, für die eine dieser verwalteten Richtlinien angewendet ist, können auch Amazon-SNS-Themen für Benachrichtigungen erstellen und verwalten, Benutzer für Themen abonnieren und Abonnements beenden sowie Themen auflisten, die als Ziele für Benachrichtigungsregeln ausgewählt werden sollen.
**Anmerkung**
In der verwalteten Richtlinie hat der Bedingungsschlüssel `codestar-notifications:NotificationsForResource` einen für den Ressourcentyp für den Service spezifischen Wert. In der Vollzugriffsrichtlinie für CodeCommit lautet der Wert beispielsweise`arn:aws:codecommit:*`.
```
{
"Sid": "CodeStarNotificationsReadWriteAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:CreateNotificationRule",
"codestar-notifications:DescribeNotificationRule",
"codestar-notifications:UpdateNotificationRule",
"codestar-notifications:DeleteNotificationRule",
"codestar-notifications:Subscribe",
"codestar-notifications:Unsubscribe"
],
"Resource": "*",
"Condition" : {
"StringLike" : {"codestar-notifications:NotificationsForResource" : "arn:aws::*"}
}
},
{
"Sid": "CodeStarNotificationsListAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:ListNotificationRules",
"codestar-notifications:ListTargets",
"codestar-notifications:ListTagsforResource",
"codestar-notifications:ListEventTypes"
],
"Resource": "*"
},
{
"Sid": "CodeStarNotificationsSNSTopicCreateAccess",
"Effect": "Allow",
"Action": [
"sns:CreateTopic",
"sns:SetTopicAttributes"
],
"Resource": "arn:aws:sns:*:*:codestar-notifications*"
},
{
"Sid": "SNSTopicListAccess",
"Effect": "Allow",
"Action": [
"sns:ListTopics"
],
"Resource": "*"
},
{
"Sid": "CodeStarNotificationsChatbotAccess",
"Effect": "Allow",
"Action": [
"chatbot:DescribeSlackChannelConfigurations",
"chatbot:ListMicrosoftTeamsChannelConfigurations"
],
"Resource": "*"
}
```
## Berechtigungen in Zusammenhang mit Benachrichtigungen in schreibgeschützten verwalteten Richtlinien
Die **AWSCodePipeline\$1ReadOnlyAccess**verwalteten Richtlinien **AWSCodeCommitReadOnlyAccess**AWSCodeBuildReadOnlyAccess**AWSCodeDeployReadOnlyAccess******,, und enthalten die folgenden Anweisungen, um den schreibgeschützten Zugriff auf Benachrichtigungen zu ermöglichen. So können beispielsweise Benachrichtigungen für Ressourcen in der Entwicklertools-Konsole angezeigt, nicht jedoch erstellt, verwaltet oder abonniert werden.
**Anmerkung**
In der verwalteten Richtlinie hat der Bedingungsschlüssel `codestar-notifications:NotificationsForResource` einen für den Ressourcentyp für den Service spezifischen Wert. In der Vollzugriffsrichtlinie für CodeCommit lautet der Wert beispielsweise. `arn:aws:codecommit:*`
```
{
"Sid": "CodeStarNotificationsPowerUserAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:DescribeNotificationRule"
],
"Resource": "*",
"Condition" : {
"StringLike" : {"codestar-notifications:NotificationsForResource" : "arn:aws::*"}
}
},
{
"Sid": "CodeStarNotificationsListAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:ListNotificationRules",
"codestar-notifications:ListEventTypes",
"codestar-notifications:ListTargets"
],
"Resource": "*"
}
```
## Berechtigungen in Zusammenhang mit Benachrichtigungen in anderen verwalteten Richtlinien
Die **AWSCodeBuildDeveloperAccess**verwalteten Richtlinien **AWSCodeCommitPowerUser**AWSCodeBuildDeveloperAccess****, und enthalten die folgenden Anweisungen, damit Entwickler, auf die eine dieser verwalteten Richtlinien angewendet wurde, Benachrichtigungen erstellen, bearbeiten und abonnieren können. Sie können Benachrichtigungsregeln nicht löschen und auch keine Tags für Ressourcen verwalten.
**Anmerkung**
In der verwalteten Richtlinie hat der Bedingungsschlüssel `codestar-notifications:NotificationsForResource` einen für den Ressourcentyp für den Service spezifischen Wert. In der Vollzugriffsrichtlinie für CodeCommit lautet der Wert beispielsweise`arn:aws:codecommit:*`.
```
{
"Sid": "CodeStarNotificationsReadWriteAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:CreateNotificationRule",
"codestar-notifications:DescribeNotificationRule",
"codestar-notifications:UpdateNotificationRule",
"codestar-notifications:Subscribe",
"codestar-notifications:Unsubscribe"
],
"Resource": "*",
"Condition" : {
"StringLike" : {"codestar-notifications:NotificationsForResource" : "arn:aws::*"}
}
},
{
"Sid": "CodeStarNotificationsListAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:ListNotificationRules",
"codestar-notifications:ListTargets",
"codestar-notifications:ListTagsforResource",
"codestar-notifications:ListEventTypes"
],
"Resource": "*"
},
{
"Sid": "SNSTopicListAccess",
"Effect": "Allow",
"Action": [
"sns:ListTopics"
],
"Resource": "*"
},
{
"Sid": "CodeStarNotificationsChatbotAccess",
"Effect": "Allow",
"Action": [
"chatbot:DescribeSlackChannelConfigurations",
"chatbot:ListMicrosoftTeamsChannelConfigurations"
],
"Resource": "*"
}
```
## Beispiel: Eine Richtlinie auf Administratorebene für die Verwaltung von Benachrichtigungen AWS CodeStar
In diesem Beispiel möchten Sie einem IAM-Benutzer in Ihrem AWS Konto vollen Zugriff auf AWS CodeStar Benachrichtigungen gewähren, sodass der Benutzer die Details der Benachrichtigungsregeln überprüfen und Benachrichtigungsregeln, Ziele und Ereignistypen auflisten kann. Sie möchten dem Benutzer außerdem Berechtigungen zum Hinzufügen, Ändern und Löschen von Benachrichtigungsregeln gewähren. Dabei handelt es sich um eine Vollzugriffsrichtlinie, die den Benachrichtigungsberechtigungen entspricht, die in den Richtlinien **AWSCodeBuildAdminAccess**, **AWSCodeCommitFullAccess**AWSCodeDeployFullAccess****, und den **AWSCodePipeline\$1FullAccess**verwalteten Richtlinien enthalten sind. Wie bei diesen verwalteten Richtlinien sollten Sie diese Art von Richtlinienerklärung nur an IAM-Benutzer, -Gruppen oder -Rollen anhängen, die vollen Administratorzugriff auf Benachrichtigungen und Benachrichtigungsregeln in Ihrem gesamten AWS Konto benötigen.
**Anmerkung**
Diese Richtlinie beinhaltet `CreateNotificationRule`. Jeder Benutzer, für den diese Richtlinie auf seinen IAM-Benutzer oder seine IAM-Rolle angewendet wird, kann Benachrichtigungsregeln für alle Ressourcentypen erstellen, die von AWS CodeStar Benachrichtigungen im AWS Konto unterstützt werden, auch wenn dieser Benutzer selbst keinen Zugriff auf diese Ressourcen hat. Ein Benutzer mit dieser Richtlinie könnte beispielsweise eine Benachrichtigungsregel für ein CodeCommit Repository erstellen, ohne über die erforderlichen Zugriffsrechte zu verfügen CodeCommit.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AWSCodeStarNotificationsFullAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:CreateNotificationRule",
"codestar-notifications:DeleteNotificationRule",
"codestar-notifications:DescribeNotificationRule",
"codestar-notifications:ListNotificationRules",
"codestar-notifications:UpdateNotificationRule",
"codestar-notifications:Subscribe",
"codestar-notifications:Unsubscribe",
"codestar-notifications:DeleteTarget",
"codestar-notifications:ListTargets",
"codestar-notifications:ListTagsforResource",
"codestar-notifications:TagResource",
"codestar-notifications:UntagResource"
],
"Resource": "*"
}
]
}
```
------
## Beispiel: Eine Richtlinie auf Mitwirkendenebene für die Verwendung von Benachrichtigungen AWS CodeStar
In diesem Beispiel möchten Sie Zugriff auf die day-to-day Verwendung von AWS CodeStar Benachrichtigungen gewähren, z. B. auf das Erstellen und Abonnieren von Benachrichtigungen, aber nicht auf destruktivere Aktionen wie das Löschen von Benachrichtigungsregeln oder -zielen. Dies entspricht dem Zugriff, der in den **AWSCodeCommitPowerUser**verwalteten Richtlinien **AWSCodeBuildDeveloperAccess**AWSCodeDeployDeveloperAccess****, und bereitgestellt wird.
**Anmerkung**
Diese Richtlinie beinhaltet `CreateNotificationRule`. Jeder Benutzer, für den diese Richtlinie auf seinen IAM-Benutzer oder seine IAM-Rolle angewendet wurde, kann Benachrichtigungsregeln für alle Ressourcentypen erstellen, die von AWS CodeStar Benachrichtigungen im AWS Konto unterstützt werden, auch wenn dieser Benutzer selbst keinen Zugriff auf diese Ressourcen hat. Ein Benutzer mit dieser Richtlinie könnte beispielsweise eine Benachrichtigungsregel für ein CodeCommit Repository erstellen, ohne über die erforderlichen Zugriffsrechte zu verfügen CodeCommit.
```
{
"Version": "2012-10-17",
"Sid": "AWSCodeStarNotificationsPowerUserAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:CreateNotificationRule",
"codestar-notifications:DescribeNotificationRule",
"codestar-notifications:ListNotificationRules",
"codestar-notifications:UpdateNotificationRule",
"codestar-notifications:Subscribe",
"codestar-notifications:Unsubscribe",
"codestar-notifications:ListTargets",
"codestar-notifications:ListTagsforResource"
],
"Resource": "*"
}
]
}
```
## Beispiel: Eine read-only-level Richtlinie für die Verwendung von AWS CodeStar Benachrichtigungen
In diesem Beispiel möchten Sie einem IAM-Benutzer in Ihrem Konto schreibgeschützten Zugriff auf die Benachrichtigungsregeln, Ziele und Ereignistypen in Ihrem AWS -Konto gewähren. Dieses Beispiel zeigt, wie Sie eine Richtlinie erstellen könnten, die die Anzeige dieser Elemente gestattet. Dies entspricht den Berechtigungen, die in den **AWSCodePipeline\$1ReadOnlyAccess**verwalteten Richtlinien **AWSCodeBuildReadOnlyAccess**AWSCodeCommitReadOnly****, und enthalten sind.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "CodeNotificationforReadOnly",
"Statement": [
{
"Sid": "ReadsAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:DescribeNotificationRule",
"codestar-notifications:ListNotificationRules",
"codestar-notifications:ListTargets",
"codestar-notifications:ListEventTypes"
],
"Resource": "*"
}
]
}
```
------
# Berechtigungen und Beispiele für AWS CodeConnections
Die folgenden Richtlinienanweisungen und -beispiele helfen Ihnen bei der Verwaltung von AWS CodeConnections.
Informationen dazu, wie Sie unter Verwendung dieser beispielhaften JSON-Richtliniendokumente eine identitätsbasierte IAM-Richtlinie erstellen, finden Sie unter [Erstellen von Richtlinien auf der JSON-Registerkarte](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor) im *Benutzerhandbuch von IAM*.
## Beispiel: Eine Richtlinie zum Erstellen AWS CodeConnections mit der CLI und zum Anzeigen mit der Konsole
Eine Rolle oder ein Benutzer, der das AWS CLI oder das SDK zum Anzeigen, Erstellen, Markieren oder Löschen von Verbindungen verwenden soll, sollte über Berechtigungen verfügen, die auf Folgendes beschränkt sind.
**Anmerkung**
Sie können in der Konsole nur mit den folgenden Berechtigungen keine Verbindung herstellen. Sie müssen die Berechtigungen im nächsten Abschnitt hinzufügen.
Verwenden Sie die folgende Richtlinie, um mithilfe der Konsole eine Liste verfügbarer Verbindungen anzuzeigen, Tags anzuzeigen und eine Verbindung zu verwenden.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ConnectionsFullAccess",
"Effect": "Allow",
"Action": [
"codeconnections:CreateConnection",
"codeconnections:DeleteConnection",
"codeconnections:UseConnection",
"codeconnections:GetConnection",
"codeconnections:ListConnections",
"codeconnections:TagResource",
"codeconnections:ListTagsForResource",
"codeconnections:UntagResource"
],
"Resource": "*"
}
]
}
```
------
## Beispiel: Eine Richtlinie für die Erstellung AWS CodeConnections mit der Konsole
Eine Rolle oder ein Benutzer, die bzw. der zum Verwalten von Verbindungen in der Konsole bestimmt ist, sollte über die erforderlichen Berechtigungen verfügen, um eine Verbindung in der Konsole abzuschließen und eine Installation zu erstellen. Dazu gehören das Autorisieren des Handshakes beim Anbieter und das Erstellen von Installationen für Verbindungen. `UseConnection` sollte auch hinzugefügt werden, um die Verbindung in der Konsole zu verwenden. Verwenden Sie die folgende Richtlinie, um eine Verbindung in der Konsole anzuzeigen, zu verwenden, zu markieren, zu erstellen oder zu löschen.
**Anmerkung**
Ab dem 1. Juli 2024 stellt die Konsole Verbindungen mit `codeconnections` der Ressource ARN her. Ressourcen mit beiden Dienstpräfixen werden weiterhin in der Konsole angezeigt.
**Anmerkung**
Bei Ressourcen, die mit der Konsole erstellt wurden, müssen die Aktionen in `codestar-connections` Richtlinienanweisungen das Dienstpräfix enthalten, wie im folgenden Beispiel gezeigt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codestar-connections:CreateConnection",
"codestar-connections:DeleteConnection",
"codestar-connections:GetConnection",
"codestar-connections:ListConnections",
"codestar-connections:GetInstallationUrl",
"codestar-connections:GetIndividualAccessToken",
"codestar-connections:ListInstallationTargets",
"codestar-connections:StartOAuthHandshake",
"codestar-connections:UpdateConnectionInstallation",
"codestar-connections:UseConnection",
"codestar-connections:TagResource",
"codestar-connections:ListTagsForResource",
"codestar-connections:UntagResource"
],
"Resource": [
"*"
]
}
]
}
```
------
## Beispiel: Eine Richtlinie auf Administratorebene für die Verwaltung AWS CodeConnections
In diesem Beispiel möchten Sie einem IAM-Benutzer in Ihrem AWS Konto vollen Zugriff gewähren, CodeConnections sodass der Benutzer Verbindungen hinzufügen, aktualisieren und löschen kann. Dies ist eine Vollzugriffsrichtlinie, die der **AWSCodePipeline\$1FullAccess**verwalteten Richtlinie entspricht. Wie bei dieser verwalteten Richtlinie sollten Sie diese Art von Richtlinienerklärung nur an IAM-Benutzer, -Gruppen oder -Rollen anhängen, die vollen Administratorzugriff auf Verbindungen in Ihrem AWS Konto benötigen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ConnectionsFullAccess",
"Effect": "Allow",
"Action": [
"codeconnections:CreateConnection",
"codeconnections:DeleteConnection",
"codeconnections:UseConnection",
"codeconnections:GetConnection",
"codeconnections:ListConnections",
"codeconnections:ListInstallationTargets",
"codeconnections:GetInstallationUrl",
"codeconnections:StartOAuthHandshake",
"codeconnections:UpdateConnectionInstallation",
"codeconnections:GetIndividualAccessToken",
"codeconnections:TagResource",
"codeconnections:ListTagsForResource",
"codeconnections:UntagResource"
],
"Resource": "*"
}
]
}
```
------
## Beispiel: Eine Richtlinie auf Mitwirkendenebene für die Verwendung AWS CodeConnections
In diesem Beispiel möchten Sie Zugriff auf die day-to-day Nutzung von gewähren CodeConnections, z. B. auf das Erstellen und Anzeigen von Verbindungsdetails, jedoch nicht auf zerstörerischere Aktionen wie das Löschen von Verbindungen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AWSCodeConnectionsPowerUserAccess",
"Effect": "Allow",
"Action": [
"codeconnections:CreateConnection",
"codeconnections:UseConnection",
"codeconnections:GetConnection",
"codeconnections:ListConnections",
"codeconnections:ListInstallationTargets",
"codeconnections:GetInstallationUrl",
"codeconnections:GetIndividualAccessToken",
"codeconnections:StartOAuthHandshake",
"codeconnections:UpdateConnectionInstallation",
"codeconnections:ListTagsForResource"
],
"Resource": "*"
}
]
}
```
------
## Beispiel: Eine read-only-level Richtlinie für die Verwendung AWS CodeConnections
In diesem Beispiel möchten Sie einem IAM-Benutzer in Ihrem Konto schreibgeschützten Zugriff auf die Verbindungen in Ihrem Konto gewähren. AWS Dieses Beispiel zeigt, wie Sie eine Richtlinie erstellen könnten, die die Anzeige dieser Elemente gestattet.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "ConnectionsforReadOnly",
"Statement": [
{
"Sid": "ReadsAPIAccess",
"Effect": "Allow",
"Action": [
"codeconnections:GetConnection",
"codeconnections:ListConnections",
"codeconnections:ListInstallationTargets",
"codeconnections:GetInstallationUrl",
"codeconnections:ListTagsForResource"
],
"Resource": "*"
}
]
}
```
------
## Beispiel: Beschränken Sie die VPC-Berechtigungen für Hosts mithilfe des **VpcId**Kontextschlüssels
Im folgenden Beispiel kann der Kunde den **VpcId**Kontextschlüssel verwenden, um die Erstellung oder Verwaltung von Hosts auf Hosts mit spezifizierter VPC zu beschränken.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"codeconnections:CreateHost",
"codeconnections:UpdateHost"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"codeconnections:VpcId": "vpc-EXAMPLE"
}
}
}
]
}
```
------
# Verwendung von Tags zur Steuerung des Zugriffs auf Ressourcen AWS CodeConnections
Markierungen können an die Ressource angehängt oder in der Anfrage an Services übergeben werden, die das Markieren unterstützen. In AWS CodeConnections können Ressourcen Tags haben, und einige Aktionen können Tags enthalten. Wenn Sie eine IAM-Richtlinie erstellen, können Sie Markierungs-Bedingungsschlüssel verwenden, um Folgendes zu kontrollieren:
+ Welche Benutzer Aktionen für eine Pipeline-Ressource ausführen können, basierend auf den Tags, über die diese bereits verfügt.
+ Welche Tags in der Anforderung einer Aktion übergeben werden können.
+ Ob bestimmte Tag-Schlüssel in einer Anforderung verwendet werden können.
Die folgenden Beispiele zeigen, wie Tag-Bedingungen in Richtlinien für AWS CodeConnections Benutzer angegeben werden.
**Example 1: Zulassen von Aktionen basierend auf Markierungen in der Anforderung**
Die folgende Richtlinie gewährt Benutzern die Berechtigung, Verbindungen in herzustellen AWS CodeConnections.
Hierfür werden die Aktionen `CreateConnection` und `TagResource` zugelassen, wenn die Anforderung ein Tag mit dem Namen `Project` und dem Wert `ProjectA` angibt. (Der Bedingungsschlüssel `aws:RequestTag` wird verwendet, um zu steuern, welche Tags in einer IAM-Anforderung übergeben werden können.) Die Bedingung `aws:TagKeys` stellt sicher, dass bei Tag-Schlüsseln die Groß- und Kleinschreibung beachtet wird.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codeconnections:CreateConnection",
"codeconnections:TagResource"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:RequestTag/Project": "ProjectA"
},
"ForAllValues:StringEquals": {
"aws:TagKeys": ["Project"]
}
}
}
]
}
```
**Example 2: Zulassen von Aktionen basierend auf Ressourcen-Tags**
Mit der folgenden Richtlinie wird Benutzern die Berechtigung zum Ausführen von Aktionen auf und Abrufen von Informationen zu Ressourcen in AWS CodeConnections gewährt.
Hierfür werden bestimmte Aktionen zugelassen, wenn die Pipeline ein Tag mit dem Namen `Project` und dem Wert `ProjectA` enthält. (Der Bedingungsschlüssel `aws:RequestTag` wird verwendet, um zu steuern, welche Tags in einer IAM-Anforderung übergeben werden können.) Die Bedingung `aws:TagKeys` stellt sicher, dass bei Tag-Schlüsseln die Groß- und Kleinschreibung beachtet wird.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codeconnections:CreateConnection",
"codeconnections:DeleteConnection",
"codeconnections:ListConnections"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Project": "ProjectA"
},
"ForAllValues:StringEquals": {
"aws:TagKeys": ["Project"]
}
}
}
]
}
```
## Verwenden von Notifications und Connections in der Konsole
Die Benachrichtigungserfahrung ist in die CodePipeline Konsolen CodeBuild CodeCommit CodeDeploy,, und sowie in die Developer Tools-Konsole in der Navigationsleiste **„Einstellungen“** selbst integriert. Um auf Benachrichtigungen in den Konsolen zuzugreifen, muss entweder eine der verwalteten Richtlinien für diese Services für Sie angewendet sein oder Sie müssen über einen Mindestsatz an Berechtigungen verfügen. Diese Berechtigungen müssen es Ihnen ermöglichen, Details zu den AWS CodeStar Benachrichtigungen und AWS CodeConnections Ressourcen in Ihrem AWS Konto aufzulisten und einzusehen. Wenn Sie eine identitätsbasierte Richtlinie erstellen, die strenger ist als die mindestens erforderlichen Berechtigungen, funktioniert die Konsole nicht wie vorgesehen für Entitäten (IAM-Benutzer oder -Rollen) mit dieser Richtlinie. Weitere Informationen zur Gewährung von Zugriff auf AWS CodeBuild, AWS CodeCommit, und AWS CodeDeploy AWS CodePipeline, einschließlich Zugriff auf diese Konsolen, finden Sie in den folgenden Themen:
+ CodeBuild: [Verwendung identitätsbasierter Richtlinien](https://docs.aws.amazon.com/codebuild/latest/userguide/security_iam_id-based-policy-examples.html#managed-policies) für CodeBuild
+ CodeCommit: [Verwendung identitätsbasierter Richtlinien](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html) für CodeCommit
+ AWS CodeDeploy: [Identitäts- und Zugriffsmanagement](https://docs.aws.amazon.com/codedeploy/latest/userguide/security-iam.html) für AWS CodeDeploy
+ CodePipeline: [Zugriffskontrolle mit IAM-Richtlinien](https://docs.aws.amazon.com/codepipeline/latest/userguide/access-control.html)
AWS CodeStar Für Benachrichtigungen gibt AWS es keine verwalteten Richtlinien. Um Zugriff auf Benachrichtigungsfunktionen zu ermöglichen, müssen Sie entweder eine der verwalteten Richtlinien für einen der oben aufgeführten Services anwenden oder Richtlinien mit der Berechtigungsstufe erstellen, die Sie Benutzern oder Entitäten erteilen möchten, und diese Richtlinien dann den Benutzern, Gruppen oder Rollen anfügen, die die Berechtigungen benötigen. Weitere Informationen finden Sie in den folgenden Beispielen:
+ [Beispiel: Eine Richtlinie auf Administratorebene für die Verwaltung von Benachrichtigungen AWS CodeStar](security_iam_id-based-policy-examples-notifications.md#security_iam_id-based-policy-examples-notifications-full-access)
+ [Beispiel: Eine Richtlinie auf Mitwirkendenebene für die Verwendung von Benachrichtigungen AWS CodeStar](security_iam_id-based-policy-examples-notifications.md#security_iam_id-based-policy-examples-notifications-contributor)
+ [Beispiel: Eine read-only-level Richtlinie für die Verwendung von AWS CodeStar Benachrichtigungen](security_iam_id-based-policy-examples-notifications.md#security_iam_id-based-policy-examples-notifications-read-only).
AWS CodeConnections hat keine AWS verwalteten Richtlinien. Sie verwenden die Berechtigungen und Kombinationen von Berechtigungen für den Zugriff, z. B. die Berechtigungen, die unter [Berechtigungen zum Abschließen von Verbindungen](#permissions-reference-connections-handshake) beschrieben ist.
Weitere Informationen finden Sie hier:
+ [Beispiel: Eine Richtlinie auf Administratorebene für die Verwaltung AWS CodeConnections](security_iam_id-based-policy-examples-connections.md#security_iam_id-based-policy-examples-connections-fullaccess)
+ [Beispiel: Eine Richtlinie auf Mitwirkendenebene für die Verwendung AWS CodeConnections](security_iam_id-based-policy-examples-connections.md#security_iam_id-based-policy-examples-connections-contributor)
+ [Beispiel: Eine read-only-level Richtlinie für die Verwendung AWS CodeConnections](security_iam_id-based-policy-examples-connections.md#security_iam_id-based-policy-examples-connections-readonly)
Sie müssen Benutzern, die nur die API AWS CLI oder die AWS API aufrufen, keine Konsolenberechtigungen gewähren. Stattdessen sollten Sie nur Zugriff auf die Aktionen zulassen, die den API-Operation entsprechen, die Sie ausführen möchten.
## Gewähren der Berechtigung zur Anzeige der eigenen Berechtigungen für Benutzer
In diesem Beispiel wird gezeigt, wie Sie eine Richtlinie erstellen, die IAM-Benutzern die Berechtigung zum Anzeigen der eingebundenen Richtlinien und verwalteten Richtlinien gewährt, die ihrer Benutzeridentität angefügt sind. Diese Richtlinie umfasst Berechtigungen zum Ausführen dieser Aktion auf der Konsole oder programmgesteuert mithilfe der API AWS CLI oder AWS .
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ViewOwnUserInfo",
"Effect": "Allow",
"Action": [
"iam:GetUserPolicy",
"iam:ListGroupsForUser",
"iam:ListAttachedUserPolicies",
"iam:ListUserPolicies",
"iam:GetUser"
],
"Resource": ["arn:aws:iam::*:user/${aws:username}"]
},
{
"Sid": "NavigateInConsole",
"Effect": "Allow",
"Action": [
"iam:GetGroupPolicy",
"iam:GetPolicyVersion",
"iam:GetPolicy",
"iam:ListAttachedGroupPolicies",
"iam:ListGroupPolicies",
"iam:ListPolicyVersions",
"iam:ListPolicies",
"iam:ListUsers"
],
"Resource": "*"
}
]
}
```
# Fehlerbehebung bei AWS CodeStar Benachrichtigungen sowie AWS CodeConnections Identität und Zugriff
Mit den folgenden Informationen können Sie häufige Probleme diagnostizieren und beheben, die beim Arbeiten mit Benachrichtigungen und IAM auftreten könnten.
**Topics**
+ [Ich bin Administrator und möchte anderen den Zugriff auf Benachrichtigungen ermöglichen](#security_iam_troubleshoot-admin-delegate)
+ [Ich habe ein Amazon-SNS-Thema erstellt und es als Benachrichtigungsregelziel hinzugefügt, aber ich empfange keine E-Mail-Nachrichten zu Ereignissen](#security_iam_troubleshoot-sns)
+ [Ich möchte Personen außerhalb meines AWS Kontos den Zugriff auf meine AWS CodeStar Benachrichtigungen und AWS CodeConnections Ressourcen ermöglichen](#security_iam_troubleshoot-cross-account-access)
## Ich bin Administrator und möchte anderen den Zugriff auf Benachrichtigungen ermöglichen
Um anderen den Zugriff auf AWS CodeStar Benachrichtigungen und zu ermöglichen AWS CodeConnections, müssen Sie den Personen oder Anwendungen, die Zugriff benötigen, die entsprechenden Berechtigungen erteilen. Wenn Sie Benutzer und Anwendungen verwalten, weisen Sie Benutzern oder Gruppen Berechtigungssätze zu, um deren Zugriffsebene zu definieren. AWS IAM Identity Center Mit Berechtigungssätzen werden automatisch IAM-Richtlinien erstellt und den IAM-Rollen zugewiesen, die der Person oder Anwendung zugeordnet sind. Weitere Informationen finden Sie im *AWS IAM Identity Center Benutzerhandbuch* unter [Berechtigungssätze](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html).
Wenn Sie IAM Identity Center nicht verwenden, müssen Sie IAM-Entitäten (Benutzer oder Rollen) für die Personen oder Anwendungen erstellen, die Zugriff benötigen. Anschließend müssen Sie der Entität unter AWS CodeStar Benachrichtigungen und eine Richtlinie hinzufügen, die ihr die richtigen Berechtigungen gewährt. AWS CodeConnections Nachdem die Berechtigungen erteilt wurden, geben Sie die Anmeldeinformationen an den Benutzer oder Anwendungsentwickler weiter. Sie werden diese Anmeldeinformationen für den Zugriff verwenden AWS. *Weitere Informationen zum Erstellen von IAM-Benutzern, -Gruppen, -Richtlinien und -Berechtigungen finden Sie im [IAM-Benutzerhandbuch unter IAM-Identitäten](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) [sowie Richtlinien und Berechtigungen in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html).*
Spezifische Informationen zu AWS CodeStar Benachrichtigungen finden Sie unter. [Berechtigungen und Beispiele für AWS CodeStar Benachrichtigungen](security_iam_id-based-policy-examples-notifications.md)
## Ich habe ein Amazon-SNS-Thema erstellt und es als Benachrichtigungsregelziel hinzugefügt, aber ich empfange keine E-Mail-Nachrichten zu Ereignissen
Um Benachrichtigungen zu Ereignissen zu erhalten, müssen Sie ein gültiges Amazon-SNS-Thema als Ziel für die Benachrichtigungsregel abonniert haben, und Ihre E-Mail-Adresse muss das Amazon-SNS-Thema abonniert haben. Um Probleme mit dem Amazon-SNS-Thema zu beheben, überprüfen Sie Folgendes:
+ Stellen Sie sicher, dass sich das Amazon SNS SNS-Thema in derselben AWS Region wie die Benachrichtigungsregel befindet.
+ Stellen Sie sicher, dass Ihr E-Mail-Alias das richtige Thema abonniert hat, und dass Sie das Abonnement bestätigt haben. Weitere Informationen finden Sie unter [Abonnieren eines Endpunkts für ein Amazon-SNS-Thema](https://docs.aws.amazon.com/sns/latest/dg/sns-tutorial-create-subscribe-endpoint-to-topic.html).
+ Vergewissern Sie sich, dass die Themenrichtlinie so geändert wurde, dass AWS CodeStar Benachrichtigungen Push-Benachrichtigungen zu diesem Thema senden können. Die Themarichtlinie sollte eine Anweisung ähnlich der folgenden enthalten:
```
{
"Sid": "AWSCodeStarNotifications_publish",
"Effect": "Allow",
"Principal": {
"Service": [
"codestar-notifications.amazonaws.com"
]
},
"Action": "SNS:Publish",
"Resource": "arn:aws:sns:us-east-1:123456789012:MyNotificationTopicName",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "123456789012"
}
}
}
```
Weitere Informationen finden Sie unter [Einrichtung](setting-up.md).
## Ich möchte Personen außerhalb meines AWS Kontos den Zugriff auf meine AWS CodeStar Benachrichtigungen und AWS CodeConnections Ressourcen ermöglichen
Sie können eine Rolle erstellen, mit der Benutzer in anderen Konten oder Personen außerhalb Ihrer Organisation auf Ihre Ressourcen zugreifen können. Sie können festlegen, wem die Übernahme der Rolle anvertraut wird. Für Dienste, die ressourcenbasierte Richtlinien oder Zugriffskontrolllisten (ACLs) unterstützen, können Sie diese Richtlinien verwenden, um Personen Zugriff auf Ihre Ressourcen zu gewähren.
Weitere Informationen dazu finden Sie hier:
+ Informationen darüber, ob AWS CodeStar Benachrichtigungen und diese Funktionen AWS CodeConnections unterstützen, finden Sie unter. [Funktionsweise von Funktionen in der Entwicklertools-Konsole mit IAM](security_iam_service-with-iam.md)
+ *Informationen dazu, wie Sie Zugriff auf Ihre Ressourcen gewähren können, AWS-Konten die Ihnen gehören, finden Sie im IAM-Benutzerhandbuch unter [Gewähren des Zugriffs für einen IAM-Benutzer in einem anderen AWS-Konto , den Sie besitzen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html).*
+ Informationen dazu, wie Sie Dritten Zugriff auf Ihre Ressourcen gewähren können AWS-Konten, finden Sie [AWS-Konten im *IAM-Benutzerhandbuch* unter Gewähren des Zugriffs für Dritte](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_third-party.html).
+ Informationen dazu, wie Sie über einen Identitätsverbund Zugriff gewähren, finden Sie unter [Gewähren von Zugriff für extern authentifizierte Benutzer (Identitätsverbund)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_federated-users.html) im *IAM-Benutzerhandbuch*.
+ Informationen zum Unterschied zwischen der Verwendung von Rollen und ressourcenbasierten Richtlinien für den kontoübergreifenden Zugriff finden Sie unter [Kontoübergreifender Ressourcenzugriff in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) im *IAM-Benutzerhandbuch*.
# Verwenden von serviceverknüpften Rollen für Benachrichtigungen AWS CodeStar
AWS CodeStar Notifications verwendet AWS Identity and Access Management [dienstverknüpfte](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) Rollen (IAM). Eine serviceverknüpfte Rolle ist ein einzigartiger Typ von IAM-Rolle, die direkt mit Benachrichtigungen verknüpft ist. AWS CodeStar Dienstbezogene Rollen sind in AWS CodeStar Notifications vordefiniert und beinhalten alle Berechtigungen, die der Dienst benötigt, um andere AWS Dienste in Ihrem Namen aufzurufen. Die Rolle wird für Sie erstellt, wenn Sie zum ersten Mal eine Benachrichtigungsregel erstellen. Sie müssen die Rolle nicht erstellen.
Eine dienstbezogene Rolle erleichtert die Einrichtung von AWS CodeStar Benachrichtigungen, da Sie Berechtigungen nicht manuell hinzufügen müssen. AWS CodeStar Notifications definiert die Berechtigungen ihrer dienstbezogenen Rollen, und sofern nicht anders definiert, können nur AWS CodeStar Benachrichtigungen diese Rollen übernehmen. Die definierten Berechtigungen umfassen die Vertrauens- und Berechtigungsrichtlinie. Diese Berechtigungsrichtlinie kann keinen anderen IAM-Entitäten zugewiesen werden.
Um eine serviceverknüpfte Rolle zu löschen, müssen Sie zunächst die verwandten Ressourcen löschen. Dadurch werden Ihre AWS CodeStar Benachrichtigungsressourcen geschützt, da Sie die Zugriffsberechtigung für die Ressourcen nicht versehentlich entziehen können.
Weitere Informationen zu anderen Services, die serviceverknüpfte Rollen unterstützen, finden Sie unter [AWS -Services, die mit IAM funktionieren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html).
## Mit dem Dienst verknüpfte Rollenberechtigungen für Benachrichtigungen AWS CodeStar
AWS CodeStar Notifications verwendet die AWSService RoleForCodeStarNotifications dienstbezogene Rolle, um Informationen über Ereignisse abzurufen, die in Ihrer Toolchain auftreten, und um Benachrichtigungen an die von Ihnen angegebenen Ziele zu senden.
Die mit dem AWSService RoleForCodeStarNotifications Dienst verknüpfte Rolle vertraut darauf, dass die folgenden Dienste die Rolle übernehmen:
+ `codestar-notifications.amazonaws.com`
Die Richtlinie für Rollenberechtigungen ermöglicht AWS CodeStar Notifications, die folgenden Aktionen für die angegebenen Ressourcen auszuführen:
+ Aktion: `PutRule` für `CloudWatch Event rules that are named awscodestar-notifications-*`
+ Aktion: `DescribeRule` für `CloudWatch Event rules that are named awscodestar-notifications-*`
+ Aktion: `PutTargets` für `CloudWatch Event rules that are named awscodestar-notifications-*`
+ Aktion: `CreateTopic`, um `create Amazon SNS topics for use with AWS CodeStar Notifications with the prefix CodeStarNotifications-`
+ Aktion: `GetCommentsForPullRequests` für `all comments on all pull requests in all CodeCommit repositories in the AWS account`
+ Aktion: `GetCommentsForComparedCommit` für `all comments on all commits in all CodeCommit repositories in the AWS account`
+ Aktion: `GetDifferences` für `all commits in all CodeCommit repositories in the AWS account`
+ Aktion: `GetCommentsForComparedCommit` für `all comments on all commits in all CodeCommit repositories in the AWS account`
+ Aktion: `GetDifferences` für `all commits in all CodeCommit repositories in the AWS account`
+ Aktion: `DescribeSlackChannelConfigurations` für `all AWS Chatbot clients in the AWS account`
+ Aktion: `UpdateSlackChannelConfiguration` für `all AWS Chatbot clients in the AWS account`
+ Aktion: `ListActionExecutions` für `all actions in all pipelines in the AWS account`
+ Aktion: `GetFile` für `all files in all CodeCommit repositories in the AWS account unless otherwise tagged`
Sie können diese Aktionen in der Richtlinienerklärung für die Rolle, die mit dem AWSService RoleForCodeStarNotifications Dienst verknüpft ist, nachlesen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": "arn:aws:events:*:*:rule/awscodestarnotifications-*",
"Effect": "Allow"
},
{
"Action": [
"sns:CreateTopic"
],
"Resource": "arn:aws:sns:*:*:CodeStarNotifications-*",
"Effect": "Allow"
},
{
"Action": [
"codecommit:GetCommentsForPullRequest",
"codecommit:GetCommentsForComparedCommit",
"codecommit:GetDifferences",
"chatbot:DescribeSlackChannelConfigurations",
"chatbot:UpdateSlackChannelConfiguration",
"codepipeline:ListActionExecutions"
],
"Resource": "*",
"Effect": "Allow"
},
{
"Action": [
"codecommit:GetFile"
],
"Resource": "*",
"Condition": {
"StringNotEquals": {
"aws:ResourceTag/ExcludeFileContentFromNotifications": "true"
}
},
"Effect": "Allow"
}
]
}
```
------
Sie müssen Berechtigungen konfigurieren, damit eine juristische Stelle von IAM (z. B. Benutzer, Gruppe oder Rolle) eine serviceverknüpfte Rolle erstellen, bearbeiten oder löschen kann. Weitere Informationen finden Sie unter [serviceverknüpfte Rollenberechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#service-linked-role-permissions) im *IAM-Benutzerhandbuch*.
## Eine dienstbezogene Rolle für Benachrichtigungen erstellen AWS CodeStar
Sie müssen eine serviceverknüpfte Rolle nicht manuell erstellen. Sie können die Developer Tools-Konsole oder die CreateNotificationRule API von oder aus verwenden, SDKs um eine Benachrichtigungsregel zu erstellen. AWS CLI Sie können die API auch direkt aufrufen. Die serviceverknüpfte Rolle wird für Sie erstellt, unabhängig von der verwendeten Methode.
Wenn Sie diese serviceverknüpfte Rolle löschen und sie dann erneut erstellen müssen, können Sie dasselbe Verfahren anwenden, um die Rolle in Ihrem Konto neu anzulegen. Sie können die Developer Tools-Konsole oder die CreateNotificationRule API von AWS CLI oder aus verwenden SDKs , um eine Benachrichtigungsregel zu erstellen. Sie können die API auch direkt aufrufen. Die serviceverknüpfte Rolle wird für Sie erstellt, unabhängig von der verwendeten Methode.
## Eine serviceverknüpfte Rolle für AWS CodeStar Benachrichtigungen bearbeiten
Da möglicherweise verschiedene Entitäten auf die Rolle verweisen, ist es nach dem Erstellen einer serviceverknüpften Rolle nicht mehr möglich, den Namen der Rolle zu ändern. Sie können mithilfe von IAM jedoch die Beschreibung der Rolle bearbeiten. Weitere Informationen finden Sie unter [Bearbeiten einer serviceverknüpften Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#edit-service-linked-role) im *IAM-Benutzerhandbuch*.
## Löschen einer dienstbezogenen Rolle für Benachrichtigungen AWS CodeStar
Wenn Sie eine Funktion oder einen Service nicht mehr benötigen, die bzw. der eine serviceverknüpfte Rolle erfordert, sollten Sie die Rolle löschen. Auf diese Weise haben Sie keine ungenutzte Entität, die nicht aktiv überwacht oder verwaltet wird. Sie müssen die Ressourcen für Ihre serviceverknüpfte Rolle zunächst bereinigen, bevor Sie sie löschen können. Für AWS CodeStar Benachrichtigungen bedeutet dies, dass alle Benachrichtigungsregeln gelöscht werden, die die Servicerolle in Ihrem AWS Konto verwenden.
**Anmerkung**
Wenn der AWS CodeStar Benachrichtigungsdienst die Rolle verwendet, wenn Sie versuchen, die Ressourcen zu löschen, schlägt das Löschen möglicherweise fehl. Wenn dies passiert, warten Sie einige Minuten und versuchen Sie es erneut.
**Um Ressourcen für AWS CodeStar Benachrichtigungen zu löschen, die verwendet werden von AWSService RoleForCodeStarNotifications**
1. Öffnen Sie die AWS Developer Tools-Konsole unter [https://console.aws.amazon.com/codesuite/Einstellungen/Benachrichtigungen](https://console.aws.amazon.com/codesuite/settings/notifications/).
**Anmerkung**
Benachrichtigungsregeln gelten für die AWS Region, in der sie erstellt wurden. Wenn Sie Benachrichtigungsregeln in mehr als einer AWS Region haben, verwenden Sie die Regionsauswahl, um die AWS-Region zu ändern.
1. Wählen Sie alle Benachrichtigungsregeln aus, die in der Liste angezeigt werden und dann **Delete (Löschen)**.
1. Wiederholen Sie diese Schritte in allen AWS Regionen, in denen Sie Benachrichtigungsregeln erstellt haben.
****IAM verwenden**, um die serviceverknüpfte Rolle zu löschen **
Verwenden Sie die IAM-Konsole oder AWS Identity and Access Management API AWS CLI, um die AWSService RoleForCodeStarNotifications serviceverknüpfte Rolle zu löschen. Weitere Informationen finden Sie unter [Löschen einer serviceverknüpften Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#delete-service-linked-role) im *IAM-Leitfaden*.
## Unterstützte Regionen für Rollen, die mit dem Dienst für AWS CodeStar Benachrichtigungen verknüpft sind
AWS CodeStar Notifications unterstützt die Verwendung von dienstbezogenen Rollen in allen AWS Regionen, in denen der Dienst verfügbar ist. [Weitere Informationen finden Sie unter [AWS Regionen und Endpunkte und AWS CodeStar Benachrichtigungen](https://docs.aws.amazon.com/general/latest/gr/rande.html).](https://docs.aws.amazon.com/general/latest/gr/codestar_notifications.html)
# Verwenden von serviceverknüpften Rollen für AWS CodeConnections
AWS CodeConnections verwendet AWS Identity and Access Management (IAM) [serviceverknüpfte](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) Rollen. Eine serviceverknüpfte Rolle ist ein einzigartiger Typ von IAM-Rolle, mit der direkt verknüpft ist. AWS CodeConnections Mit Diensten verknüpfte Rollen sind vordefiniert AWS CodeConnections und enthalten alle Berechtigungen, die der Dienst benötigt, um andere AWS Dienste in Ihrem Namen aufzurufen. Die Rolle wird für Sie erstellt, wenn Sie zum ersten Mal eine Verbindung erstellen. Sie müssen die Rolle nicht erstellen.
Eine dienstverknüpfte Rolle AWS CodeConnections erleichtert die Einrichtung, da Sie Berechtigungen nicht manuell hinzufügen müssen. AWS CodeConnections definiert die Berechtigungen ihrer dienstbezogenen Rollen und AWS CodeConnections kann, sofern nicht anders definiert, nur ihre Rollen übernehmen. Die definierten Berechtigungen umfassen die Vertrauens- und Berechtigungsrichtlinie. Diese Berechtigungsrichtlinie kann keinen anderen IAM-Entitäten zugewiesen werden.
Um eine serviceverknüpfte Rolle zu löschen, müssen Sie zunächst die verwandten Ressourcen löschen. Dadurch werden Ihre AWS CodeConnections Ressourcen geschützt, da Sie nicht versehentlich die Zugriffsberechtigung für die Ressourcen entziehen können.
Weitere Informationen zu anderen Services, die serviceverknüpfte Rollen unterstützen, finden Sie unter [AWS -Services, die mit IAM funktionieren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html).
**Anmerkung**
Aktionen für Ressourcen, die unter dem neuen Dienstpräfix `codeconnections` erstellt wurden, sind verfügbar. Wenn Sie eine Ressource unter dem neuen Dienstpräfix erstellen, wird sie `codeconnections` im Ressourcen-ARN verwendet. Aktionen und Ressourcen für das `codestar-connections` Dienstpräfix bleiben verfügbar. Bei der Angabe einer Ressource in der IAM-Richtlinie muss das Dienstpräfix mit dem der Ressource übereinstimmen.
## Mit dem Dienst verknüpfte Rollenberechtigungen für AWS CodeConnections
AWS CodeConnections verwendet die AWSService RoleForGitSync serviceverknüpfte Rolle, um Git Sync mit verbundenen Git-basierten Repositorys zu verwenden.
Die AWSService RoleForGitSync dienstverknüpfte Rolle vertraut darauf, dass die folgenden Dienste die Rolle übernehmen:
+ `repository.sync.codeconnections.amazonaws.com`
Die genannte Rollenberechtigungsrichtlinie AWSGit SyncServiceRolePolicy ermöglicht es AWS CodeConnections , die folgenden Aktionen für die angegebenen Ressourcen durchzuführen:
+ Aktion: Gewährt Benutzern Berechtigungen, die es Benutzern ermöglichen, Verbindungen mit externen Git-basierten Repositorys herzustellen und eine Git-Synchronisierung mit diesen Repositorys zu verwenden.
Sie müssen Berechtigungen konfigurieren, damit eine juristische Stelle von IAM (z. B. Benutzer, Gruppe oder Rolle) eine serviceverknüpfte Rolle erstellen, bearbeiten oder löschen kann. Weitere Informationen finden Sie unter [serviceverknüpfte Rollenberechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#service-linked-role-permissions) im *IAM-Benutzerhandbuch*.
## Erstellen einer dienstbezogenen Rolle für AWS CodeConnections
Sie müssen eine serviceverknüpfte Rolle nicht manuell erstellen. Sie erstellen die Rolle, wenn Sie eine Ressource für Ihr Git-synchronisiertes Projekt mit der API erstellen. CreateRepositoryLink
Wenn Sie diese serviceverknüpfte Rolle löschen und sie dann erneut erstellen müssen, können Sie dasselbe Verfahren anwenden, um die Rolle in Ihrem Konto neu anzulegen.
## Bearbeitung einer serviceverknüpften Rolle für AWS CodeConnections
Da möglicherweise verschiedene Entitäten auf die Rolle verweisen, ist es nach dem Erstellen einer serviceverknüpften Rolle nicht mehr möglich, den Namen der Rolle zu ändern. Sie können mithilfe von IAM jedoch die Beschreibung der Rolle bearbeiten. Weitere Informationen finden Sie unter [Bearbeiten einer serviceverknüpften Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#edit-service-linked-role) im *IAM-Benutzerhandbuch*.
## Löschen einer serviceverknüpften Rolle für AWS CodeConnections
Wenn Sie eine Funktion oder einen Service nicht mehr benötigen, die bzw. der eine serviceverknüpfte Rolle erfordert, sollten Sie die Rolle löschen. Auf diese Weise haben Sie keine ungenutzte Entität, die nicht aktiv überwacht oder verwaltet wird. Sie müssen die Ressourcen für Ihre serviceverknüpfte Rolle zunächst bereinigen, bevor Sie sie löschen können. Dies bedeutet, dass alle Verbindungen gelöscht werden, die die Servicerolle in Ihrem AWS Konto verwenden.
**Anmerkung**
Wenn der AWS CodeConnections Dienst die Rolle verwendet, wenn Sie versuchen, die Ressourcen zu löschen, schlägt das Löschen möglicherweise fehl. Wenn dies passiert, warten Sie einige Minuten und versuchen Sie es erneut.
**Um AWS CodeConnections Ressourcen zu löschen, die verwendet werden von AWSService RoleForGitSync**
1. Öffnen Sie die Developer-Tools-Konsole und wählen Sie dann **Einstellungen** aus.
1. Wählen Sie alle in der Liste angezeigten Benachrichtigungsregeln und dann **Löschen** aus.
1. Wiederholen Sie diese Schritte in allen AWS Regionen, in denen Sie Verbindungen erstellt haben.
****IAM verwenden**, um die serviceverknüpfte Rolle zu löschen **
Verwenden Sie die IAM-Konsole oder AWS Identity and Access Management API AWS CLI, um die AWSService RoleForGitSync serviceverknüpfte Rolle zu löschen. Weitere Informationen finden Sie unter [Löschen einer serviceverknüpften Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#delete-service-linked-role) im *IAM-Leitfaden*.
## Unterstützte Regionen für serviceverknüpfte Rollen AWS CodeConnections
AWS CodeConnections unterstützt die Verwendung von dienstbezogenen Rollen in allen AWS Regionen, in denen der Dienst verfügbar ist. Weitere Informationen finden Sie unter [AWS Regionen und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html).
# AWS verwaltete Richtlinien für AWS CodeConnections
Eine AWS verwaltete Richtlinie ist eine eigenständige Richtlinie, die von erstellt und verwaltet wird AWS. AWS Verwaltete Richtlinien sind so konzipiert, dass sie Berechtigungen für viele gängige Anwendungsfälle bereitstellen, sodass Sie damit beginnen können, Benutzern, Gruppen und Rollen Berechtigungen zuzuweisen.
Beachten Sie, dass AWS verwaltete Richtlinien für Ihre speziellen Anwendungsfälle möglicherweise keine Berechtigungen mit den geringsten Rechten gewähren, da sie allen AWS Kunden zur Verfügung stehen. Wir empfehlen Ihnen, die Berechtigungen weiter zu reduzieren, indem Sie [vom Kunden verwaltete Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#customer-managed-policies) definieren, die speziell auf Ihre Anwendungsfälle zugeschnitten sind.
Sie können die in AWS verwalteten Richtlinien definierten Berechtigungen nicht ändern. Wenn die in einer AWS verwalteten Richtlinie definierten Berechtigungen AWS aktualisiert werden, wirkt sich das Update auf alle Prinzidentitäten (Benutzer, Gruppen und Rollen) aus, denen die Richtlinie zugeordnet ist. AWS aktualisiert eine AWS verwaltete Richtlinie höchstwahrscheinlich, wenn eine neue Richtlinie eingeführt AWS-Service wird oder neue API-Operationen für bestehende Dienste verfügbar werden.
Weitere Informationen finden Sie unter [Von AWS verwaltete Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) im *IAM-Benutzerhandbuch*.
**Anmerkung**
Aktionen für Ressourcen, die unter dem neuen Dienstpräfix erstellt wurden, `codeconnections` sind verfügbar. Wenn Sie eine Ressource unter dem neuen Dienstpräfix erstellen, wird sie `codeconnections` im Ressourcen-ARN verwendet. Aktionen und Ressourcen für das `codestar-connections` Dienstpräfix bleiben verfügbar. Wenn Sie eine Ressource in der IAM-Richtlinie angeben, muss das Dienstpräfix mit dem der Ressource übereinstimmen.
## AWS verwaltete Richtlinie: AWSGit SyncServiceRolePolicy
Sie können keine Verbindungen AWSGit SyncServiceRolePolicy zu Ihren IAM-Entitäten herstellen. Diese Richtlinie ist mit einer dienstbezogenen Rolle verknüpft, mit der Sie Aktionen AWS CodeConnections in Ihrem Namen ausführen können. Weitere Informationen finden Sie unter [Verwenden von serviceverknüpften Rollen für AWS CodeConnections](service-linked-role-connections.md).
Diese Richtlinie ermöglicht Kunden den Zugriff auf Git-basierte Repositorys zur Verwendung mit Verbindungen. Kunden werden nach der Nutzung der CreateRepositoryLink API auf diese Ressourcen zugreifen.
**Details zu Berechtigungen**
Diese Richtlinie umfasst die folgenden Berechtigungen.
+ `codeconnections`: Gewährt Benutzern Berechtigungen, die es Benutzern ermöglichen, Verbindungen mit externen Git-basierten Repositorys herzustellen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AccessGitRepos",
"Effect": "Allow",
"Action": [
"codestar-connections:UseConnection",
"codeconnections:UseConnection"
],
"Resource": [
"arn:aws:codestar-connections:*:*:connection/*",
"arn:aws:codeconnections:*:*:connection/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "${aws:PrincipalAccount}"
}
}
}
]
}
```
------
## AWS CodeConnections Aktualisierungen der AWS verwalteten Richtlinien
Hier finden Sie Informationen zu Aktualisierungen AWS verwalteter Richtlinien, die AWS CodeConnections seit Beginn der Nachverfolgung dieser Änderungen durch diesen Dienst vorgenommen wurden. Abonnieren Sie den RSS-Feed auf der Seite AWS CodeConnections [Dokumentenverlauf](doc-history.md), um automatische Benachrichtigungen über Änderungen an dieser Seite zu erhalten.
| Änderungen | Beschreibung | Date |
| --- | --- | --- |
| [AWSGitSyncServiceRolePolicy](#security-iam-awsmanpol-AWSGitSyncServiceRolePolicy) – Richtlinie aktualisieren | Der Name des AWS CodeStar Connections-Service wurde geändert in AWS CodeConnections. Die Richtlinie für Ressourcen, die beide Servicepräfixe enthalten ARNs , wurde aktualisiert. | 26. April 2024 |
| [AWSGitSyncServiceRolePolicy](#security-iam-awsmanpol-AWSGitSyncServiceRolePolicy) – Neue Richtlinie | AWS CodeStar Connections hat die Richtlinie hinzugefügt. Erteilt Berechtigungen, die es Verbindungsbenutzern ermöglichen, Git Sync mit verbundenen Git-basierten Repositorys zu verwenden. | 26. November 2023 |
| AWS CodeConnections hat begonnen, Änderungen zu verfolgen | AWS CodeConnections hat begonnen, Änderungen für die AWS verwalteten Richtlinien zu verfolgen. | 26. November 2023 |