

Questa è la AWS CDK v2 Developer Guide. Il vecchio CDK v1 è entrato in manutenzione il 1° giugno 2022 e ha terminato il supporto il 1° giugno 2023.

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à.

# Autorizzazioni e CDK AWS
<a name="permissions"></a>

La AWS Construct Library utilizza alcuni idiomi comuni e ampiamente implementati per gestire l'accesso e le autorizzazioni. Il modulo IAM fornisce gli strumenti necessari per utilizzare questi idiomi.

 AWS CDK utilizza AWS CloudFormation per implementare le modifiche. Ogni implementazione coinvolge un attore (uno sviluppatore o un sistema automatizzato) che avvia una AWS CloudFormation distribuzione. Nel corso di questa operazione, l'attore assumerà una o più identità IAM (utente o ruoli) e, facoltativamente, assegnerà un ruolo a. AWS CloudFormation

Se utilizzi AWS IAM Identity Center per l'autenticazione come utente, il provider Single Sign-on fornisce credenziali di sessione di breve durata che ti autorizzano a svolgere il ruolo IAM predefinito. *Per scoprire come il AWS CDK ottiene le AWS credenziali dall'autenticazione IAM Identity Center, consulta Understand IAM Identity Center authentication nella and Tools [Reference Guide](https://docs.aws.amazon.com/sdkref/latest/guide/understanding-sso.html). AWS SDKs *

## Principali
<a name="permissions-principals"></a>

Un principale IAM è un' AWS entità autenticata che rappresenta un utente, un servizio o un'applicazione che può effettuare chiamate. AWS APIs La AWS Construct Library supporta la specificazione dei principali in diversi modi flessibili per consentire loro di accedere alle tue risorse. AWS 

Nei contesti di sicurezza, il termine «principale» si riferisce specificamente a entità autenticate come gli utenti. Oggetti come gruppi e ruoli non *rappresentano* gli utenti (e altre entità autenticate) ma li *identificano* indirettamente allo scopo di concedere le autorizzazioni.

Ad esempio, se crei un gruppo IAM, puoi concedere al gruppo (e quindi ai suoi membri) l'accesso in scrittura a una tabella Amazon RDS. Tuttavia, il gruppo stesso non è un principale perché non rappresenta una singola entità (inoltre, non è possibile accedere a un gruppo).

Nella libreria IAM del CDK, le classi che identificano direttamente o indirettamente i principali implementano l'[https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.IPrincipal.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.IPrincipal.html)interfaccia, che consente di utilizzare questi oggetti in modo intercambiabile nelle politiche di accesso. Tuttavia, non tutti sono principi in senso di sicurezza. Questi oggetti includono:

1. Risorse IAM come [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html), e [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Group.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Group.html) 

1. Responsabili del servizio () `new iam.[ServicePrincipal](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.ServicePrincipal.html)('service.amazonaws.com')`

1. Responsabili federati () `new iam.[FederatedPrincipal](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.FederatedPrincipal.html)('cognito-identity.amazonaws.com')`

1. Responsabili del conto () `new iam.[AccountPrincipal](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.AccountPrincipal.html)('0123456789012')`

1. Principi utente canonici () `new iam.[CanonicalUserPrincipal](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.CanonicalUserPrincipal.html)('79a59d[…​]7ef2be')`

1.  AWS Organizzazioni principali () `new iam.[OrganizationPrincipal](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.OrganizationPrincipal.html)('org-id')`

1. Principi ARN arbitrari () `new iam.[ArnPrincipal](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.ArnPrincipal.html)(res.arn)`

1. E `iam.[CompositePrincipal](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.CompositePrincipal.html)(principal1, principal2, …​)` fidarsi di più principi

## Concessioni
<a name="permissions-grants"></a>

Molti costrutti rappresentano risorse a cui è possibile accedere, come un bucket Amazon S3 o una tabella Amazon DynamoDB. Per queste, puoi concedere l'accesso a un'altra entità. **Esistono due modi per farlo, a seconda del particolare costrutto: utilizzando la classe Grants corrispondente (ad esempio, `BucketGrants` per i bucket Amazon S3) o utilizzando metodi nel costrutto stesso, i cui nomi iniziano con grant.** I primi sono preferiti perché possono essere utilizzati per concedere l'accesso alle risorse L1 e L2 nello stesso modo. Per creare un'istanza di una classe Grants, usa il suo metodo factory:

**Example**  

```
BucketGrants.fromBucket(bucket); // bucket can be either a Bucket (L2) or a CfnBucket (L1)
```

```
BucketGrants.fromBucket(bucket); // bucket can be either a Bucket (L2) or a CfnBucket (L1)
```

```
BucketGrants.from_bucket(bucket) # bucket can be either a Bucket (L2) or a CfnBucket (L1)
```

```
BucketGrants.fromBucket(bucket); // bucket can be either a Bucket (L2) or a CfnBucket (L1)
```

```
BucketGrants.FromBucket(bucket); // bucket can be either a Bucket (L2) or a CfnBucket (L1)
```

Le classi Grants forniscono metodi per concedere autorizzazioni specifiche per accedere alle rispettive risorse. Ad esempio, `BucketGrants` ha metodi `read` e `readWrite` (Python:`read`,`read_write`) per abilitare la lettura e read/write l'accesso, rispettivamente, da un'entità al bucket. L'entità non deve sapere esattamente quali autorizzazioni IAM di Amazon S3 sono necessarie per eseguire queste operazioni.

Il primo argomento dei metodi in una classe Grants (o i metodi **grant** nelle risorse stesse) è sempre di tipo. [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.IGrantable.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.IGrantable.html) Questa interfaccia rappresenta le entità a cui possono essere concesse le autorizzazioni. Cioè, rappresenta risorse con ruoli, come gli oggetti IAM [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html), e [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Group.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Group.html).

Le autorizzazioni possono essere concesse anche ad altre entità. Ad esempio, più avanti in questo argomento, mostriamo come concedere a un CodeBuild progetto l'accesso a un bucket Amazon S3. In genere, il ruolo associato viene ottenuto tramite una `role` proprietà sull'entità a cui viene concesso l'accesso.

Anche le risorse che utilizzano ruoli di esecuzione, ad esempio [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html), implementano`IGrantable`, quindi è possibile concedere loro l'accesso diretto anziché concedere l'accesso al loro ruolo. Ad esempio, se `bucket` è un bucket Amazon S3 ed è `function` una funzione Lambda, il codice seguente concede alla funzione l'accesso in lettura al bucket.

Per comodità, i costrutti L2 offrono anche una `grants` proprietà che restituisce un'istanza della classe Grants corrispondente.

**Example**  

```
bucket.grants.read(function);
```

```
bucket.grants.read(function);
```

```
bucket.grants.read(function)
```

```
bucket.getGrants().read(function);
```

```
bucket.Grants.Read(function);
```

A volte è necessario applicare le autorizzazioni mentre lo stack viene distribuito. Uno di questi casi si verifica quando si concede a una risorsa AWS CloudFormation personalizzata l'accesso a un'altra risorsa. La risorsa personalizzata verrà richiamata durante la distribuzione, quindi deve disporre delle autorizzazioni specificate al momento della distribuzione.

Un altro caso si verifica quando un servizio verifica che al ruolo assegnato siano applicate le politiche corrette. (Alcuni AWS servizi eseguono questa operazione per assicurarsi che tu non abbia dimenticato di impostare le politiche.) In questi casi, la distribuzione potrebbe non riuscire se le autorizzazioni vengono applicate troppo tardi.

Per forzare l'applicazione delle autorizzazioni della concessione prima che venga creata un'altra risorsa, puoi aggiungere una dipendenza dalla concessione stessa, come mostrato qui. Sebbene il valore restituito dai metodi di concessione venga comunemente scartato, ogni metodo di concessione restituisce in effetti un oggetto. `iam.Grant`

**Example**  

```
const grant = bucket.grants.read(lambda);
const custom = new CustomResource(...);
custom.node.addDependency(grant);
```

```
const grant = bucket.grants.read(lambda);
const custom = new CustomResource(...);
custom.node.addDependency(grant);
```

```
grant = bucket.grants.read(function)
custom = CustomResource(...)
custom.node.add_dependency(grant)
```

```
Grant grant = bucket.getGrants().read(function);
CustomResource custom = new CustomResource(...);
custom.node.addDependency(grant);
```

```
var grant = bucket.Grants.Read(function);
var custom = new CustomResource(...);
custom.node.AddDependency(grant);
```

## Roles
<a name="permissions-roles"></a>

Il pacchetto IAM contiene un [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)costrutto che rappresenta i ruoli IAM. Il codice seguente crea un nuovo ruolo, affidandosi al EC2 servizio Amazon.

**Example**  

```
import * as iam from 'aws-cdk-lib/aws-iam';

const role = new iam.Role(this, 'Role', {
  assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),   // required
});
```

```
const iam = require('aws-cdk-lib/aws-iam');

const role = new iam.Role(this, 'Role', {
  assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com')   // required
});
```

```
import aws_cdk.aws_iam as iam

role = iam.Role(self, "Role",
          assumed_by=iam.ServicePrincipal("ec2.amazonaws.com")) # required
```

```
import software.amazon.awscdk.services.iam.Role;
import software.amazon.awscdk.services.iam.ServicePrincipal;

Role role = Role.Builder.create(this, "Role")
        .assumedBy(new ServicePrincipal("ec2.amazonaws.com")).build();
```

```
using Amazon.CDK.AWS.IAM;

var role = new Role(this, "Role", new RoleProps
{
    AssumedBy = new ServicePrincipal("ec2.amazonaws.com"),   // required
});
```

Puoi aggiungere autorizzazioni a un ruolo chiamando il [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html#addwbrtowbrpolicystatement](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html#addwbrtowbrpolicystatement)metodo del ruolo (Python`add_to_policy`:), passando [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.PolicyStatement.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.PolicyStatement.html)un che definisce la regola da aggiungere. L'istruzione viene aggiunta alla politica predefinita del ruolo; se non ne ha, ne viene creata una.

L'esempio seguente aggiunge una dichiarazione di `Deny` policy al ruolo per le azioni `ec2:SomeAction` e `s3:AnotherAction` sulle risorse `bucket` e `otherRole` (Python:`other_role`), a condizione che il servizio autorizzato sia. AWS CodeBuild

**Example**  

```
role.addToPolicy(new iam.PolicyStatement({
  effect: iam.Effect.DENY,
  resources: [bucket.bucketArn, otherRole.roleArn],
  actions: ['ec2:SomeAction', 's3:AnotherAction'],
  conditions: {StringEquals: {
    'ec2:AuthorizedService': 'codebuild.amazonaws.com',
}}}));
```

```
role.addToPolicy(new iam.PolicyStatement({
  effect: iam.Effect.DENY,
  resources: [bucket.bucketArn, otherRole.roleArn],
  actions: ['ec2:SomeAction', 's3:AnotherAction'],
  conditions: {StringEquals: {
    'ec2:AuthorizedService': 'codebuild.amazonaws.com'
}}}));
```

```
role.add_to_policy(iam.PolicyStatement(
    effect=iam.Effect.DENY,
    resources=[bucket.bucket_arn, other_role.role_arn],
    actions=["ec2:SomeAction", "s3:AnotherAction"],
    conditions={"StringEquals": {
        "ec2:AuthorizedService": "codebuild.amazonaws.com"}}
))
```

```
role.addToPolicy(PolicyStatement.Builder.create()
        .effect(Effect.DENY)
        .resources(Arrays.asList(bucket.getBucketArn(), otherRole.getRoleArn()))
        .actions(Arrays.asList("ec2:SomeAction", "s3:AnotherAction"))
        .conditions(java.util.Map.of(    // Map.of requires Java 9 or later
            "StringEquals", java.util.Map.of(
                "ec2:AuthorizedService", "codebuild.amazonaws.com")))
        .build());
```

```
role.AddToPolicy(new PolicyStatement(new PolicyStatementProps
{
    Effect = Effect.DENY,
    Resources = new string[] { bucket.BucketArn, otherRole.RoleArn },
    Actions = new string[] { "ec2:SomeAction", "s3:AnotherAction" },
    Conditions = new Dictionary<string, object>
    {
        ["StringEquals"] = new Dictionary<string, string>
        {
            ["ec2:AuthorizedService"] = "codebuild.amazonaws.com"
        }
    }
}));
```

Nell'esempio precedente, abbiamo creato un nuovo [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.PolicyStatement.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.PolicyStatement.html)inline con la chiamata ([https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html#addwbrtowbrpolicystatement](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html#addwbrtowbrpolicystatement)Python:). `add_to_policy` Puoi anche inserire una dichiarazione politica esistente o una che hai modificato. L'[https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.PolicyStatement.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.PolicyStatement.html)oggetto dispone di [numerosi metodi](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.PolicyStatement.html#methods) per aggiungere principi, risorse, condizioni e azioni.

Se utilizzate un costrutto che richiede un ruolo per funzionare correttamente, potete effettuare una delle seguenti operazioni:
+ Assegnate un ruolo esistente quando istanziate l'oggetto di costruzione.
+ Lascia che il costrutto crei un nuovo ruolo per te, affidandoti al responsabile del servizio appropriato. L'esempio seguente utilizza un costrutto di questo tipo: un progetto. CodeBuild 

**Example**  

```
import * as codebuild from 'aws-cdk-lib/aws-codebuild';

// imagine roleOrUndefined is a function that might return a Role object
// under some conditions, and undefined under other conditions
const someRole: iam.IRole | undefined = roleOrUndefined();

const project = new codebuild.Project(this, 'Project', {
  // if someRole is undefined, the Project creates a new default role,
  // trusting the codebuild.amazonaws.com service principal
  role: someRole,
});
```

```
const codebuild = require('aws-cdk-lib/aws-codebuild');

// imagine roleOrUndefined is a function that might return a Role object
// under some conditions, and undefined under other conditions
const someRole = roleOrUndefined();

const project = new codebuild.Project(this, 'Project', {
  // if someRole is undefined, the Project creates a new default role,
  // trusting the codebuild.amazonaws.com service principal
  role: someRole
});
```

```
import aws_cdk.aws_codebuild as codebuild

# imagine role_or_none is a function that might return a Role object
# under some conditions, and None under other conditions
some_role = role_or_none();

project = codebuild.Project(self, "Project",
# if role is None, the Project creates a new default role,
# trusting the codebuild.amazonaws.com service principal
role=some_role)
```

```
import software.amazon.awscdk.services.iam.Role;
import software.amazon.awscdk.services.codebuild.Project;

// imagine roleOrNull is a function that might return a Role object
// under some conditions, and null under other conditions
Role someRole = roleOrNull();

// if someRole is null, the Project creates a new default role,
// trusting the codebuild.amazonaws.com service principal
Project project = Project.Builder.create(this, "Project")
        .role(someRole).build();
```

```
using Amazon.CDK.AWS.CodeBuild;

// imagine roleOrNull is a function that might return a Role object
// under some conditions, and null under other conditions
var someRole = roleOrNull();

// if someRole is null, the Project creates a new default role,
// trusting the codebuild.amazonaws.com service principal
var project = new Project(this, "Project", new ProjectProps
{
    Role = someRole
});
```

Una volta creato l'oggetto, il ruolo (indipendentemente dal ruolo passato o da quello predefinito creato dal costrutto) è disponibile come proprietà. `role` Tuttavia, questa proprietà non è disponibile su risorse esterne. Pertanto, questi costrutti hanno un metodo `addToRolePolicy` (Python`add_to_role_policy`:).

Il metodo non fa nulla se il costrutto è una risorsa esterna e in caso contrario chiama il metodo `addToPolicy` (Python`add_to_policy`:) `role` della proprietà. Questo ti evita la fatica di gestire il caso indefinito in modo esplicito.

L'esempio seguente dimostra:

**Example**  

```
// project is imported into the CDK application
const project = codebuild.Project.fromProjectName(this, 'Project', 'ProjectName');

// project is imported, so project.role is undefined, and this call has no effect
project.addToRolePolicy(new iam.PolicyStatement({
  effect: iam.Effect.ALLOW,   // ... and so on defining the policy
}));
```

```
// project is imported into the CDK application
const project = codebuild.Project.fromProjectName(this, 'Project', 'ProjectName');

// project is imported, so project.role is undefined, and this call has no effect
project.addToRolePolicy(new iam.PolicyStatement({
  effect: iam.Effect.ALLOW   // ... and so on defining the policy
}));
```

```
# project is imported into the CDK application
project = codebuild.Project.from_project_name(self, 'Project', 'ProjectName')

# project is imported, so project.role is undefined, and this call has no effect
project.add_to_role_policy(iam.PolicyStatement(
  effect=iam.Effect.ALLOW,   # ... and so on defining the policy
  )
)
```

```
// project is imported into the CDK application
Project project = Project.fromProjectName(this, "Project", "ProjectName");

// project is imported, so project.getRole() is null, and this call has no effect
project.addToRolePolicy(PolicyStatement.Builder.create()
        .effect(Effect.ALLOW)   // .. and so on defining the policy
        .build();
)
```

```
// project is imported into the CDK application
var project = Project.FromProjectName(this, "Project", "ProjectName");

// project is imported, so project.role is null, and this call has no effect
project.AddToRolePolicy(new PolicyStatement(new PolicyStatementProps
{
    Effect = Effect.ALLOW, // ... and so on defining the policy
}));
```

## Policy delle risorse
<a name="permissions-resource-policies"></a>

Alcune risorse AWS, come i bucket Amazon S3 e i ruoli IAM, hanno anche una politica delle risorse. Questi costrutti hanno un `addToResourcePolicy` metodo (Python`add_to_resource_policy`:), che accetta [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.PolicyStatement.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.PolicyStatement.html)a come argomento. Ogni dichiarazione politica aggiunta a una politica delle risorse deve specificare almeno un principio.

Nell'esempio seguente, il [bucket Amazon S3](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html) `bucket` concede un ruolo con l'`s3:SomeAction`autorizzazione a se stesso.

**Example**  

```
bucket.addToResourcePolicy(new iam.PolicyStatement({
  effect: iam.Effect.ALLOW,
  actions: ['s3:SomeAction'],
  resources: [bucket.bucketArn],
  principals: [role]
}));
```

```
bucket.addToResourcePolicy(new iam.PolicyStatement({
  effect: iam.Effect.ALLOW,
  actions: ['s3:SomeAction'],
  resources: [bucket.bucketArn],
  principals: [role]
}));
```

```
bucket.add_to_resource_policy(iam.PolicyStatement(
    effect=iam.Effect.ALLOW,
    actions=["s3:SomeAction"],
    resources=[bucket.bucket_arn],
    principals=role))
```

```
bucket.addToResourcePolicy(PolicyStatement.Builder.create()
        .effect(Effect.ALLOW)
        .actions(Arrays.asList("s3:SomeAction"))
        .resources(Arrays.asList(bucket.getBucketArn()))
        .principals(Arrays.asList(role))
        .build());
```

```
bucket.AddToResourcePolicy(new PolicyStatement(new PolicyStatementProps
{
    Effect = Effect.ALLOW,
    Actions = new string[] { "s3:SomeAction" },
    Resources = new string[] { bucket.BucketArn },
    Principals = new IPrincipal[] { role }
}));
```

## Utilizzo di oggetti IAM esterni
<a name="permissions-existing"></a>

Se hai definito un utente, un principale, un gruppo o un ruolo IAM al di fuori dell'app AWS CDK, puoi utilizzare quell'oggetto IAM nell'app AWS CDK. A tale scopo, create un riferimento ad esso utilizzando il suo ARN o il suo nome. (Usa il nome per utenti, gruppi e ruoli). Il riferimento restituito può quindi essere utilizzato per concedere autorizzazioni o per creare dichiarazioni politiche come spiegato in precedenza.
+ Per gli utenti, chiama [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.User.html#static-fromwbruserwbrarnscope-id-userarn](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.User.html#static-fromwbruserwbrarnscope-id-userarn)o. [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.User.html#static-fromwbruserwbrnamescope-id-username](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.User.html#static-fromwbruserwbrnamescope-id-username) `User.fromUserAttributes()`è anche disponibile, ma attualmente offre le stesse funzionalità di`User.fromUserArn()`.
+ Per i principali, crea un'istanza di un oggetto. [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.ArnPrincipal.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.ArnPrincipal.html)
+ Per gruppi, chiama o. [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Group.html#static-fromwbrgroupwbrarnscope-id-grouparn](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Group.html#static-fromwbrgroupwbrarnscope-id-grouparn)
+ Per ruoli, chiama [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html#static-fromwbrrolewbrarnscope-id-rolearn-options](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html#static-fromwbrrolewbrarnscope-id-rolearn-options)o [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html#static-fromwbrrolewbrnamescope-id-rolename](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html#static-fromwbrrolewbrnamescope-id-rolename).

Le politiche (incluse le politiche gestite) possono essere utilizzate in modo simile utilizzando i seguenti metodi. È possibile utilizzare riferimenti a questi oggetti ovunque sia richiesta una policy IAM.
+  [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Policy.html#static-fromwbrpolicywbrnamescope-id-policyname](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Policy.html#static-fromwbrpolicywbrnamescope-id-policyname) 
+  [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.ManagedPolicy.html#static-fromwbrmanagedwbrpolicywbrarnscope-id-managedpolicyarn](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.ManagedPolicy.html#static-fromwbrmanagedwbrpolicywbrarnscope-id-managedpolicyarn) 
+  [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.ManagedPolicy.html#static-fromwbrmanagedwbrpolicywbrnamescope-id-managedpolicyname](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.ManagedPolicy.html#static-fromwbrmanagedwbrpolicywbrnamescope-id-managedpolicyname) 
+  [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.ManagedPolicy.html#static-fromwbrawswbrmanagedwbrpolicywbrnamemanagedpolicyname](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.ManagedPolicy.html#static-fromwbrawswbrmanagedwbrpolicywbrnamemanagedpolicyname) 

**Nota**  
Come per tutti i riferimenti a AWS risorse esterne, non è possibile modificare oggetti IAM esterni nell'app CDK.