Skip to content
v2.277.0

CfnSecurityConfigurationProps Struct ​

Properties for defining a CfnSecurityConfiguration.

Example ​

ts
import * as emr from 'aws-cdk-lib/aws-emr';

const cfnSecurityConfiguration = new emr.CfnSecurityConfiguration(this, 'EmrSecurityConfiguration', {
  name: 'AddStepRuntimeRoleSecConfig',
  securityConfiguration: JSON.parse(`
    {
      "AuthorizationConfiguration": {
          "IAMConfiguration": {
              "EnableApplicationScopedIAMRole": true,
              "ApplicationScopedIAMRoleConfiguration":
                  {
                      "PropagateSourceIdentity": true
                  }
          },
          "LakeFormationConfiguration": {
              "AuthorizedSessionTagValue": "Amazon EMR"
          }
      }
    }`),
});

const task = new tasks.EmrCreateCluster(this, 'Create Cluster', {
  instances: {},
  name: sfn.TaskInput.fromJsonPathAt('$.ClusterName').value,
  securityConfiguration: cfnSecurityConfiguration.name,
});

const executionRole = new iam.Role(this, 'Role', {
  assumedBy: new iam.ArnPrincipal(task.clusterRole.roleArn),
});

executionRole.assumeRolePolicy?.addStatements(
  new iam.PolicyStatement({
    effect: iam.Effect.ALLOW,
    principals: [
      task.clusterRole,
    ],
    actions: [
      'sts:SetSourceIdentity',
    ],
  }),
  new iam.PolicyStatement({
    effect: iam.Effect.ALLOW,
    principals: [
      task.clusterRole,
    ],
    actions: [
      'sts:TagSession',
    ],
    conditions: {
      StringEquals: {
        'aws:RequestTag/LakeFormationAuthorizedCaller': 'Amazon EMR',
      },
    },
  }),
);

new tasks.EmrAddStep(this, 'Task', {
  clusterId: 'ClusterId',
  executionRoleArn: executionRole.roleArn,
  name: 'StepName',
  jar: 'Jar',
  actionOnFailure: tasks.ActionOnFailure.CONTINUE,
});
python
import aws_cdk.aws_emr as emr


cfn_security_configuration = emr.CfnSecurityConfiguration(self, "EmrSecurityConfiguration",
    name="AddStepRuntimeRoleSecConfig",
    security_configuration=JSON.parse("""
            {
              "AuthorizationConfiguration": {
                  "IAMConfiguration": {
                      "EnableApplicationScopedIAMRole": true,
                      "ApplicationScopedIAMRoleConfiguration":
                          {
                              "PropagateSourceIdentity": true
                          }
                  },
                  "LakeFormationConfiguration": {
                      "AuthorizedSessionTagValue": "Amazon EMR"
                  }
              }
            }""")
)

task = tasks.EmrCreateCluster(self, "Create Cluster",
    instances=tasks.EmrCreateCluster.InstancesConfigProperty(),
    name=sfn.TaskInput.from_json_path_at("$.ClusterName").value,
    security_configuration=cfn_security_configuration.name
)

execution_role = iam.Role(self, "Role",
    assumed_by=iam.ArnPrincipal(task.cluster_role.role_arn)
)

execution_role.assume_role_policy.add_statements(
    iam.PolicyStatement(
        effect=iam.Effect.ALLOW,
        principals=[task.cluster_role
        ],
        actions=["sts:SetSourceIdentity"
        ]
    ),
    iam.PolicyStatement(
        effect=iam.Effect.ALLOW,
        principals=[task.cluster_role
        ],
        actions=["sts:TagSession"
        ],
        conditions={
            "StringEquals": {
                "aws:RequestTag/LakeFormationAuthorizedCaller": "Amazon EMR"
            }
        }
    ))

tasks.EmrAddStep(self, "Task",
    cluster_id="ClusterId",
    execution_role_arn=execution_role.role_arn,
    name="StepName",
    jar="Jar",
    action_on_failure=tasks.ActionOnFailure.CONTINUE
)
java
import software.amazon.awscdk.services.emr.*;


CfnSecurityConfiguration cfnSecurityConfiguration = CfnSecurityConfiguration.Builder.create(this, "EmrSecurityConfiguration")
        .name("AddStepRuntimeRoleSecConfig")
        .securityConfiguration(JSON.parse("\n    {\n      \"AuthorizationConfiguration\": {\n          \"IAMConfiguration\": {\n              \"EnableApplicationScopedIAMRole\": true,\n              \"ApplicationScopedIAMRoleConfiguration\":\n                  {\n                      \"PropagateSourceIdentity\": true\n                  }\n          },\n          \"LakeFormationConfiguration\": {\n              \"AuthorizedSessionTagValue\": \"Amazon EMR\"\n          }\n      }\n    }"))
        .build();

EmrCreateCluster task = EmrCreateCluster.Builder.create(this, "Create Cluster")
        .instances(InstancesConfigProperty.builder().build())
        .name(TaskInput.fromJsonPathAt("$.ClusterName").getValue())
        .securityConfiguration(cfnSecurityConfiguration.getName())
        .build();

Role executionRole = Role.Builder.create(this, "Role")
        .assumedBy(new ArnPrincipal(task.getClusterRole().getRoleArn()))
        .build();

executionRole.assumeRolePolicy.addStatements(
PolicyStatement.Builder.create()
        .effect(Effect.ALLOW)
        .principals(List.of(task.getClusterRole()))
        .actions(List.of("sts:SetSourceIdentity"))
        .build(),
PolicyStatement.Builder.create()
        .effect(Effect.ALLOW)
        .principals(List.of(task.getClusterRole()))
        .actions(List.of("sts:TagSession"))
        .conditions(Map.of(
                "StringEquals", Map.of(
                        "aws:RequestTag/LakeFormationAuthorizedCaller", "Amazon EMR")))
        .build());

EmrAddStep.Builder.create(this, "Task")
        .clusterId("ClusterId")
        .executionRoleArn(executionRole.getRoleArn())
        .name("StepName")
        .jar("Jar")
        .actionOnFailure(ActionOnFailure.CONTINUE)
        .build();
csharp
// Install: dotnet add package Amazon.CDK.Lib
using Amazon.CDK.AWS.EMR;


var cfnSecurityConfiguration = new CfnSecurityConfiguration(this, "EmrSecurityConfiguration", new CfnSecurityConfigurationProps {
    Name = "AddStepRuntimeRoleSecConfig",
    SecurityConfiguration = JSON.Parse(@"
        {
          ""AuthorizationConfiguration"": {
              ""IAMConfiguration"": {
                  ""EnableApplicationScopedIAMRole"": true,
                  ""ApplicationScopedIAMRoleConfiguration"":
                      {
                          ""PropagateSourceIdentity"": true
                      }
              },
              ""LakeFormationConfiguration"": {
                  ""AuthorizedSessionTagValue"": ""Amazon EMR""
              }
          }
        }")
});

var task = new EmrCreateCluster(this, "Create Cluster", new EmrCreateClusterProps {
    Instances = new InstancesConfigProperty { },
    Name = TaskInput.FromJsonPathAt("$.ClusterName").Value,
    SecurityConfiguration = cfnSecurityConfiguration.Name
});

var executionRole = new Role(this, "Role", new RoleProps {
    AssumedBy = new ArnPrincipal(task.ClusterRole.RoleArn)
});

executionRole.AssumeRolePolicy.AddStatements(
new PolicyStatement(new PolicyStatementProps {
    Effect = Effect.ALLOW,
    Principals = new [] { task.ClusterRole },
    Actions = new [] { "sts:SetSourceIdentity" }
}),
new PolicyStatement(new PolicyStatementProps {
    Effect = Effect.ALLOW,
    Principals = new [] { task.ClusterRole },
    Actions = new [] { "sts:TagSession" },
    Conditions = new Dictionary<string, object> {
        { "StringEquals", new Dictionary<string, string> {
            { "aws:RequestTag/LakeFormationAuthorizedCaller", "Amazon EMR" }
        } }
    }
}));

new EmrAddStep(this, "Task", new EmrAddStepProps {
    ClusterId = "ClusterId",
    ExecutionRoleArn = executionRole.RoleArn,
    Name = "StepName",
    Jar = "Jar",
    ActionOnFailure = ActionOnFailure.CONTINUE
});
go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
import emr "github.com/aws/aws-cdk-go/awscdk"


cfnSecurityConfiguration := emr.NewCfnSecurityConfiguration(this, jsii.String("EmrSecurityConfiguration"), &CfnSecurityConfigurationProps{
	Name: jsii.String("AddStepRuntimeRoleSecConfig"),
	SecurityConfiguration: jSON.parse(jsii.String(`
	    {
	      "AuthorizationConfiguration": {
	          "IAMConfiguration": {
	              "EnableApplicationScopedIAMRole": true,
	              "ApplicationScopedIAMRoleConfiguration":
	                  {
	                      "PropagateSourceIdentity": true
	                  }
	          },
	          "LakeFormationConfiguration": {
	              "AuthorizedSessionTagValue": "Amazon EMR"
	          }
	      }
	    }`)),
})

task := tasks.NewEmrCreateCluster(this, jsii.String("Create Cluster"), &EmrCreateClusterProps{
	Instances: &InstancesConfigProperty{
	},
	Name: sfn.TaskInput_FromJsonPathAt(jsii.String("$.ClusterName")).value,
	SecurityConfiguration: cfnSecurityConfiguration.name,
})

executionRole := iam.NewRole(this, jsii.String("Role"), &RoleProps{
	AssumedBy: iam.NewArnPrincipal(task.clusterRole.RoleArn),
})

executionRole.AssumeRolePolicy.AddStatements(
iam.NewPolicyStatement(&PolicyStatementProps{
	Effect: iam.Effect_ALLOW,
	Principals: []IPrincipal{
		task.clusterRole,
	},
	Actions: []*string{
		jsii.String("sts:SetSourceIdentity"),
	},
}),
iam.NewPolicyStatement(&PolicyStatementProps{
	Effect: iam.Effect_ALLOW,
	Principals: []IPrincipal{
		task.clusterRole,
	},
	Actions: []*string{
		jsii.String("sts:TagSession"),
	},
	Conditions: map[string]interface{}{
		"StringEquals": map[string]*string{
			"aws:RequestTag/LakeFormationAuthorizedCaller": jsii.String("Amazon EMR"),
		},
	},
}))

tasks.NewEmrAddStep(this, jsii.String("Task"), &EmrAddStepProps{
	ClusterId: jsii.String("ClusterId"),
	ExecutionRoleArn: executionRole.roleArn,
	Name: jsii.String("StepName"),
	Jar: jsii.String("Jar"),
	ActionOnFailure: tasks.ActionOnFailure_CONTINUE,
})

Properties ​

nameoptionalstringnameoptionalstrnameoptionalStringNameoptionalstringNameoptional*string#
The name of the security configuration.
securityConfigurationanysecurity_configurationAnysecurityConfigurationObjectSecurityConfigurationobjectSecurityConfigurationinterface{}required#
The security configuration details in JSON format.

For JSON parameters and examples, see Use Security Configurations to Set Up Cluster Security in the Amazon EMR Management Guide .