Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Gestione delle identità e degli accessi per AWS CodeStar notifiche e AWS CodeConnections
AWS Identity and Access Management (IAM) è uno strumento Servizio AWS che aiuta un amministratore a controllare in modo sicuro l'accesso alle AWS risorse. Gli amministratori IAM controllano chi può essere *autenticato* (effettuato l'accesso) e *autorizzato* (disporre delle autorizzazioni) a utilizzare AWS CodeStar le notifiche e le risorse. AWS CodeConnections IAM è uno Servizio AWS strumento che puoi utilizzare senza costi aggiuntivi.
**Nota**
Sono disponibili azioni per le risorse create con il nuovo prefisso `codeconnections` di servizio. La creazione di una risorsa con il nuovo prefisso di servizio verrà utilizzata `codeconnections` nella risorsa ARN. Le azioni e le risorse per il prefisso del `codestar-connections` servizio rimangono disponibili. Quando si specifica una risorsa nella policy IAM, il prefisso del servizio deve corrispondere a quello della risorsa.
**Topics**
+ [Destinatari](#security_iam_audience)
+ [Autenticazione con identità](#security_iam_authentication)
+ [Gestione dell’accesso tramite policy](#security_iam_access-manage)
+ [Come funzionano le caratteristiche nella console degli strumenti di sviluppo con IAM](security_iam_service-with-iam.md)
+ [AWS CodeConnections riferimento alle autorizzazioni](#permissions-reference-connections)
+ [Esempi di policy basate su identità](security_iam_id-based-policy-examples.md)
+ [Utilizzo dei tag per controllare l'accesso alle risorse AWS CodeConnections](connections-tag-based-access-control.md)
+ [Utilizzo di notifiche e connessioni nella console](#security_iam_id-based-policy-examples-console)
+ [Consentire agli utenti di visualizzare le loro autorizzazioni](#security_iam_id-based-policy-examples-view-own-permissions)
+ [Risoluzione dei problemi relativi a AWS CodeStar notifiche, identità e accesso AWS CodeConnections](security_iam_troubleshoot.md)
+ [Utilizzo di ruoli collegati ai servizi per le notifiche AWS CodeStar](using-service-linked-roles.md)
+ [Utilizzo di ruoli collegati ai servizi per AWS CodeConnections](service-linked-role-connections.md)
+ [AWS politiche gestite per AWS CodeConnections](security-iam-awsmanpol.md)
## Destinatari
Il modo in cui utilizzi AWS Identity and Access Management (IAM) varia in base al tuo ruolo:
+ **Utente del servizio**: richiedi le autorizzazioni all’amministratore se non riesci ad accedere alle funzionalità (consulta [Risoluzione dei problemi relativi a AWS CodeStar notifiche, identità e accesso AWS CodeConnections](security_iam_troubleshoot.md))
+ **Amministratore del servizio**: determina l’accesso degli utenti e invia le richieste di autorizzazione (consulta [Come funzionano le caratteristiche nella console degli strumenti di sviluppo con IAM](security_iam_service-with-iam.md))
+ **Amministratore IAM**: scrivi policy per gestire l’accesso (consulta [Esempi di policy basate su identità](security_iam_id-based-policy-examples.md))
## Autenticazione con identità
L'autenticazione è il modo in cui accedi AWS utilizzando le tue credenziali di identità. Devi autenticarti come utente IAM o assumendo un ruolo IAM. Utente root dell'account AWS
Puoi accedere come identità federata utilizzando credenziali provenienti da una fonte di identità come AWS IAM Identity Center (IAM Identity Center), autenticazione Single Sign-On o credenziali. Google/Facebook Per ulteriori informazioni sull’accesso, consulta [Come accedere all’ Account AWS](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html) nella *Guida per l’utente di Accedi ad AWS *.
Per l'accesso programmatico, AWS fornisce un SDK e una CLI per firmare crittograficamente le richieste. Per ulteriori informazioni, consulta [AWS Signature Version 4 per le richieste API](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) nella *Guida per l’utente di IAM*.
### Utente root dell'account AWS
Quando si crea una Account AWS, si inizia con un'identità di accesso chiamata *utente Account AWS root* che ha accesso completo a tutte le risorse. Servizi AWS Consigliamo vivamente di non utilizzare l’utente root per le attività quotidiane. Per le attività che richiedono le credenziali come utente root, consulta [Attività che richiedono le credenziali dell’utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks) nella *Guida per l’utente di IAM*.
### Utenti e gruppi IAM
Un *[utente IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html)* è una identità che dispone di autorizzazioni specifiche per una singola persona o applicazione. Ti consigliamo di utilizzare credenziali temporanee invece di utenti IAM con credenziali a lungo termine. Per ulteriori informazioni, consulta [Richiedere agli utenti umani di utilizzare la federazione con un provider di identità per accedere AWS utilizzando credenziali temporanee nella Guida](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) per l'*utente IAM*.
Un [https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) specifica una raccolta di utenti IAM e semplifica la gestione delle autorizzazioni per gestire gruppi di utenti di grandi dimensioni. Per ulteriori informazioni, consulta [Casi d’uso per utenti IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/gs-identities-iam-users.html) nella *Guida per l’utente di IAM*.
### Ruoli IAM
Un *[ruolo IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)* è un’identità con autorizzazioni specifiche che fornisce credenziali temporanee. Puoi assumere un ruolo [passando da un ruolo utente a un ruolo IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html) o chiamando un'operazione AWS CLI o AWS API. Per ulteriori informazioni, consulta [Metodi per assumere un ruolo](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage-assume.html) nella *Guida per l’utente di IAM*.
I ruoli IAM sono utili per l’accesso degli utenti federati, le autorizzazioni utente IAM temporanee, l’accesso multi-account, l’accesso multi-servizio e le applicazioni in esecuzione su Amazon EC2. Per maggiori informazioni, consultare [Accesso a risorse multi-account in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) nella *Guida per l’utente IAM*.
## Gestione dell’accesso tramite policy
Puoi controllare l'accesso AWS creando policy e associandole a AWS identità o risorse. Una policy definisce le autorizzazioni quando è associata a un'identità o a una risorsa. AWS valuta queste politiche quando un preside effettua una richiesta. La maggior parte delle politiche viene archiviata AWS come documenti JSON. Per maggiori informazioni sui documenti delle policy JSON, consulta [Panoramica delle policy JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json) nella *Guida per l’utente IAM*.
Utilizzando le policy, gli amministratori specificano chi ha accesso a cosa definendo quale **principale** può eseguire **azioni** su quali **risorse** e in quali **condizioni**.
Per impostazione predefinita, utenti e ruoli non dispongono di autorizzazioni. Un amministratore IAM crea le policy IAM e le aggiunge ai ruoli, che gli utenti possono quindi assumere. Le policy IAM definiscono le autorizzazioni indipendentemente dal metodo utilizzato per eseguirle.
### Policy basate sull’identità
Le policy basate su identità sono documenti di policy di autorizzazione JSON che è possibile collegare a un’identità (utente, gruppo o ruolo). Tali policy controllano le operazioni autorizzate per l’identità, nonché le risorse e le condizioni in cui possono essere eseguite. Per informazioni su come creare una policy basata su identità, consultare [Definizione di autorizzazioni personalizzate IAM con policy gestite dal cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) nella *Guida per l’utente IAM*.
Le policy basate su identità possono essere *policy in linea* (con embedding direttamente in una singola identità) o *policy gestite* (policy autonome collegate a più identità). Per informazioni su come scegliere tra una policy gestita o una policy inline, consulta [Scegliere tra policy gestite e policy in linea](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-choosing-managed-or-inline.html) nella *Guida per l’utente di IAM*.
# Come funzionano le caratteristiche nella console degli strumenti di sviluppo con IAM
Prima di utilizzare IAM per gestire l'accesso alle caratteristiche nella console degli strumenti di sviluppo, è necessario comprendere quali caratteristiche IAM sono disponibili per l'uso con essa. Per avere una visione di alto livello del funzionamento delle notifiche e di altri AWS servizi con IAM, consulta [AWS i servizi che funzionano con IAM nella IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) *User Guide*.
**Topics**
+ [Policy basate sull'identità nella console Strumenti di sviluppo](#security_iam_service-with-iam-id-based-policies)
+ [AWS CodeStar Notifiche e politiche basate sulle risorse AWS CodeConnections](#security_iam_service-with-iam-resource-based-policies)
+ [Autorizzazione basata su tag](#security_iam_service-with-iam-tags)
+ [Ruoli IAM](#security_iam_service-with-iam-roles)
## Policy basate sull'identità nella console Strumenti di sviluppo
Con le policy basate sull’identità di IAM, è possibile specificare quali operazioni e risorse sono consentite o respinte, nonché le condizioni in base alle quali le operazioni sono consentite o respinte. AWS CodeStar Notifiche e AWS CodeConnections supporto per azioni, risorse e chiavi di condizione specifiche. Per informazioni su tutti gli elementi utilizzati in una policy JSON, consulta [Documentazione di riferimento agli elementi delle policy JSON IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) nella *Guida per l'utente IAM*.
### Azioni
Gli amministratori possono utilizzare le policy AWS JSON per specificare chi ha accesso a cosa. In altre parole, quale **entità principale** può eseguire **operazioni** su quali **risorse** e in quali **condizioni**.
L'elemento `Action` di una policy JSON descrive le operazioni che è possibile utilizzare per consentire o negare l'accesso in una policy. Includere le operazioni in una policy per concedere le autorizzazioni a eseguire l’operazione associata.
Le operazioni delle policy per le notifiche nella console degli strumento di sviluppo utilizzano il seguente prefisso prima dell'operazione: `codestar-notifications and codeconnections`. Ad esempio, per concedere a qualcuno l'autorizzazione per visualizzare tutte le regole di notifica nel suo account, includi l'operazione `codestar-notifications:ListNotificationRules` nella rispettiva policy. Le dichiarazioni politiche devono includere un elemento `Action` or`NotAction`. AWS CodeStar AWS CodeConnections Notifica e definisce il proprio set di azioni che descrivono le attività che è possibile eseguire con questo servizio.
Per specificare più azioni di AWS CodeStar notifica in un'unica istruzione, separale con virgole come segue.
```
"Action": [
"codestar-notifications:action1",
"codestar-notifications:action2"
```
Per specificare più AWS CodeConnections azioni in un'unica istruzione, separale con virgole come segue.
```
"Action": [
"codeconnections:action1",
"codeconnections:action2"
```
Puoi specificare più operazioni tramite caratteri jolly (\$1). Ad esempio, per specificare tutte le operazioni che iniziano con la parola `List`, includi la seguente operazione.
```
"Action": "codestar-notifications:List*"
```
AWS CodeStar Le azioni dell'API di notifica includono:
+ `CreateNotificationRule`
+ `DeleteNotificationRule`
+ `DeleteTarget`
+ `DescribeNotificationRule`
+ `ListEventTypes`
+ `ListNotificationRules`
+ `ListTagsForResource`
+ `ListTargets`
+ `Subscribe`
+ `TagResource`
+ `Unsubscribe`
+ `UntagResource`
+ `UpdateNotificationRule`
AWS CodeConnections Le azioni API includono quanto segue:
+ `CreateConnection`
+ `DeleteConnection`
+ `GetConnection`
+ `ListConnections`
+ `ListTagsForResource`
+ `TagResource`
+ `UntagResource`
Le seguenti azioni che richiedono solo le autorizzazioni sono necessarie AWS CodeConnections per completare l'handshake di autenticazione:
+ `GetIndividualAccessToken`
+ `GetInstallationUrl`
+ `ListInstallationTargets`
+ `StartOAuthHandshake`
+ `UpdateConnectionInstallation`
Le seguenti azioni relative ai soli permessi sono necessarie per utilizzare una connessione: AWS CodeConnections
+ `UseConnection`
La seguente azione basata solo sulle autorizzazioni è richiesta AWS CodeConnections per passare una connessione a un servizio:
+ `PassConnection`
Per visualizzare un elenco di AWS CodeStar notifiche e AWS CodeConnections azioni, consulta [Actions defined by AWS CodeStar Notifications](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_codestarnotifications.html#codestarnotifications-actions-as-permissions) and [Actions Defined by AWS CodeConnections](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_codestarconnections.html#codestarconnections-actions-as-permissions) nella *IAM* User Guide.
### Resources
AWS CodeStar Le notifiche e AWS CodeConnections non supportano la specificazione della risorsa ARNs in una policy.
### Chiavi di condizione
AWS CodeStar Le notifiche AWS CodeConnections definiscono i propri set di chiavi di condizione e supportano anche l'utilizzo di alcune chiavi di condizione globali. Per visualizzare tutte le chiavi di condizione AWS globali, consulta le [chiavi di contesto delle condizioni AWS globali](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) nella *Guida per l'utente IAM*.
Tutte le azioni di AWS CodeStar notifica supportano la chiave di `codestar-notifications:NotificationsForResource` condizione. Per ulteriori informazioni, consulta [Esempi di policy basate su identità](security_iam_id-based-policy-examples.md).
AWS CodeConnections definiscono le seguenti chiavi di condizione che possono essere utilizzate nell'`Condition`elemento di una policy IAM. Puoi utilizzare queste chiavi per ottimizzare ulteriormente le condizioni in cui si applica l'istruzione di policy. Per ulteriori informazioni, consulta [AWS CodeConnections riferimento alle autorizzazioni](security-iam.md#permissions-reference-connections).
| Chiavi di condizione | Description |
| --- | --- |
| `codeconnections:BranchName` | Filtra l'accesso in base al nome del ramo del repository di terze parti |
| `codeconnections:FullRepositoryId` | Filtra l'accesso dal repository passato nella richiesta. Si applica solo alle richieste UseConnection per l'accesso a un repository specifico |
| codeconnections:InstallationId | Filtra l'accesso in base all'ID di terza parte (ad esempio l'ID di installazione dell'app Bitbucket) utilizzato per aggiornare una connessione. Consente di limitare le installazioni di app di terze parti che possono essere utilizzate per creare una connessione |
| codeconnections:OwnerId | Filtra l'accesso in base all'ID del proprietario o dell'account del provider di terze parti |
| `codeconnections:PassedToService` | Filtra l'accesso in base al servizio a cui l'entità può passare una connessione |
| `codeconnections:ProviderAction` | Filtra l'accesso in base all'operazione del provider in una richiesta UseConnection, ad esempio ListRepositories. |
| codeconnections:ProviderPermissionsRequired | Filtra l'accesso in base al tipo di autorizzazioni del provider di terze parti |
| `codeconnections:ProviderType` | Filtra l'accesso in base al tipo di provider di terze parti passato nella richiesta |
| codeconnections:ProviderTypeFilter | Filtra l'accesso in base al tipo di provider di terze parti utilizzato per filtrare i risultati |
| codeconnections:RepositoryName | Filtra l'accesso in base al nome del repository di terze parti |
### Esempi
Per visualizzare esempi di AWS CodeStar notifiche e politiche AWS CodeConnections basate sull'identità, consulta. [Esempi di policy basate su identità](security_iam_id-based-policy-examples.md)
## AWS CodeStar Notifiche e politiche basate sulle risorse AWS CodeConnections
AWS CodeStar Notifiche e politiche basate sulle AWS CodeConnections risorse non supportano.
## Autorizzazione basata su tag
Puoi allegare tag a AWS CodeStar Notifiche e AWS CodeConnections risorse o inserire tag in una richiesta. Per controllare l’accesso basato su tag, fornire informazioni sui tag nell’[elemento condizione](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) di una policy utilizzando le chiavi di condizione `codestar-notifications and codeconnections:ResourceTag/key-name`, `aws:RequestTag/key-name` o `aws:TagKeys`. Per ulteriori informazioni sulle strategie di tagging, consulta [Tagging resources AWS](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html). Per ulteriori informazioni sull'etichettatura di AWS CodeStar notifiche e AWS CodeConnections risorse, consulta. [Tagging di risorse di connessione](connections-tag.md)
Per visualizzare policy basate sulle identità di esempio per limitare l'accesso a una risorsa basata su tag su tale risorsa, consulta [Utilizzo dei tag per controllare l'accesso alle risorse AWS CodeConnections](connections-tag-based-access-control.md).
## Ruoli IAM
Un [ruolo IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) è un'entità all'interno del tuo AWS account che dispone di autorizzazioni specifiche.
### Utilizzo di credenziali temporanee
È possibile utilizzare credenziali temporanee per effettuare l'accesso utilizzando la federazione, assumere un ruolo IAM o assumere un ruolo tra account. Ottieni credenziali di sicurezza temporanee chiamando operazioni AWS STS API come [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)o. [GetFederationToken](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetFederationToken.html)
AWS CodeStar Notifiche e AWS CodeConnections supporti all'uso di credenziali temporanee.
### Ruoli collegati ai servizi
[I ruoli collegati ai](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) AWS servizi consentono ai servizi di accedere alle risorse di altri servizi per completare un'azione per conto dell'utente. I ruoli collegati ai servizi sono visualizzati nell'account IAM e sono di proprietà del servizio. Un amministratore IAM può visualizzare le autorizzazioni per i ruoli collegati ai servizi, ma non può modificarle.
AWS CodeStar Le notifiche supportano i ruoli collegati ai servizi. Per informazioni dettagliate sulla creazione o la gestione delle AWS CodeStar notifiche e dei ruoli AWS CodeConnections collegati ai servizi, consulta. [Utilizzo di ruoli collegati ai servizi per le notifiche AWS CodeStar](using-service-linked-roles.md)
CodeConnections non supporta ruoli collegati ai servizi.
## AWS CodeConnections riferimento alle autorizzazioni
Le tabelle seguenti elencano ogni operazione AWS CodeConnections API, le azioni corrispondenti per le quali è possibile concedere le autorizzazioni e il formato della risorsa ARN da utilizzare per la concessione delle autorizzazioni. AWS CodeConnections APIs Sono raggruppate in tabelle in base all'ambito delle azioni consentite da tale API. Usale come riferimento durante la stesura delle policy di autorizzazione da collegare a un'identità IAM (policy basate su identità).
Quando si crea una policy di autorizzazione, è necessario specificare le operazioni nel campo `Action` della policy. Puoi specificare il valore della risorsa nel campo `Resource` della policy come ARN, con o senza un carattere jolly (\$1).
Per esprimere le condizioni nelle policy di connessione, utilizza le chiavi di condizione descritte qui ed elencate in [Chiavi di condizione](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-conditionkeys). Puoi anche usare i tasti di condizione AWS-wide. Per un elenco completo delle chiavi AWS-wide, consulta [Available keys](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#AvailableKeys) nella *IAM User Guide*.
Per specificare un'operazione, utilizza il prefisso `codeconnections` seguito dal nome dell'operazione API (ad esempio, `codeconnections:ListConnections` o `codeconnections:CreateConnection`).
**Utilizzo di caratteri jolly**
Per specificare più operazioni o risorse, usa un carattere jolly (\$1) nell'ARN. Ad esempio, `codeconnections:*` specifica tutte le AWS CodeConnections azioni e `codeconnections:Get*` specifica tutte le AWS CodeConnections azioni che iniziano con la parola. `Get` L'esempio seguente concede l'accesso completo a tutte le risorse con nomi che iniziano con `MyConnection`.
```
arn:aws:codeconnections:us-west-2:account-ID:connection/*
```
È possibile utilizzare i caratteri jolly solo con le *connection* risorse elencate nella tabella seguente. Non puoi usare i caratteri jolly con le nostre risorse*region*. *account-id* Per ulteriori informazioni sui caratteri jolly, consulta [Identificatori IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html) nella *Guida per l'utente IAM*.
**Topics**
+ [Autorizzazioni per la gestione delle connessioni](#permissions-reference-connections-managing)
+ [Autorizzazioni per la gestione degli host](#permissions-reference-connections-hosts)
+ [Autorizzazioni per completare le connessioni](#permissions-reference-connections-handshake)
+ [Autorizzazioni per la configurazione degli host](#connections-permissions-actions-host-registration)
+ [Trasferimento di una connessione a un servizio](#permissions-reference-connections-passconnection)
+ [Utilizzo di una connessione](#permissions-reference-connections-use)
+ [Tipi di accesso supportati per `ProviderAction`](#permissions-reference-connections-access)
+ [Autorizzazioni supportate per l'assegnazione di tag alle risorse di connessione](#permissions-reference-connections-tagging)
+ [Passare una connessione a un collegamento di repository](#permissions-reference-connections-passrepository)
+ [Chiave di condizione supportata per i collegamenti al repository](#permissions-reference-connections-branch)
+ [Autorizzazioni supportate per la condivisione della connessione](#permissions-reference-connections-sharing)
### Autorizzazioni per la gestione delle connessioni
Un ruolo o un utente designato a utilizzare l'SDK AWS CLI o l'SDK per visualizzare, creare o eliminare connessioni deve avere le autorizzazioni limitate a quanto segue.
**Nota**
Non è possibile completare o utilizzare una connessione nella console con solo le seguenti autorizzazioni. È necessario aggiungere le autorizzazioni in [Autorizzazioni per completare le connessioni](#permissions-reference-connections-handshake).
```
codeconnections:CreateConnection
codeconnections:DeleteConnection
codeconnections:GetConnection
codeconnections:ListConnections
```
Utilizzare le barre di scorrimento per visualizzare il resto della tabella.
**AWS CodeConnections autorizzazioni necessarie per la gestione delle connessioni**
| AWS CodeConnections azioni | Autorizzazioni richieste | Resources |
| --- | --- | --- |
| CreateConnection | `codeconnections:CreateConnection` Necessario per utilizzare la CLI o la console per creare una connessione. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| DeleteConnection | `codeconnections:DeleteConnection` Necessario per utilizzare la CLI o la console per eliminare una connessione. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| GetConnection | `codeconnections:GetConnection` Necessario per utilizzare la CLI o la console per visualizzare i dettagli su una connessione. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| ListConnections | `codeconnections:ListConnections` Necessario per utilizzare la CLI o la console per elencare tutte le connessioni nell'account. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
Queste operazioni supportano le seguenti chiavi di condizione:
| Azione | Chiavi di condizione |
| --- | --- |
| `codeconnections:CreateConnection` | `codeconnections:ProviderType` |
| codeconnections:DeleteConnection | N/D |
| codeconnections:GetConnection | N/D |
| codeconnections:ListConnections | codeconnections:ProviderTypeFilter |
### Autorizzazioni per la gestione degli host
Un ruolo o un utente designato a utilizzare l'SDK AWS CLI o l'SDK per visualizzare, creare o eliminare gli host deve disporre delle autorizzazioni limitate ai seguenti.
**Nota**
Non è possibile completare o utilizzare una connessione nell'host con solo le seguenti autorizzazioni. È necessario aggiungere le autorizzazioni in [Autorizzazioni per la configurazione degli host](#connections-permissions-actions-host-registration).
```
codeconnections:CreateHost
codeconnections:DeleteHost
codeconnections:GetHost
codeconnections:ListHosts
```
Utilizzare le barre di scorrimento per visualizzare il resto della tabella.
**AWS CodeConnections autorizzazioni necessarie per la gestione degli host**
| AWS CodeConnections azioni | Autorizzazioni richieste | Resources |
| --- | --- | --- |
| CreateHost | `codeconnections:CreateHost` Necessario per utilizzare la CLI o la console per creare un host. | arn:aws:codeconnections: ::host/ *region* *account-id* *host-id* |
| DeleteHost | `codeconnections:DeleteHost` Necessario per utilizzare la CLI o la console per eliminare un host. | codeconnections: ::host/ *region* *account-id* *host-id* |
| GetHost | `codeconnections:GetHost` Necessario per utilizzare la CLI o la console per visualizzare i dettagli di un host. | arn:aws:codeconnections*region*: ::host/ *account-id* *host-id* |
| ListHosts | `codeconnections:ListHosts` Necessario per utilizzare la CLI o la console per elencare tutti gli host nell'account. | arn:aws:codeconnections: *region* ::host/ *account-id* *host-id* |
Queste operazioni supportano le seguenti chiavi di condizione:
| Azione | Chiavi di condizione |
| --- | --- |
| `codeconnections:CreateHost` | `codeconnections:ProviderType` `codeconnections:VpcId` |
| codeconnections:DeleteHost | N/D |
| codeconnections:GetHost | N/D |
| codeconnections:ListHosts | codeconnections:ProviderTypeFilter |
Per un esempio di politica che utilizza la chiave **VpcId**condition, vedi[Esempio: limita le autorizzazioni VPC dell'host utilizzando la chiave di contesto **VpcId**](security_iam_id-based-policy-examples-connections.md#security_iam_id-based-policy-examples-connections-vpc).
### Autorizzazioni per completare le connessioni
Un ruolo o un utente designato per gestire le connessioni nella console deve disporre delle autorizzazioni necessarie per completare una connessione nella console e creare un'installazione, che include l'autorizzazione dell'handshake al provider e la creazione di installazioni da utilizzare per le connessioni. Utilizzare le seguenti autorizzazioni oltre alle autorizzazioni precedenti.
Le seguenti operazioni IAM vengono utilizzate dalla console durante l'esecuzione di un handshake basato su browser. `ListInstallationTargets`, `GetInstallationUrl`, `StartOAuthHandshake`, `UpdateConnectionInstallation`, e `GetIndividualAccessToken` sono autorizzazioni di policy IAM. Non sono operazioni API.
```
codeconnections:GetIndividualAccessToken
codeconnections:GetInstallationUrl
codeconnections:ListInstallationTargets
codeconnections:StartOAuthHandshake
codeconnections:UpdateConnectionInstallation
```
In base a ciò, sono necessarie le seguenti autorizzazioni per utilizzare, creare, aggiornare o eliminare una connessione nella console.
```
codeconnections:CreateConnection
codeconnections:DeleteConnection
codeconnections:GetConnection
codeconnections:ListConnections
codeconnections:UseConnection
codeconnections:ListInstallationTargets
codeconnections:GetInstallationUrl
codeconnections:StartOAuthHandshake
codeconnections:UpdateConnectionInstallation
codeconnections:GetIndividualAccessToken
```
Utilizzare le barre di scorrimento per visualizzare il resto della tabella.
**AWS CodeConnections autorizzazioni necessarie per completare le connessioni**
| AWS CodeConnections azioni | Autorizzazioni richieste | Resources |
| --- | --- | --- |
| `GetIndividualAccessToken` | `codeconnections:GetIndividualAccessToken` Necessario per utilizzare la console per completare una connessione. Si tratta solo di un'autorizzazione di policy IAM, non di un'operazione API. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `GetInstallationUrl` | `codeconnections:GetInstallationUrl` Necessario per utilizzare la console per completare una connessione. Si tratta solo di un'autorizzazione di policy IAM, non di un'operazione API. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `ListInstallationTargets` | `codeconnections:ListInstallationTargets` Necessario per utilizzare la console per completare una connessione. Si tratta solo di un'autorizzazione di policy IAM, non di un'operazione API. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `StartOAuthHandshake` | `codeconnections:StartOAuthHandshake` Necessario per utilizzare la console per completare una connessione. Si tratta solo di un'autorizzazione di policy IAM, non di un'operazione API. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `UpdateConnectionInstallation` | `codeconnections:UpdateConnectionInstallation` Necessario per utilizzare la console per completare una connessione. Si tratta solo di un'autorizzazione di policy IAM, non di un'operazione API. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
Queste operazioni supportano le seguenti chiavi di condizione.
| Azione | Chiavi di condizione |
| --- | --- |
| codeconnections:GetIndividualAccessToken | codeconnections:ProviderType |
| codeconnections:GetInstallationUrl | codeconnections:ProviderType |
| `codeconnections:ListInstallationTargets` | N/D |
| codeconnections:StartOAuthHandshake | codeconnections:ProviderType |
| codeconnections:UpdateConnectionInstallation | codeconnections:InstallationId |
### Autorizzazioni per la configurazione degli host
Un ruolo o un utente designato per gestire le connessioni nella console deve disporre delle autorizzazioni necessarie per configurare un host nella console, incluse l'autorizzazione dell'handshake al provider e l'installazione dell'app host. Utilizzare le seguenti autorizzazioni oltre alle autorizzazioni per host precedenti.
Le seguenti operazioni IAM vengono utilizzate dalla console per eseguire una registrazione dell'host basata su browser. `RegisterAppCode` e `StartAppRegistrationHandshake` sono autorizzazioni delle policy IAM. Non sono operazioni API.
```
codeconnections:RegisterAppCode
codeconnections:StartAppRegistrationHandshake
```
In base a ciò, sono necessarie le seguenti autorizzazioni per utilizzare, creare, aggiornare o eliminare una connessione nella console che richiede un host (ad esempio i tipi di provider installati).
```
codeconnections:CreateConnection
codeconnections:DeleteConnection
codeconnections:GetConnection
codeconnections:ListConnections
codeconnections:UseConnection
codeconnections:ListInstallationTargets
codeconnections:GetInstallationUrl
codeconnections:StartOAuthHandshake
codeconnections:UpdateConnectionInstallation
codeconnections:GetIndividualAccessToken
codeconnections:RegisterAppCode
codeconnections:StartAppRegistrationHandshake
```
Utilizzare le barre di scorrimento per visualizzare il resto della tabella.
**AWS CodeConnections autorizzazioni necessarie per completare la configurazione dell'host**
| Azioni di connessione | Autorizzazioni richieste | Resources |
| --- | --- | --- |
| `RegisterAppCode` | `codeconnections:RegisterAppCode` Necessario per utilizzare la console per completare la configurazione dell'host. Si tratta solo di un'autorizzazione di policy IAM, non di un'operazione API. | arn:aws:codeconnections: ::host/ *region* *account-id* *host-id* |
| `StartAppRegistrationHandshake` | `codeconnections:StartAppRegistrationHandshake` Necessario per utilizzare la console per completare la configurazione dell'host. Si tratta solo di un'autorizzazione di policy IAM, non di un'operazione API. | arn:aws:codeconnections: *region* ::host/ *account-id* *host-id* |
Queste operazioni supportano le seguenti chiavi di condizione.
### Trasferimento di una connessione a un servizio
Quando una connessione viene trasferita a un servizio (ad esempio, quando un ARN di connessione viene fornito in una definizione di pipeline per creare o aggiornare una pipeline), l'utente deve disporre dell'autorizzazione `codeconnections:PassConnection`.
Utilizzare le barre di scorrimento per visualizzare il resto della tabella.
**AWS CodeConnections autorizzazioni necessarie per il passaggio di una connessione**
| AWS CodeConnections azioni | Autorizzazioni richieste | Resources |
| --- | --- | --- |
| `PassConnection` | `codeconnections:PassConnection` Necessario per passare una connessione a un servizio. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
Questa operazione supporta anche la seguente chiave di condizione:
+ `codeconnections:PassedToService`
**Valori supportati per le chiavi di condizione**
| Chiave | Provider di operazione validi |
| --- | --- |
| `codeconnections:PassedToService` | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/dtconsole/latest/userguide/security-iam.html) |
### Utilizzo di una connessione
Quando un servizio simile CodePipeline utilizza una connessione, il ruolo del servizio deve disporre dell'`codeconnections:UseConnection`autorizzazione per una determinata connessione.
Per gestire le connessioni nella console, è necessario che la policy utente disponga dell'autorizzazione `codeconnections:UseConnection`.
Utilizzare le barre di scorrimento per visualizzare il resto della tabella.
**AWS CodeConnections azione richiesta per l'utilizzo delle connessioni**
| AWS CodeConnections azioni | Autorizzazioni richieste | Resources |
| --- | --- | --- |
| `UseConnection` | `codeconnections:UseConnection` Necessario per utilizzare una connessione. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
Questa operazione supporta anche le seguenti chiavi di condizione:
+ `codeconnections:BranchName`
+ `codeconnections:FullRepositoryId`
+ `codeconnections:OwnerId`
+ `codeconnections:ProviderAction`
+ `codeconnections:ProviderPermissionsRequired`
+ `codeconnections:RepositoryName`
**Valori supportati per le chiavi di condizione**
| Chiave | Provider di operazione validi |
| --- | --- |
| `codeconnections:FullRepositoryId` | Il nome utente e il nome di repository di un repository, ad esempio `my-owner/my-repository`. Supportato solo quando la connessione viene utilizzata per accedere a un repository specifico. |
| `codeconnections:ProviderPermissionsRequired` | read\$1only o read\$1write |
| `codeconnections:ProviderAction` | `GetBranch`, `ListRepositories`, `ListOwners`, `ListBranches`, `StartUploadArchiveToS3`, `GitPush`, `GitPull`, `GetUploadArchiveToS3Status`, `CreatePullRequestDiffComment`, `GetPullRequest`, `ListBranchCommits`, `ListCommitFiles`, `ListPullRequestComments`, `ListPullRequestCommits`. Per informazioni, consulta la sezione successiva. |
Le chiavi di condizione necessarie per alcune funzionalità potrebbero cambiare nel tempo. Si consiglia di utilizzare `codeconnections:UseConnection` per controllare l'accesso a una connessione, a meno che i requisiti di controllo dell'accesso non richiedano autorizzazioni diverse.
### Tipi di accesso supportati per `ProviderAction`
Quando una connessione viene utilizzata da un AWS servizio, vengono effettuate chiamate API al provider del codice sorgente. Ad esempio, un servizio potrebbe elencare i repository per una connessione Bitbucket chiamando l'API `https://api.bitbucket.org/2.0/repositories/username`.
La chiave di `ProviderAction` condizione consente di limitare APIs il numero di provider che è possibile chiamare. Poiché il percorso API potrebbe essere generato dinamicamente e il percorso varia da provider a provider, il valore `ProviderAction` viene mappato a un nome di operazione astratto anziché all'URL dell'API. Ciò permette di scrivere policy che hanno lo stesso effetto indipendentemente dal tipo di provider per la connessione.
Di seguito sono riportati i tipi di accesso concessi per ciascuno dei valori `ProviderAction` supportati. Le seguenti sono autorizzazioni di policy IAM. Non sono operazioni API.
Utilizzare le barre di scorrimento per visualizzare il resto della tabella.
**AWS CodeConnections tipi di accesso supportati per `ProviderAction`**
| AWS CodeConnections autorizzazione | Autorizzazioni richieste | Resources |
| --- | --- | --- |
| `GetBranch` | ` codeconnections:GetBranch` Necessario per accedere alle informazioni su un ramo, ad esempio il commit più recente per quel ramo. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `ListRepositories` | ` codeconnections:ListRepositories` Necessario per accedere a un elenco di repository pubblici e privati che appartengono a un proprietario, inclusi i dettagli su tali repository. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `ListOwners` | `codeconnections:ListOwners` Necessario per accedere a un elenco di proprietari a cui la connessione ha accesso. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `ListBranches` | ` codeconnections:ListBranches` Necessario per accedere all'elenco dei rami esistenti in un determinato repository. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `StartUploadArchiveToS3` | ` codeconnections:StartUploadArchiveToS3` Necessario per leggere il codice sorgente e caricarlo su Amazon S3. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `GitPush` | ` codeconnections:GitPush` Necessario per scrivere in un repository utilizzando Git. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `GitPull` | ` codeconnections:GitPull` Necessario per leggere da un repository utilizzando Git. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| GetUploadArchiveToS3Status | ` codeconnections:GetUploadArchiveToS3Status` Necessario per accedere allo stato di un caricamento, inclusi eventuali messaggi di errore, avviato da `StartUploadArchiveToS3`. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| CreatePullRequestDiffComment | ` codeconnections:CreatePullRequestDiffComment` Necessario per accedere ai commenti su una richiesta pull. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| GetPullRequest | ` codeconnections:GetPullRequest` Necessario per visualizzare le richieste pull per un repository. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `ListBranchCommits` | ` codeconnections:ListBranchCommits` Necessario per visualizzare un elenco di commit per un ramo del repository. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `ListCommitFiles` | ` codeconnections:ListCommitFiles` Necessario per visualizzare un elenco di file per un commit. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `ListPullRequestComments` | ` codeconnections:ListPullRequestComments` Necessario per visualizzare un elenco di commenti per una richiesta pull. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
| `ListPullRequestCommits` | ` codeconnections:ListPullRequestCommits` Necessario per visualizzare un elenco di commit per una richiesta pull. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id* |
### Autorizzazioni supportate per l'assegnazione di tag alle risorse di connessione
Le seguenti operazioni IAM vengono utilizzate per taggare le risorse di connessione.
```
codeconnections:ListTagsForResource
codeconnections:TagResource
codeconnections:UntagResource
```
Utilizzare le barre di scorrimento per visualizzare il resto della tabella.
**AWS CodeConnections azioni necessarie per etichettare le risorse di connessione**
| AWS CodeConnections azioni | Autorizzazioni richieste | Resources |
| --- | --- | --- |
| `ListTagsForResource` | `codeconnections:ListTagsForResource` Necessario per visualizzare un elenco di tag associati alla risorsa di connessione. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id*,arn:aws:codeconnections: *region* ::host/ *account-id* *host-id* |
| `TagResource` | `codeconnections:TagResource` Necessario per aggiungere tag a una risorsa di connessione. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id*,arn:aws:codeconnections: *region* ::host/ *account-id* *host-id* |
| `UntagResource` | `codeconnections:UntagResource` Necessario per rimuovere i tag da una risorsa di connessione. | arn:aws:codeconnections: *region* ::connection/ *account-id* *connection-id*,arn:aws:codeconnections: *region* ::host/ *account-id* *host-id* |
### Passare una connessione a un collegamento di repository
Quando in una configurazione di sincronizzazione viene fornito un collegamento di repository, l'utente deve disporre dell'autorizzazione `codeconnections:PassRepository` per l'ARN o la risorsa di collegamento al repository.
Utilizzare le barre di scorrimento per visualizzare il resto della tabella.
**AWS CodeConnections autorizzazioni necessarie per il passaggio di una connessione**
| AWS CodeConnections azioni | Autorizzazioni richieste | Resources |
| --- | --- | --- |
| `PassRepository` | `codeconnections:PassRepository` Necessaria per passare un collegamento di repository a una configurazione di sincronizzazione. | arn:aws:codeconnections: ::repository-link/ *region* *account-id* *repository-link-id* |
Questa operazione supporta anche la seguente chiave di condizione:
+ `codeconnections:PassedToService`
**Valori supportati per le chiavi di condizione**
| Chiave | Provider di operazione validi |
| --- | --- |
| `codeconnections:PassedToService` | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/dtconsole/latest/userguide/security-iam.html) |
### Chiave di condizione supportata per i collegamenti al repository
La seguente chiave di condizione supporta le operazioni per i collegamenti ai repository e le risorse di configurazione delle sincronizzazioni:
+ `codeconnections:Branch`
Filtra l'accesso in base al nome del ramo passato nella richiesta.
**Azioni supportate per la chiave di condizione**
| Chiave | Valori validi |
| --- | --- |
| `codeconnections:Branch` | Per questa chiave di condizione sono supportate le seguenti operazioni:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/dtconsole/latest/userguide/security-iam.html) |
### Autorizzazioni supportate per la condivisione della connessione
Le seguenti operazioni IAM vengono utilizzate per la condivisione delle connessioni.
```
codeconnections:GetResourcePolicy
```
Utilizzare le barre di scorrimento per visualizzare il resto della tabella.
**AWS CodeConnections azioni necessarie per la condivisione delle connessioni**
| AWS CodeConnections azioni | Autorizzazioni richieste | Resources |
| --- | --- | --- |
| `GetResourcePolicy` | `codeconnections:GetResourcePolicy` Necessario per accedere alle informazioni sulla politica delle risorse. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
Per ulteriori informazioni sulla condivisione della connessione, vedere[Condividi le connessioni con Account AWS](connections-share.md).
# Esempi di policy basate su identità
Per impostazione predefinita, gli utenti e i ruoli IAM che dispongono di una delle policy gestite o AWS CodePipeline applicate dispongono di autorizzazioni per AWS CodeCommit connessioni, notifiche e regole di notifica in linea con l'intento di tali policy. AWS CodeBuild AWS CodeDeploy Ad esempio, gli utenti o i ruoli IAM a cui è stata applicata una delle politiche di accesso completo (**AWSCodeCommitFullAccess**AWSCodeBuildAdminAccess**AWSCodeDeployFullAccess******,, or **AWSCodePipeline\$1FullAccess**) hanno anche accesso completo alle notifiche e alle regole di notifica create per le risorse di tali servizi.
Gli altri utenti e ruoli IAM non sono autorizzati a creare o modificare AWS CodeStar notifiche e AWS CodeConnections risorse. Inoltre, non possono eseguire attività utilizzando l' AWS API Console di gestione AWS AWS CLI, o. Un amministratore IAM deve creare policy IAM che concedono a utenti e ruoli l'autorizzazione per eseguire operazioni API sulle risorse specificate di cui hanno bisogno. L'amministratore deve quindi collegare queste policy a utenti o IAM che richiedono tali autorizzazioni.
# Autorizzazioni ed esempi per le notifiche AWS CodeStar
Le seguenti dichiarazioni ed esempi di policy possono aiutarti a gestire AWS CodeStar le notifiche.
## Autorizzazioni correlate alle notifiche nelle policy gestite di accesso completo
Le politiche **AWSCodeCommitFullAccess**AWSCodeBuildAdminAccess****, **AWSCodeDeployFullAccess**, e **AWSCodePipeline\$1FullAccess**gestite includono le seguenti istruzioni per consentire l'accesso completo alle notifiche nella console Developer Tools. Gli utenti a cui è stata applicata una di queste policy gestite possono anche creare e gestire argomenti Amazon SNS per le notifiche, iscrivere e annullare l'iscrizione degli utenti agli argomenti ed elencare gli argomenti da scegliere come destinazioni per le regole di notifica.
**Nota**
Nella policy gestita, la chiave di condizione `codestar-notifications:NotificationsForResource` ha un valore specifico per il tipo di risorsa del servizio. Ad esempio, nella politica di accesso completo per CodeCommit, il valore è`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": "*"
}
```
## Autorizzazioni correlate alle notifiche nelle policy gestite di sola lettura
Le politiche **AWSCodeCommitReadOnlyAccess**AWSCodeBuildReadOnlyAccess****, **AWSCodeDeployReadOnlyAccess**, e **AWSCodePipeline\$1ReadOnlyAccess**gestite includono le seguenti istruzioni per consentire l'accesso in sola lettura alle notifiche. Ad esempio, possono visualizzare le notifiche per le risorse nella console Strumenti di sviluppo, ma non possono crearle, gestirle o iscriversi a esse.
**Nota**
Nella policy gestita, la chiave di condizione `codestar-notifications:NotificationsForResource` ha un valore specifico per il tipo di risorsa del servizio. Ad esempio, nella politica di accesso completo per CodeCommit, il valore è. `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": "*"
}
```
## Autorizzazioni correlate alle notifiche in altre policy gestite
Le **AWSCodeCommitPowerUser**policy e **AWSCodeBuildDeveloperAccess**le policy **AWSCodeBuildDeveloperAccess**gestite includono le seguenti istruzioni per consentire agli sviluppatori a cui è stata applicata una di queste politiche gestite di creare, modificare e sottoscrivere le notifiche. Non possono eliminare le regole di notifica o gestire i tag per le risorse.
**Nota**
Nella policy gestita, la chiave di condizione `codestar-notifications:NotificationsForResource` ha un valore specifico per il tipo di risorsa del servizio. Ad esempio, nella politica di accesso completo per CodeCommit, il valore è`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": "*"
}
```
## Esempio: una politica a livello di amministratore per la gestione delle notifiche AWS CodeStar
In questo esempio, vuoi concedere a un utente IAM del tuo AWS account l'accesso completo alle AWS CodeStar notifiche in modo che l'utente possa esaminare i dettagli delle regole di notifica ed elencare le regole di notifica, gli obiettivi e i tipi di eventi. Si vuole anche consentire all'utente di aggiungere, aggiornare ed eliminare regole di notifica. Si tratta di una policy di accesso completa, equivalente ai permessi di notifica inclusi nelle policy e nelle **AWSCodeBuildAdminAccess**policy **AWSCodePipeline\$1FullAccess**gestite. **AWSCodeCommitFullAccess**AWSCodeDeployFullAccess**** Analogamente a queste policy gestite, dovresti allegare questo tipo di dichiarazione politica solo a utenti, gruppi o ruoli IAM che richiedono l'accesso amministrativo completo alle notifiche e alle regole di notifica del tuo AWS account.
**Nota**
Questa policy contiene `CreateNotificationRule`. Qualsiasi utente con questa policy applicata al proprio utente o ruolo IAM sarà in grado di creare regole di notifica per tutti i tipi di risorse supportati da AWS CodeStar Notifications nell' AWS account, anche se l'utente stesso non ha accesso a tali risorse. Ad esempio, un utente con questa politica potrebbe creare una regola di notifica per un CodeCommit repository senza disporre delle autorizzazioni per l'accesso CodeCommit stesso.
------
#### [ 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": "*"
}
]
}
```
------
## Esempio: una politica a livello di collaboratore per l'utilizzo delle notifiche AWS CodeStar
In questo esempio, si desidera concedere l'accesso all' day-to-dayutilizzo delle AWS CodeStar notifiche, come la creazione e la sottoscrizione di notifiche, ma non ad azioni più distruttive, come l'eliminazione di regole o obiettivi di notifica. Questo è l'equivalente dell'accesso fornito nelle politiche e **AWSCodeBuildDeveloperAccess**gestite **AWSCodeDeployDeveloperAccess**. **AWSCodeCommitPowerUser**
**Nota**
Questa policy contiene `CreateNotificationRule`. Qualsiasi utente con questa policy applicata al proprio utente o ruolo IAM sarà in grado di creare regole di notifica per tutti i tipi di risorse supportati da AWS CodeStar Notifications nell' AWS account, anche se l'utente stesso non ha accesso a tali risorse. Ad esempio, un utente con questa politica potrebbe creare una regola di notifica per un CodeCommit repository senza disporre delle autorizzazioni per l'accesso CodeCommit stesso.
```
{
"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": "*"
}
]
}
```
## Esempio: una read-only-level politica per l'utilizzo delle notifiche AWS CodeStar
In questo esempio, desideri concedere a un utente IAM nel tuo account l'accesso in sola lettura alle regole di notifica, ai destinatari e ai tipi di eventi nell'account AWS . Questo esempio mostra come creare una policy che consente di visualizzare questi elementi. È l'equivalente delle autorizzazioni incluse come parte delle **AWSCodeBuildReadOnlyAccess**politiche e **AWSCodePipeline\$1ReadOnlyAccess**gestite. **AWSCodeCommitReadOnly**
------
#### [ 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": "*"
}
]
}
```
------
# Autorizzazioni ed esempi per AWS CodeConnections
Le istruzioni e gli esempi di policy riportati di seguito consentono di gestire AWS CodeConnections.
Per informazioni su come creare una policy basata su identità IAM utilizzando questi documenti di policy JSON di esempio, consulta [Creazione di policy nella scheda JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor) nella *Guida per l'utente IAM*.
## Esempio: una politica per la creazione AWS CodeConnections con la CLI e la visualizzazione con la console
Un ruolo o un utente designato a utilizzare l'SDK AWS CLI o l'SDK per visualizzare, creare, etichettare o eliminare le connessioni deve avere le autorizzazioni limitate a quanto segue.
**Nota**
Non è possibile completare una connessione nella console con solo le seguenti autorizzazioni. È necessario aggiungere le autorizzazioni nella sezione successiva.
Per utilizzare la console per visualizzare un elenco di connessioni disponibili, visualizzare i tag e utilizzare una connessione, utilizzare la policy seguente.
------
#### [ 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": "*"
}
]
}
```
------
## Esempio: una politica per la creazione AWS CodeConnections con la console
Un ruolo o un utente designato per gestire le connessioni nella console deve disporre delle autorizzazioni necessarie per completare una connessione nella console e creare un'installazione, che include l'autorizzazione dell'handshake al provider e la creazione di installazioni da utilizzare per le connessioni. `UseConnection` dovrebbe anche essere aggiunto per utilizzare la connessione nella console. Utilizzare la policy seguente per visualizzare, utilizzare, creare taggare o eliminare una connessione nella console.
**Nota**
A partire dal 1° luglio 2024, la console crea connessioni con `codeconnections` la risorsa ARN. Le risorse con entrambi i prefissi di servizio continueranno a essere visualizzate nella console.
**Nota**
Per le risorse create utilizzando la console, le azioni relative alle policy statement devono includere `codestar-connections` come prefisso di servizio, come illustrato nell'esempio seguente.
------
#### [ 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": [
"*"
]
}
]
}
```
------
## Esempio: una politica a livello di amministratore per la gestione AWS CodeConnections
In questo esempio, vuoi concedere a un utente IAM del tuo AWS account l'accesso completo a in CodeConnections modo che l'utente possa aggiungere, aggiornare ed eliminare connessioni. Si tratta di una politica di accesso completo, equivalente alla politica **AWSCodePipeline\$1FullAccess**gestita. Analogamente a quella politica gestita, dovresti allegare questo tipo di dichiarazione politica solo a utenti, gruppi o ruoli IAM che richiedono l'accesso amministrativo completo alle connessioni tra il tuo AWS account.
------
#### [ 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": "*"
}
]
}
```
------
## Esempio: una politica a livello di collaboratore da utilizzare AWS CodeConnections
In questo esempio, si desidera concedere l'accesso all' day-to-dayutilizzo di CodeConnections, ad esempio la creazione e la visualizzazione dei dettagli delle connessioni, ma non ad azioni più distruttive, come l'eliminazione delle connessioni.
------
#### [ 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": "*"
}
]
}
```
------
## Esempio: una read-only-level politica per l'utilizzo AWS CodeConnections
In questo esempio, vuoi concedere a un utente IAM del tuo account l'accesso in sola lettura alle connessioni del tuo AWS account. Questo esempio mostra come creare una policy che consente di visualizzare questi elementi.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "ConnectionsforReadOnly",
"Statement": [
{
"Sid": "ReadsAPIAccess",
"Effect": "Allow",
"Action": [
"codeconnections:GetConnection",
"codeconnections:ListConnections",
"codeconnections:ListInstallationTargets",
"codeconnections:GetInstallationUrl",
"codeconnections:ListTagsForResource"
],
"Resource": "*"
}
]
}
```
------
## Esempio: limita le autorizzazioni VPC dell'host utilizzando la chiave di contesto **VpcId**
Nell'esempio seguente, il cliente può utilizzare la chiave di **VpcId**contesto per limitare la creazione o la gestione degli host agli host con un VPC specificato.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"codeconnections:CreateHost",
"codeconnections:UpdateHost"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"codeconnections:VpcId": "vpc-EXAMPLE"
}
}
}
]
}
```
------
# Utilizzo dei tag per controllare l'accesso alle risorse AWS CodeConnections
I tag possono essere collegati alla risorsa o trasferiti nella richiesta verso servizi che supportano il tagging. In AWS CodeConnections, le risorse possono avere tag e alcune azioni possono includere tag. Quando si crea una policy IAM, è possibile utilizzare le chiavi di condizione di tag per controllare:
+ Quali utenti possono eseguire operazioni su una risorsa della pipeline, in base ai tag di cui la risorsa dispone già.
+ Quali tag possono essere passati in una richiesta di operazione.
+ Se delle chiavi di tag specifiche possono essere utilizzate in una richiesta.
Gli esempi seguenti mostrano come specificare le condizioni dei tag nelle politiche per AWS CodeConnections gli utenti.
**Example 1: Consentire operazioni in base ai tag nella richiesta**
La seguente politica concede agli utenti il permesso di creare connessioni in AWS CodeConnections.
A questo scopo, consente le operazioni `CreateConnection`e `TagResource` se la richiesta specifica un tag denominato `Project` con il valore `ProjectA`. La chiave di condizione `aws:RequestTag` viene utilizzata per controllare quali tag possono essere passati in una richiesta IAM. La condizione `aws:TagKeys` garantisce che la chiave tag rileva la distinzione tra maiuscole e minuscole.
****
```
{
"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: Consentire operazioni in base ai tag delle risorse**
La policy seguente concede agli utenti l'autorizzazione per eseguire operazioni e ottenere informazioni sulle risorse in AWS CodeConnections.
A questo scopo, consente operazioni specifiche se la pipeline dispone di un tag denominato `Project` con il valore `ProjectA`. La chiave di condizione `aws:RequestTag` viene utilizzata per controllare quali tag possono essere passati in una richiesta IAM. La condizione `aws:TagKeys` garantisce che la chiave tag rileva la distinzione tra maiuscole e minuscole.
****
```
{
"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"]
}
}
}
]
}
```
## Utilizzo di notifiche e connessioni nella console
L'esperienza di notifica è integrata nelle console CodeBuild CodeCommit, CodeDeploy, e, nonché nella CodePipeline console Developer Tools nella barra di navigazione delle **Impostazioni** stessa. Per accedere alle notifiche nelle console, è necessario applicare una delle policy gestite a tali servizi oppure disporre di un set minimo di autorizzazioni. Queste autorizzazioni devono consentirti di elencare e visualizzare i dettagli sulle AWS CodeStar notifiche e sulle AWS CodeConnections risorse del tuo AWS account. Se crei una policy basata su identità più restrittiva rispetto alle autorizzazioni minime richieste, la console non funzionerà nel modo previsto per le entità (utenti e ruoli IAM) associate a tale policy. Per ulteriori informazioni sulla concessione dell'accesso a AWS CodeBuild,, e AWS CodeCommit AWS CodeDeploy AWS CodePipeline, incluso l'accesso a tali console, consulta i seguenti argomenti:
+ CodeBuild: [Utilizzo di politiche basate sull'identità per CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/security_iam_id-based-policy-examples.html#managed-policies)
+ CodeCommit: [Utilizzo](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html) di politiche basate sull'identità per CodeCommit
+ AWS CodeDeploy: Gestione delle [identità e](https://docs.aws.amazon.com/codedeploy/latest/userguide/security-iam.html) degli accessi per AWS CodeDeploy
+ CodePipeline: [controllo degli accessi con policy IAM](https://docs.aws.amazon.com/codepipeline/latest/userguide/access-control.html)
AWS CodeStar Le notifiche non hanno politiche AWS gestite. Per fornire l'accesso alla funzionalità di notifica, è necessario applicare una delle policy gestite per uno dei servizi elencati in precedenza oppure creare policy con il livello di autorizzazione che si desidera concedere agli utenti o alle entità e quindi allegare le policy agli utenti, ai gruppi o ai ruoli che richiedono le autorizzazioni. Per maggiori informazioni ed esempi, consulta:
+ [Esempio: una politica a livello di amministratore per la gestione delle notifiche AWS CodeStar](security_iam_id-based-policy-examples-notifications.md#security_iam_id-based-policy-examples-notifications-full-access)
+ [Esempio: una politica a livello di collaboratore per l'utilizzo delle notifiche AWS CodeStar](security_iam_id-based-policy-examples-notifications.md#security_iam_id-based-policy-examples-notifications-contributor)
+ [Esempio: una read-only-level politica per l'utilizzo delle notifiche AWS CodeStar](security_iam_id-based-policy-examples-notifications.md#security_iam_id-based-policy-examples-notifications-read-only).
AWS CodeConnections non dispone di politiche AWS gestite. È possibile utilizzare le autorizzazioni e le combinazioni di autorizzazioni per l'accesso, ad esempio le autorizzazioni descritte in [Autorizzazioni per completare le connessioni](#permissions-reference-connections-handshake).
Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Esempio: una politica a livello di amministratore per la gestione AWS CodeConnections](security_iam_id-based-policy-examples-connections.md#security_iam_id-based-policy-examples-connections-fullaccess)
+ [Esempio: una politica a livello di collaboratore da utilizzare AWS CodeConnections](security_iam_id-based-policy-examples-connections.md#security_iam_id-based-policy-examples-connections-contributor)
+ [Esempio: una read-only-level politica per l'utilizzo AWS CodeConnections](security_iam_id-based-policy-examples-connections.md#security_iam_id-based-policy-examples-connections-readonly)
Non è necessario concedere le autorizzazioni della console agli utenti che effettuano chiamate solo verso AWS CLI o l' AWS API. Al contrario, è possibile accedere solo alle operazioni che soddisfano l'operazione API che stai cercando di eseguire.
## Consentire agli utenti di visualizzare le loro autorizzazioni
Questo esempio mostra in che modo è possibile creare una policy che consente agli utenti IAM di visualizzare le policy inline e gestite che sono collegate alla relativa identità utente. Questa politica include le autorizzazioni per completare questa azione sulla console o utilizzando l'API o a livello di codice. AWS CLI 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": "*"
}
]
}
```
# Risoluzione dei problemi relativi a AWS CodeStar notifiche, identità e accesso AWS CodeConnections
Utilizza le informazioni seguenti per diagnosticare e risolvere i problemi comuni che possono verificarsi durante l'utilizzo delle notifiche e IAM.
**Topics**
+ [Sono un amministratore e desidero consentire ad altri utenti di accedere alle notifiche](#security_iam_troubleshoot-admin-delegate)
+ [Ho creato un argomento Amazon SNS e l'ho aggiunto come una destinazione delle regole di notifica, ma non ricevo e-mail sugli eventi](#security_iam_troubleshoot-sns)
+ [Voglio consentire a persone esterne al mio AWS account di accedere alle mie AWS CodeStar notifiche e AWS CodeConnections risorse](#security_iam_troubleshoot-cross-account-access)
## Sono un amministratore e desidero consentire ad altri utenti di accedere alle notifiche
Per consentire ad altri di accedere alle AWS CodeStar notifiche e AWS CodeConnections, è necessario concedere l'autorizzazione alle persone o alle applicazioni che devono accedere. Se si utilizza AWS IAM Identity Center per gestire persone e applicazioni, si assegnano set di autorizzazioni a utenti o gruppi per definirne il livello di accesso. I set di autorizzazioni creano e assegnano automaticamente le policy IAM ai ruoli IAM associati alla persona o all'applicazione. Per ulteriori informazioni, consulta [Set di autorizzazioni](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html) nella *Guida per l'AWS IAM Identity Center utente*.
Se non utilizzi IAM Identity Center, devi creare entità IAM (utenti o ruoli) per le persone o le applicazioni che necessitano di accesso. È quindi necessario allegare una policy all'entità che conceda loro le autorizzazioni corrette in AWS CodeStar Notifiche e. AWS CodeConnections Dopo aver concesso le autorizzazioni, fornisci le credenziali all'utente o allo sviluppatore dell'applicazione. Utilizzeranno tali credenziali per accedere. AWS*Per ulteriori informazioni sulla creazione di utenti, gruppi, policy e autorizzazioni IAM, consulta [IAM Identities](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) and [Policies and permissions in IAM nella IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) User Guide.*
Per informazioni specifiche AWS CodeStar sulle notifiche, consulta. [Autorizzazioni ed esempi per le notifiche AWS CodeStar](security_iam_id-based-policy-examples-notifications.md)
## Ho creato un argomento Amazon SNS e l'ho aggiunto come una destinazione delle regole di notifica, ma non ricevo e-mail sugli eventi
Per ricevere notifiche sugli eventi, devi aver effettuato l'iscrizione a un argomento Amazon SNS valido come una destinazione per la regola di notifica e devi aver effettuato l'iscrizione del tuo indirizzo e-mail all'argomento Amazon SNS. Per risolvere i problemi relativi all'argomento Amazon SNS, verifica quanto segue:
+ Assicurati che l'argomento Amazon SNS si trovi nella stessa AWS regione della regola di notifica.
+ Verifica di aver effettuato l'iscrizione del tuo alias e-mail all'argomento corretto e di averla confermata. Per ulteriori informazioni, consulta [Iscrizione di un endpoint a un argomento Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-tutorial-create-subscribe-endpoint-to-topic.html).
+ Verifica che la politica dell'argomento sia stata modificata per consentire a AWS CodeStar Notifications di inviare notifiche a quell'argomento. La policy dell'argomento deve includere un'istruzione simile alla seguente:
```
{
"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"
}
}
}
```
Per ulteriori informazioni, consulta [Configurazione](setting-up.md).
## Voglio consentire a persone esterne al mio AWS account di accedere alle mie AWS CodeStar notifiche e AWS CodeConnections risorse
È possibile creare un ruolo con il quale utenti in altri account o persone esterne all’organizzazione possono accedere alle tue risorse. È possibile specificare chi è attendibile per l’assunzione del ruolo. Per i servizi che supportano politiche basate sulle risorse o liste di controllo degli accessi (ACLs), puoi utilizzare tali politiche per concedere alle persone l'accesso alle tue risorse.
Per maggiori informazioni, consulta gli argomenti seguenti:
+ Per sapere se AWS CodeStar Notifications and AWS CodeConnections supporta queste funzionalità, consulta. [Come funzionano le caratteristiche nella console degli strumenti di sviluppo con IAM](security_iam_service-with-iam.md)
+ Per scoprire come fornire l'accesso alle tue risorse su tutto Account AWS ciò che possiedi, consulta [Fornire l'accesso a un utente IAM in un altro Account AWS di tua proprietà](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html) nella *IAM User Guide*.
+ Per scoprire come fornire l'accesso alle tue risorse a terze parti Account AWS, consulta [Fornire l'accesso a soggetti Account AWS di proprietà di terze parti](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_third-party.html) nella *Guida per l'utente IAM*.
+ Per informazioni su come fornire l'accesso tramite la federazione delle identità, consulta [Fornire l'accesso a utenti autenticati esternamente (federazione delle identità)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_federated-users.html) nella *Guida per l'utente IAM*.
+ Per informazioni sulle differenze di utilizzo tra ruoli e policy basate su risorse per l’accesso multi-account, consulta [Accesso a risorse multi-account in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) nella *Guida per l’utente IAM*.
# Utilizzo di ruoli collegati ai servizi per le notifiche AWS CodeStar
AWS CodeStar Le notifiche utilizzano ruoli AWS Identity and Access Management collegati ai [servizi](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) (IAM). Un ruolo collegato al servizio è un tipo unico di ruolo IAM collegato direttamente alle notifiche. AWS CodeStar I ruoli collegati ai servizi sono predefiniti da AWS CodeStar Notifications e includono tutte le autorizzazioni richieste dal servizio per chiamare altri servizi per tuo conto. AWS Questo ruolo viene creato la prima volta che crei una regola di notifica. Non devi creare il ruolo.
Un ruolo collegato al servizio semplifica la configurazione AWS CodeStar delle notifiche perché non è necessario aggiungere le autorizzazioni manualmente. AWS CodeStar Le notifiche definiscono le autorizzazioni dei relativi ruoli collegati al servizio e, se non diversamente definito, solo AWS CodeStar Notifications può assumere i relativi ruoli. Le autorizzazioni definite includono la policy di attendibilità e la policy delle autorizzazioni. Una policy delle autorizzazioni specifica non può essere collegata a un'altra entità IAM.
Per eliminare un ruolo collegato al servizio, è necessario innanzitutto eliminarne le risorse correlate. In questo modo proteggi AWS CodeStar le tue risorse di Notifiche perché non puoi rimuovere inavvertitamente l'autorizzazione ad accedere alle risorse.
Per informazioni sugli altri servizi che supportano i ruoli collegati ai servizi consulta [Servizi AWS che funzionano con IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html).
## Autorizzazioni di ruolo collegate al servizio per le notifiche AWS CodeStar
AWS CodeStar Notifications utilizza il ruolo AWSService RoleForCodeStarNotifications collegato al servizio per recuperare informazioni sugli eventi che si verificano nella toolchain e inviare notifiche agli obiettivi specificati.
Il ruolo AWSService RoleForCodeStarNotifications collegato al servizio prevede che i seguenti servizi assumano il ruolo:
+ `codestar-notifications.amazonaws.com`
La politica di autorizzazione dei ruoli consente a AWS CodeStar Notifications di completare le seguenti azioni sulle risorse specificate:
+ Operazione: `PutRule` su `CloudWatch Event rules that are named awscodestar-notifications-*`
+ Operazione: `DescribeRule` su `CloudWatch Event rules that are named awscodestar-notifications-*`
+ Operazione: `PutTargets` su `CloudWatch Event rules that are named awscodestar-notifications-*`
+ Operazione: `CreateTopic` su `create Amazon SNS topics for use with AWS CodeStar Notifications with the prefix CodeStarNotifications-`
+ Operazione: `GetCommentsForPullRequests` su `all comments on all pull requests in all CodeCommit repositories in the AWS account`
+ Operazione: `GetCommentsForComparedCommit` su `all comments on all commits in all CodeCommit repositories in the AWS account`
+ Operazione: `GetDifferences` su `all commits in all CodeCommit repositories in the AWS account`
+ Operazione: `GetCommentsForComparedCommit` su `all comments on all commits in all CodeCommit repositories in the AWS account`
+ Operazione: `GetDifferences` su `all commits in all CodeCommit repositories in the AWS account`
+ Operazione: `DescribeSlackChannelConfigurations` su `all AWS Chatbot clients in the AWS account`
+ Operazione: `UpdateSlackChannelConfiguration` su `all AWS Chatbot clients in the AWS account`
+ Operazione: `ListActionExecutions` su `all actions in all pipelines in the AWS account`
+ Operazione: `GetFile` su `all files in all CodeCommit repositories in the AWS account unless otherwise tagged`
È possibile visualizzare queste azioni nella dichiarazione politica per il ruolo collegato al AWSService RoleForCodeStarNotifications servizio.
------
#### [ 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"
}
]
}
```
------
Per consentire a un'entità IAM (come un utente, un gruppo o un ruolo) di creare, modificare o eliminare un ruolo collegato al servizio è necessario configurare le relative autorizzazioni. Per ulteriori informazioni, consulta [Autorizzazioni del ruolo collegato ai servizi](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#service-linked-role-permissions) nella *Guida per l'utente di IAM*.
## Creazione di un ruolo collegato al servizio per le notifiche AWS CodeStar
Non hai bisogno di creare manualmente un ruolo collegato ai servizi. Puoi utilizzare la console Developer Tools o l' CreateNotificationRule API di AWS CLI o SDKs per creare una regola di notifica. Puoi anche chiamare direttamente l'API. Indipendentemente dal metodo utilizzato, il ruolo collegato ai servizi viene creato automaticamente.
Se elimini questo ruolo collegato al servizio, è possibile ricrearlo seguendo lo stesso processo utilizzato per ricreare il ruolo nell’account. Puoi utilizzare la console Developer Tools o l' CreateNotificationRule API di AWS CLI o SDKs per creare una regola di notifica. Puoi anche chiamare direttamente l'API. Indipendentemente dal metodo utilizzato, il ruolo collegato ai servizi viene creato automaticamente.
## Modifica di un ruolo collegato al servizio per le notifiche AWS CodeStar
Dopo aver creato un ruolo collegato ai servizi, non è possibile modificarne il nome perché varie entità possono farvi riferimento. Puoi tuttavia utilizzare IAM per modificare la descrizione del ruolo. Per ulteriori informazioni, consulta [Modifica di un ruolo collegato ai servizi](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#edit-service-linked-role) nella *Guida per l'utente di IAM*.
## Eliminazione di un ruolo collegato al servizio per Notifications AWS CodeStar
Se non è più necessario utilizzare una caratteristica o un servizio che richiede un ruolo collegato ai servizi, ti consigliamo di eliminare il ruolo. In questo modo non sarà più presente un'entità non utilizzata che non viene monitorata e gestita attivamente. È necessario effettuare la pulizia delle risorse associate al ruolo collegato ai servizi prima di poterlo eliminare. Per quanto riguarda AWS CodeStar le notifiche, ciò significa eliminare tutte le regole di notifica che utilizzano il ruolo di servizio nell'account. AWS
**Nota**
Se il servizio AWS CodeStar Notifiche utilizza il ruolo quando si tenta di eliminare le risorse, l'eliminazione potrebbe non riuscire. In questo caso, attendi alcuni minuti e quindi ripeti l’operazione.
**Per eliminare AWS CodeStar le risorse di notifica utilizzate da AWSService RoleForCodeStarNotifications**
1. Apri la console AWS Developer Tools in [https://console.aws.amazon.com/codesuite/impostazioni/notifiche](https://console.aws.amazon.com/codesuite/settings/notifications/).
**Nota**
Le regole di notifica si applicano alla AWS regione in cui vengono create. Se hai regole di notifica in più di una AWS regione, usa il selettore della regione per modificare le Regione AWS.
1. Scegli tutte le regole di notifica visualizzate nell'elenco, quindi seleziona **Delete (Elimina)**.
1. Ripeti questi passaggi in tutte le AWS regioni in cui hai creato le regole di notifica.
**Per **utilizzare IAM** per eliminare il ruolo collegato ai servizi**
Utilizza la console o l' AWS CLI AWS Identity and Access Management API IAM per eliminare il ruolo AWSService RoleForCodeStarNotifications collegato al servizio. Per ulteriori informazioni, consulta [Eliminazione del ruolo collegato al servizio](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#delete-service-linked-role) nella *Guida per l’utente di IAM*.
## Regioni supportate per i ruoli collegati al servizio AWS CodeStar Notifications
AWS CodeStar Notifications supporta l'utilizzo di ruoli collegati al servizio in tutte le AWS regioni in cui il servizio è disponibile. [Per ulteriori informazioni, consulta [AWS Regioni ed endpoint e Notifiche](https://docs.aws.amazon.com/general/latest/gr/rande.html).AWS CodeStar ](https://docs.aws.amazon.com/general/latest/gr/codestar_notifications.html)
# Utilizzo di ruoli collegati ai servizi per AWS CodeConnections
AWS CodeConnections utilizza ruoli collegati ai [servizi AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) (IAM). Un ruolo collegato ai servizi è un tipo unico di ruolo IAM a cui è collegato direttamente. AWS CodeConnections I ruoli collegati ai servizi sono predefiniti AWS CodeConnections e includono tutte le autorizzazioni richieste dal servizio per chiamare altri servizi per tuo conto. AWS Questo ruolo viene creato la prima volta che crei una connessione. Non devi creare il ruolo.
Un ruolo collegato al servizio semplifica la configurazione AWS CodeConnections perché non è necessario aggiungere le autorizzazioni manualmente. AWS CodeConnections definisce le autorizzazioni dei ruoli collegati ai servizi e, se non diversamente definito, solo può assumerne i ruoli. AWS CodeConnections Le autorizzazioni definite includono la policy di attendibilità e la policy delle autorizzazioni. Una policy delle autorizzazioni specifica non può essere collegata a un'altra entità IAM.
Per eliminare un ruolo collegato al servizio, è necessario innanzitutto eliminarne le risorse correlate. In questo modo proteggi AWS CodeConnections le tue risorse perché non puoi rimuovere inavvertitamente l'autorizzazione ad accedere alle risorse.
Per informazioni sugli altri servizi che supportano i ruoli collegati ai servizi consulta [Servizi AWS che funzionano con IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html).
**Nota**
Sono disponibili azioni per le risorse create con il nuovo prefisso `codeconnections` di servizio. La creazione di una risorsa con il nuovo prefisso di servizio verrà utilizzata `codeconnections` nella risorsa ARN. Le azioni e le risorse per il prefisso del `codestar-connections` servizio restano disponibili. Quando si specifica una risorsa nella policy IAM, il prefisso del servizio deve corrispondere a quello della risorsa.
## Autorizzazioni di ruolo collegate al servizio per AWS CodeConnections
AWS CodeConnections utilizza il ruolo AWSService RoleForGitSync collegato al servizio per utilizzare Git sync con repository basati su Git collegati.
Il ruolo AWSService RoleForGitSync collegato al servizio prevede che i seguenti servizi assumano il ruolo:
+ `repository.sync.codeconnections.amazonaws.com`
La politica di autorizzazione dei ruoli denominata AWSGit SyncServiceRolePolicy consente di AWS CodeConnections completare le seguenti azioni sulle risorse specificate:
+ Azione: concede agli utenti le autorizzazioni per creare connessioni a repository esterni basati su Git e per utilizzare la sincronizzazione Git con tali repository.
Per consentire a un'entità IAM (come un utente, un gruppo o un ruolo) di creare, modificare o eliminare un ruolo collegato al servizio è necessario configurare le relative autorizzazioni. Per ulteriori informazioni, consulta [Autorizzazioni del ruolo collegato ai servizi](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#service-linked-role-permissions) nella *Guida per l'utente di IAM*.
## Creazione di un ruolo collegato al servizio per AWS CodeConnections
Non hai bisogno di creare manualmente un ruolo collegato ai servizi. Crei il ruolo quando crei una risorsa per il tuo progetto sincronizzato con Git con l'API. CreateRepositoryLink
Se elimini questo ruolo collegato al servizio, è possibile ricrearlo seguendo lo stesso processo utilizzato per ricreare il ruolo nell’account.
## Modifica di un ruolo collegato al servizio per AWS CodeConnections
Dopo aver creato un ruolo collegato ai servizi, non è possibile modificarne il nome perché varie entità possono farvi riferimento. Puoi tuttavia utilizzare IAM per modificare la descrizione del ruolo. Per ulteriori informazioni, consulta [Modifica di un ruolo collegato ai servizi](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#edit-service-linked-role) nella *Guida per l'utente di IAM*.
## Eliminazione di un ruolo collegato al servizio per AWS CodeConnections
Se non è più necessario utilizzare una caratteristica o un servizio che richiede un ruolo collegato ai servizi, ti consigliamo di eliminare il ruolo. In questo modo non sarà più presente un'entità non utilizzata che non viene monitorata e gestita attivamente. È necessario effettuare la pulizia delle risorse associate al ruolo collegato ai servizi prima di poterlo eliminare. Ciò significa eliminare tutte le connessioni che utilizzano il ruolo di servizio nel tuo account. AWS
**Nota**
Se il AWS CodeConnections servizio utilizza il ruolo quando si tenta di eliminare le risorse, l'eliminazione potrebbe non riuscire. In questo caso, attendi alcuni minuti e quindi ripeti l’operazione.
**Per eliminare AWS CodeConnections le risorse utilizzate da AWSService RoleForGitSync**
1. Apri la console degli strumenti di sviluppo e scegli **Impostazioni**.
1. Scegli tutte le connessioni che appaiono nell'elenco, quindi seleziona **Elimina**.
1. Ripeti questi passaggi in tutte le AWS regioni in cui hai creato le connessioni.
**Per **utilizzare IAM** per eliminare il ruolo collegato ai servizi**
Utilizza la console o l' AWS CLI AWS Identity and Access Management API IAM per eliminare il ruolo AWSService RoleForGitSync collegato al servizio. Per ulteriori informazioni, consulta [Eliminazione del ruolo collegato al servizio](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#delete-service-linked-role) nella *Guida per l’utente di IAM*.
## Regioni supportate per i ruoli collegati ai servizi AWS CodeConnections
AWS CodeConnections supporta l'utilizzo di ruoli collegati al servizio in tutte le AWS regioni in cui il servizio è disponibile. Per ulteriori informazioni, consulta [Regioni ed endpoint di AWS](https://docs.aws.amazon.com/general/latest/gr/rande.html).
# AWS politiche gestite per AWS CodeConnections
Una politica AWS gestita è una politica autonoma creata e amministrata da AWS. AWS le politiche gestite sono progettate per fornire autorizzazioni per molti casi d'uso comuni, in modo da poter iniziare ad assegnare autorizzazioni a utenti, gruppi e ruoli.
Tieni presente che le policy AWS gestite potrebbero non concedere le autorizzazioni con il privilegio minimo per i tuoi casi d'uso specifici, poiché sono disponibili per tutti i clienti. AWS Si consiglia pertanto di ridurre ulteriormente le autorizzazioni definendo [policy gestite dal cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#customer-managed-policies) specifiche per i propri casi d'uso.
Non è possibile modificare le autorizzazioni definite nelle politiche gestite. AWS Se AWS aggiorna le autorizzazioni definite in una politica AWS gestita, l'aggiornamento ha effetto su tutte le identità principali (utenti, gruppi e ruoli) a cui è associata la politica. AWS è più probabile che aggiorni una policy AWS gestita quando ne Servizio AWS viene lanciata una nuova o quando diventano disponibili nuove operazioni API per i servizi esistenti.
Per ulteriori informazioni, consultare [Policy gestite da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) nella *Guida per l'utente di IAM*.
**Nota**
Sono disponibili azioni per le risorse create con il nuovo prefisso `codeconnections` del servizio. La creazione di una risorsa con il nuovo prefisso di servizio verrà utilizzata `codeconnections` nella risorsa ARN. Le azioni e le risorse per il prefisso del `codestar-connections` servizio rimangono disponibili. Quando si specifica una risorsa nella policy IAM, il prefisso del servizio deve corrispondere a quello della risorsa.
## AWS politica gestita: AWSGit SyncServiceRolePolicy
Non puoi collegarti AWSGit SyncServiceRolePolicy alle tue entità IAM. Questa policy è associata a un ruolo collegato al servizio che consente di AWS CodeConnections eseguire azioni per tuo conto. Per ulteriori informazioni, consulta [Utilizzo di ruoli collegati ai servizi per AWS CodeConnections](service-linked-role-connections.md).
Questa policy consente ai clienti di accedere ai repository basati su Git da utilizzare con le connessioni. I clienti accederanno a queste risorse dopo aver utilizzato l' CreateRepositoryLink API.
**Dettagli delle autorizzazioni**
Questa policy include le seguenti autorizzazioni:
+ `codeconnections`: concede agli utenti le autorizzazioni per creare connessioni a repository esterni basati su Git.
------
#### [ 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 aggiornamenti alle politiche AWS gestite
Visualizza i dettagli sugli aggiornamenti delle politiche AWS gestite AWS CodeConnections da quando questo servizio ha iniziato a tenere traccia di queste modifiche. Per ricevere avvisi automatici sulle modifiche a questa pagina, iscriviti al feed RSS nella pagina della [cronologia dei AWS CodeConnections documenti](doc-history.md).
| Modifica | Descrizione | Data |
| --- | --- | --- |
| [AWSGitSyncServiceRolePolicy](#security-iam-awsmanpol-AWSGitSyncServiceRolePolicy)— Politica aggiornata | Il nome del servizio AWS CodeStar Connections è cambiato in AWS CodeConnections. È stata aggiornata la policy per le risorse ARNs che contengono entrambi i prefissi di servizio. | 26 aprile 2024 |
| [AWSGitSyncServiceRolePolicy](#security-iam-awsmanpol-AWSGitSyncServiceRolePolicy): nuova policy | AWS CodeStar Connections ha aggiunto la policy. Concede le autorizzazioni per consentire agli utenti delle connessioni di utilizzare Git sync con repository basati su Git collegati. | 26 novembre 2023 |
| AWS CodeConnections ha iniziato a tenere traccia delle modifiche | AWS CodeConnections ha iniziato a tenere traccia delle modifiche per le sue politiche AWS gestite. | 26 novembre 2023 |