Autorizzazioni e AWS CDK - AWS Cloud Development Kit (AWS CDK) v2

Questa è la guida per sviluppatori AWS CDK v2. La versione precedente della CDK versione 1 è entrata 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 AWS CDK

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

AWS CDK utilizza AWS CloudFormation per distribuire 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ù IAM identità (utente o ruoli) e facoltativamente cederà un ruolo a. AWS CloudFormation

Se utilizzi l' AWS IAM Identity Center autenticazione come utente, il provider Single Sign-On fornisce credenziali di sessione di breve durata che ti autorizzano a svolgere un ruolo predefinito. IAM Per sapere come AWS CDK ottiene le AWS credenziali dall'autenticazione di Identity Center, consulta Understand IAM Identity Center Authentication nella and Tools Reference IAM Guide.AWS SDKs

Principali

Un IAM principale è 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 IAM gruppo, puoi concedere al gruppo (e quindi ai suoi membri) l'accesso in scrittura a una RDS tabella Amazon. Tuttavia, il gruppo in sé non è un principale perché non rappresenta una singola entità (inoltre, non è possibile accedere a un gruppo).

Nella CDK sua IAM libreria, le classi che identificano direttamente o indirettamente i principali implementano l'IPrincipalinterfaccia, 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. IAMrisorse come RoleUser, e Group

  2. Responsabili del servizio () new iam.ServicePrincipal('service.amazonaws.com')

  3. Responsabili federati () new iam.FederatedPrincipal('cognito-identity.amazonaws.com')

  4. Responsabili del conto (new iam.AccountPrincipal('0123456789012'))

  5. Principi utente canonici () new iam.CanonicalUserPrincipal('79a59d[...]7ef2be')

  6. AWS Organizations presidi () new iam.OrganizationPrincipal('org-id')

  7. ARNPrincipi arbitrari () new iam.ArnPrincipal(res.arn)

  8. E iam.CompositePrincipal(principal1, principal2, ...) fidarsi di più principi

Concessioni

Ogni costrutto che rappresenta una risorsa a cui è possibile accedere, ad esempio un bucket Amazon S3 o una tabella Amazon DynamoDB, ha metodi che garantiscono l'accesso a un'altra entità. Tutti questi metodi hanno nomi che iniziano con grant.

Ad esempio, i bucket Amazon S3 dispongono dei metodi e grantRead (grantReadWritePython:grant_read,grant_read_write) per abilitare l'accesso in lettura e lettura/scrittura, rispettivamente, da un'entità al bucket. L'entità non deve sapere esattamente quali IAM autorizzazioni Amazon S3 sono necessarie per eseguire queste operazioni.

Il primo argomento di un metodo di concessione è sempre di tipo. IGrantable Questa interfaccia rappresenta le entità a cui possono essere concesse le autorizzazioni. Cioè, rappresenta risorse con ruoli, come gli IAM oggetti RoleUser, eGroup.

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 esempiolambda.Function, implementanoIGrantable, 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.

TypeScript
bucket.grantRead(function);
JavaScript
bucket.grantRead(function);
Python
bucket.grant_read(function)
Java
bucket.grantRead(function);
C#
bucket.GrantRead(function);

A volte le autorizzazioni devono essere applicate 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 che gli viene 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

TypeScript
const grant = bucket.grantRead(lambda); const custom = new CustomResource(...); custom.node.addDependency(grant);
JavaScript
const grant = bucket.grantRead(lambda); const custom = new CustomResource(...); custom.node.addDependency(grant);
Python
grant = bucket.grant_read(function) custom = CustomResource(...) custom.node.add_dependency(grant)
Java
Grant grant = bucket.grantRead(function); CustomResource custom = new CustomResource(...); custom.node.addDependency(grant);
C#
var grant = bucket.GrantRead(function); var custom = new CustomResource(...); custom.node.AddDependency(grant);

Roles

Il IAM pacchetto contiene un Role costrutto che rappresenta i ruoli. IAM Il codice seguente crea un nuovo ruolo, affidandosi al EC2 servizio Amazon.

TypeScript
import * as iam from 'aws-cdk-lib/aws-iam'; const role = new iam.Role(this, 'Role', { assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'), // required });
JavaScript
const iam = require('aws-cdk-lib/aws-iam'); const role = new iam.Role(this, 'Role', { assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com') // required });
Python
import aws_cdk.aws_iam as iam role = iam.Role(self, "Role", assumed_by=iam.ServicePrincipal("ec2.amazonaws.com")) # required
Java
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();
C#
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 addToPolicy metodo del ruolo (Pythonadd_to_policy:), passando PolicyStatement 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

TypeScript
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', }}}));
JavaScript
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' }}}));
Python
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"}} ))
Java
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());
C#
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 PolicyStatement inline con la chiamata (addToPolicyPython:). add_to_policy Puoi anche inserire una dichiarazione politica esistente o una che hai modificato. L'PolicyStatementoggetto dispone di numerosi metodi 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

TypeScript
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, });
JavaScript
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 });
Python
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)
Java
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();
C#
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 (Pythonadd_to_role_policy:).

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

L'esempio seguente dimostra:

TypeScript
// 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 }));
JavaScript
// 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 }));
Python
# 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 )
Java
// 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();
C#
// 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

Alcune risorse AWS, come i bucket e i IAM ruoli di Amazon S3, hanno anche una politica delle risorse. Questi costrutti hanno un addToResourcePolicy metodo (Pythonadd_to_resource_policy:), che accetta PolicyStatement a come argomento. Ogni dichiarazione politica aggiunta a una politica delle risorse deve specificare almeno un principio.

Nell'esempio seguente, il bucket Amazon S3 bucket concede un ruolo con l's3:SomeActionautorizzazione a se stesso.

TypeScript
bucket.addToResourcePolicy(new iam.PolicyStatement({ effect: iam.Effect.ALLOW, actions: ['s3:SomeAction'], resources: [bucket.bucketArn], principals: [role] }));
JavaScript
bucket.addToResourcePolicy(new iam.PolicyStatement({ effect: iam.Effect.ALLOW, actions: ['s3:SomeAction'], resources: [bucket.bucketArn], principals: [role] }));
Python
bucket.add_to_resource_policy(iam.PolicyStatement( effect=iam.Effect.ALLOW, actions=["s3:SomeAction"], resources=[bucket.bucket_arn], principals=role))
Java
bucket.addToResourcePolicy(PolicyStatement.Builder.create() .effect(Effect.ALLOW) .actions(Arrays.asList("s3:SomeAction")) .resources(Arrays.asList(bucket.getBucketArn())) .principals(Arrays.asList(role)) .build());
C#
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 esterni IAM

Se hai definito un IAM utente, un responsabile, un gruppo o un ruolo all'esterno AWS CDK dell'app, puoi utilizzare quell'IAMoggetto nell' AWS CDK app. Per farlo, crea un riferimento ad esso usando ARN 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.

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 IAM policy.

Nota

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