Créez des politiques IAM à l'aide du AWS SDK for Java 2.x

L'API IAM Policy Builder est une bibliothèque que vous pouvez utiliser pour créer des politiques IAM en Java et les télécharger vers Gestion des identités et des accès AWS (IAM).

Au lieu de créer une politique IAM en assemblant manuellement une chaîne JSON ou en lisant un fichier, l'API propose une approche orientée objet côté client pour générer la chaîne JSON. Lorsque vous lisez une politique IAM existante au format JSON, l'API la convertit en IamPolicy instance à gérer.

L'API IAM Policy Builder est devenue disponible avec la version 2.20.105 du SDK. Utilisez donc cette version ou une version ultérieure dans votre fichier de compilation Maven. Le dernier numéro de version du SDK est répertorié sur Maven Central.

L'extrait suivant montre un exemple de bloc de dépendance pour un fichier pom.xml Maven. Cela vous permet d'utiliser l'API IAM Policy Builder dans votre projet.

<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>iam-policy-builder</artifactId>
    <version>2.27.21</version>
</dependency>

Créer un IamPolicy

Cette section présente plusieurs exemples de création de politiques à l'aide de l'API IAM Policy Builder.

Dans chacun des exemples suivants, commencez par IamPolicy.Builder et ajoutez une ou plusieurs instructions à l'aide de la addStatement méthode. En suivant ce modèle, les méthodes IamStatement.Builder has permettent d'ajouter l'effet, les actions, les ressources et les conditions à l'instruction.

Exemple : créer une politique basée sur le temps

L'exemple suivant crée une politique basée sur l'identité qui autorise l'GetItemaction Amazon DynamoDB entre deux moments.

    public String timeBasedPolicyExample() {
        IamPolicy policy = IamPolicy.builder()
                .addStatement(b -> b
                        .effect(IamEffect.ALLOW)
                        .addAction("dynamodb:GetItem")
                        .addResource(IamResource.ALL)
                        .addCondition(b1 -> b1
                                .operator(IamConditionOperator.DATE_GREATER_THAN)
                                .key("aws:CurrentTime")
                                .value("2020-04-01T00:00:00Z"))
                        .addCondition(b1 -> b1
                                .operator(IamConditionOperator.DATE_LESS_THAN)
                                .key("aws:CurrentTime")
                                .value("2020-06-30T23:59:59Z")))
                .build();

        // Use an IamPolicyWriter to write out the JSON string to a more readable format.
        return policy.toJson(IamPolicyWriter.builder()
                        .prettyPrint(true)
                        .build());
    }

Exemple : Spécifiez plusieurs conditions

L'exemple suivant montre comment créer une politique basée sur l'identité qui permet d'accéder à des attributs DynamoDB spécifiques. La politique contient trois conditions.

    public String multipleConditionsExample() {
        IamPolicy policy = IamPolicy.builder()
                .addStatement(b -> b
                        .effect(IamEffect.ALLOW)
                        .addAction("dynamodb:GetItem")
                        .addAction("dynamodb:BatchGetItem")
                        .addAction("dynamodb:Query")
                        .addAction("dynamodb:PutItem")
                        .addAction("dynamodb:UpdateItem")
                        .addAction("dynamodb:DeleteItem")
                        .addAction("dynamodb:BatchWriteItem")
                        .addResource("arn:aws:dynamodb:*:*:table/table-name")
                        .addConditions(IamConditionOperator.STRING_EQUALS.addPrefix("ForAllValues:"),
                                "dynamodb:Attributes",
                                List.of("column-name1", "column-name2", "column-name3"))
                        .addCondition(b1 -> b1.operator(IamConditionOperator.STRING_EQUALS.addSuffix("IfExists"))
                                .key("dynamodb:Select")
                                .value("SPECIFIC_ATTRIBUTES"))
                        .addConditions(IamConditionOperator.STRING_EQUALS,
                                "dynamodb:ReturnValues",
                                List.of("NONE", "UPDATED_OLD", "UPDATED_NEW")))
                .build();

        return policy.toJson(IamPolicyWriter.builder()
                .prettyPrint(true).build());
    }

Exemple : Spécifier les directeurs

L'exemple suivant montre comment créer une politique basée sur les ressources qui refuse l'accès à un compartiment pour tous les principaux, à l'exception de ceux spécifiés dans la condition.

    public String specifyPrincipalsExample() {
        IamPolicy policy = IamPolicy.builder()
                .addStatement(b -> b
                        .effect(IamEffect.DENY)
                        .addAction("s3:*")
                        .addPrincipal(IamPrincipal.ALL)
                        .addResource("arn:aws:s3:::BUCKETNAME/*")
                        .addResource("arn:aws:s3:::BUCKETNAME")
                        .addCondition(b1 -> b1
                                .operator(IamConditionOperator.ARN_NOT_EQUALS)
                                .key("aws:PrincipalArn")
                                .value("arn:aws:iam::444455556666:user/user-name")))
                .build();
        return policy.toJson(IamPolicyWriter.builder()
                .prettyPrint(true).build());
    }

Exemple : Autoriser l'accès entre comptes

L'exemple suivant montre comment autoriser une autre personne Compte AWS à charger des objets dans votre compartiment tout en conservant le contrôle total du propriétaire sur les objets chargés.

    public String allowCrossAccountAccessExample() {
        IamPolicy policy = IamPolicy.builder()
                .addStatement(b -> b
                        .effect(IamEffect.ALLOW)
                        .addPrincipal(IamPrincipalType.AWS, "111122223333")
                        .addAction("s3:PutObject")
                        .addResource("arn:aws:s3:::amzn-s3-demo-bucket/*")
                        .addCondition(b1 -> b1
                                .operator(IamConditionOperator.STRING_EQUALS)
                                .key("s3:x-amz-acl")
                                .value("bucket-owner-full-control")))
                .build();
        return policy.toJson(IamPolicyWriter.builder()
                .prettyPrint(true).build());
    }

Utiliser et IamPolicy avec IAM

Après avoir créé une IamPolicy instance, vous utilisez un IamClient pour utiliser le service IAM.

L'exemple suivant crée une politique qui permet à une identité IAM d'écrire des éléments dans une table DynamoDB du compte spécifié par le paramètre. accountID La politique est ensuite téléchargée dans IAM sous forme de chaîne JSON.

    public String createAndUploadPolicyExample(IamClient iam, String accountID, String policyName) {
        // Build the policy.
        IamPolicy policy =
                IamPolicy.builder() // 'version' defaults to "2012-10-17".
                        .addStatement(IamStatement.builder()
                                .effect(IamEffect.ALLOW)
                                .addAction("dynamodb:PutItem")
                                .addResource("arn:aws:dynamodb:us-east-1:" + accountID + ":table/exampleTableName")
                                .build())
                        .build();
        // Upload the policy.
        iam.createPolicy(r -> r.policyName(policyName).policyDocument(policy.toJson()));
        return policy.toJson(IamPolicyWriter.builder().prettyPrint(true).build());
    }

L'exemple suivant s'appuie sur l'exemple précédent. Le code télécharge la politique et l'utilise comme base pour une nouvelle politique en copiant et en modifiant la déclaration. La nouvelle politique est ensuite téléchargée.

    public String createNewBasedOnExistingPolicyExample(IamClient iam, String accountID, String policyName, String newPolicyName) {

        String policyArn = "arn:aws:iam::" + accountID + ":policy/" + policyName;
        GetPolicyResponse getPolicyResponse = iam.getPolicy(r -> r.policyArn(policyArn));

        String policyVersion = getPolicyResponse.policy().defaultVersionId();
        GetPolicyVersionResponse getPolicyVersionResponse =
                iam.getPolicyVersion(r -> r.policyArn(policyArn).versionId(policyVersion));

        // Create an IamPolicy instance from the JSON string returned from IAM.
        String decodedPolicy = URLDecoder.decode(getPolicyVersionResponse.policyVersion().document(), StandardCharsets.UTF_8);
        IamPolicy policy = IamPolicy.fromJson(decodedPolicy);

            /*
             All IamPolicy components are immutable, so use the copy method that creates a new instance that
             can be altered in the same method call.

             Add the ability to get an item from DynamoDB as an additional action.
            */
        IamStatement newStatement = policy.statements().get(0).copy(s -> s.addAction("dynamodb:GetItem"));

        // Create a new statement that replaces the original statement.
        IamPolicy newPolicy = policy.copy(p -> p.statements(Arrays.asList(newStatement)));

        // Upload the new policy. IAM now has both policies.
        iam.createPolicy(r -> r.policyName(newPolicyName)
                .policyDocument(newPolicy.toJson()));

        return newPolicy.toJson(IamPolicyWriter.builder().prettyPrint(true).build());
    }

IamClient iam = IamClient.builder().region(Region.AWS_GLOBAL).build();

First example
{
  "Version": "2012-10-17",
  "Statement" : {
    "Effect" : "Allow",
    "Action" : "dynamodb:PutItem",
    "Resource" : "arn:aws:dynamodb:us-east-1:111122223333:table/exampleTableName"
  }
}

Second example
{
  "Version": "2012-10-17",
  "Statement" : {
    "Effect" : "Allow",
    "Action" : [ "dynamodb:PutItem", "dynamodb:GetItem" ],
    "Resource" : "arn:aws:dynamodb:us-east-1:111122223333:table/exampleTableName"
  }
}