iam

package
v3.38.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 13, 2021 License: Apache-2.0 Imports: 7 Imported by: 4

Documentation

Index

Constants

View Source 
const (
	ManagedPolicyAWSAccountActivityAccess                    = ManagedPolicy("arn:aws:iam::aws:policy/AWSAccountActivityAccess")
	ManagedPolicyAWSAccountUsageReportAccess                 = ManagedPolicy("arn:aws:iam::aws:policy/AWSAccountUsageReportAccess")
	ManagedPolicyAWSAgentlessDiscoveryService                = ManagedPolicy("arn:aws:iam::aws:policy/AWSAgentlessDiscoveryService")
	ManagedPolicyAWSApplicationDiscoveryAgentAccess          = ManagedPolicy("arn:aws:iam::aws:policy/AWSApplicationDiscoveryAgentAccess")
	ManagedPolicyAWSApplicationDiscoveryServiceFullAccess    = ManagedPolicy("arn:aws:iam::aws:policy/AWSApplicationDiscoveryServiceFullAccess")
	ManagedPolicyAWSBatchFullAccess                          = ManagedPolicy("arn:aws:iam::aws:policy/AWSBatchFullAccess")
	ManagedPolicyAWSBatchServiceRole                         = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSBatchServiceRole")
	ManagedPolicyAWSCertificateManagerFullAccess             = ManagedPolicy("arn:aws:iam::aws:policy/AWSCertificateManagerFullAccess")
	ManagedPolicyAWSCertificateManagerReadOnly               = ManagedPolicy("arn:aws:iam::aws:policy/AWSCertificateManagerReadOnly")
	ManagedPolicyAWSCloudFormationReadOnlyAccess             = ManagedPolicy("arn:aws:iam::aws:policy/AWSCloudFormationReadOnlyAccess")
	ManagedPolicyAWSCloudHSMFullAccess                       = ManagedPolicy("arn:aws:iam::aws:policy/AWSCloudHSMFullAccess")
	ManagedPolicyAWSCloudHSMReadOnlyAccess                   = ManagedPolicy("arn:aws:iam::aws:policy/AWSCloudHSMReadOnlyAccess")
	ManagedPolicyAWSCloudHSMRole                             = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSCloudHSMRole")
	ManagedPolicyAWSCloudTrailFullAccess                     = ManagedPolicy("arn:aws:iam::aws:policy/AWSCloudTrailFullAccess")
	ManagedPolicyAWSCloudTrailReadOnlyAccess                 = ManagedPolicy("arn:aws:iam::aws:policy/AWSCloudTrailReadOnlyAccess")
	ManagedPolicyAWSCodeBuildAdminAccess                     = ManagedPolicy("arn:aws:iam::aws:policy/AWSCodeBuildAdminAccess")
	ManagedPolicyAWSCodeBuildDeveloperAccess                 = ManagedPolicy("arn:aws:iam::aws:policy/AWSCodeBuildDeveloperAccess")
	ManagedPolicyAWSCodeBuildReadOnlyAccess                  = ManagedPolicy("arn:aws:iam::aws:policy/AWSCodeBuildReadOnlyAccess")
	ManagedPolicyAWSCodeCommitFullAccess                     = ManagedPolicy("arn:aws:iam::aws:policy/AWSCodeCommitFullAccess")
	ManagedPolicyAWSCodeCommitPowerUser                      = ManagedPolicy("arn:aws:iam::aws:policy/AWSCodeCommitPowerUser")
	ManagedPolicyAWSCodeCommitReadOnly                       = ManagedPolicy("arn:aws:iam::aws:policy/AWSCodeCommitReadOnly")
	ManagedPolicyAWSCodeDeployDeployerAccess                 = ManagedPolicy("arn:aws:iam::aws:policy/AWSCodeDeployDeployerAccess")
	ManagedPolicyAWSCodeDeployFullAccess                     = ManagedPolicy("arn:aws:iam::aws:policy/AWSCodeDeployFullAccess")
	ManagedPolicyAWSCodeDeployReadOnlyAccess                 = ManagedPolicy("arn:aws:iam::aws:policy/AWSCodeDeployReadOnlyAccess")
	ManagedPolicyAWSCodeDeployRole                           = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSCodeDeployRole")
	ManagedPolicyAWSCodeDeployRoleForECS                     = ManagedPolicy("arn:aws:iam::aws:policy/AWSCodeDeployRoleForECS")
	ManagedPolicyAWSCodePipelineApproverAccess               = ManagedPolicy("arn:aws:iam::aws:policy/AWSCodePipelineApproverAccess")
	ManagedPolicyAWSCodePipelineCustomActionAccess           = ManagedPolicy("arn:aws:iam::aws:policy/AWSCodePipelineCustomActionAccess")
	ManagedPolicyAWSCodePipelineFullAccess                   = ManagedPolicy("arn:aws:iam::aws:policy/AWSCodePipelineFullAccess")
	ManagedPolicyAWSCodePipelineReadOnlyAccess               = ManagedPolicy("arn:aws:iam::aws:policy/AWSCodePipelineReadOnlyAccess")
	ManagedPolicyAWSCodeStarFullAccess                       = ManagedPolicy("arn:aws:iam::aws:policy/AWSCodeStarFullAccess")
	ManagedPolicyAWSCodeStarServiceRole                      = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSCodeStarServiceRole")
	ManagedPolicyAWSConfigRole                               = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSConfigRole")
	ManagedPolicyAWSConfigRulesExecutionRole                 = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSConfigRulesExecutionRole")
	ManagedPolicyAWSConfigUserAccess                         = ManagedPolicy("arn:aws:iam::aws:policy/AWSConfigUserAccess")
	ManagedPolicyAWSConnector                                = ManagedPolicy("arn:aws:iam::aws:policy/AWSConnector")
	ManagedPolicyAWSDataPipelineRole                         = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSDataPipelineRole")
	ManagedPolicy_AWSDataPipeline_FullAccess                 = ManagedPolicy("arn:aws:iam::aws:policy/AWSDataPipeline_FullAccess")
	ManagedPolicy_AWSDataPipeline_PowerUser                  = ManagedPolicy("arn:aws:iam::aws:policy/AWSDataPipeline_PowerUser")
	ManagedPolicyAWSDeviceFarmFullAccess                     = ManagedPolicy("arn:aws:iam::aws:policy/AWSDeviceFarmFullAccess")
	ManagedPolicyAWSDirectConnectFullAccess                  = ManagedPolicy("arn:aws:iam::aws:policy/AWSDirectConnectFullAccess")
	ManagedPolicyAWSDirectConnectReadOnlyAccess              = ManagedPolicy("arn:aws:iam::aws:policy/AWSDirectConnectReadOnlyAccess")
	ManagedPolicyAWSDirectoryServiceFullAccess               = ManagedPolicy("arn:aws:iam::aws:policy/AWSDirectoryServiceFullAccess")
	ManagedPolicyAWSDirectoryServiceReadOnlyAccess           = ManagedPolicy("arn:aws:iam::aws:policy/AWSDirectoryServiceReadOnlyAccess")
	ManagedPolicyAWSElasticBeanstalkCustomPlatformforEC2Role = ManagedPolicy("arn:aws:iam::aws:policy/AWSElasticBeanstalkCustomPlatformforEC2Role")
	ManagedPolicyAWSElasticBeanstalkEnhancedHealth           = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSElasticBeanstalkEnhancedHealth")
	ManagedPolicyAWSElasticBeanstalkFullAccess               = ManagedPolicy("arn:aws:iam::aws:policy/AWSElasticBeanstalkFullAccess")
	ManagedPolicyAWSElasticBeanstalkMulticontainerDocker     = ManagedPolicy("arn:aws:iam::aws:policy/AWSElasticBeanstalkMulticontainerDocker")
	ManagedPolicyAWSElasticBeanstalkReadOnlyAccess           = ManagedPolicy("arn:aws:iam::aws:policy/AWSElasticBeanstalkReadOnlyAccess")
	ManagedPolicyAWSElasticBeanstalkService                  = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSElasticBeanstalkService")
	ManagedPolicyAWSElasticBeanstalkWebTier                  = ManagedPolicy("arn:aws:iam::aws:policy/AWSElasticBeanstalkWebTier")
	ManagedPolicyAWSElasticBeanstakWorkerTier                = ManagedPolicy("arn:aws:iam::aws:policy/AWSElasticBeanstalkWorkerTier")
	ManagedPolicyAWSGreengrassFullccess                      = ManagedPolicy("arn:aws:iam::aws:policy/AWSGreengrassFullAccess")
	ManagedPolicyAWSGreengrassResourceAccessRolePolicy       = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSGreengrassResourceAccessRolePolicy")
	ManagedPolicyAWSHealthFullAccess                         = ManagedPolicy("arn:aws:iam::aws:policy/AWSHealthFullAccess")
	ManagedPolicyAWSImportExportFullAccess                   = ManagedPolicy("arn:aws:iam::aws:policy/AWSImportExportFullAccess")
	ManagedPolicyAWSImportExportReadOnlyAccess               = ManagedPolicy("arn:aws:iam::aws:policy/AWSImportExportReadOnlyAccess")
	ManagedPolicyAWSIoTConfigAccess                          = ManagedPolicy("arn:aws:iam::aws:policy/AWSIoTConfigAccess")
	ManagedPolicyAWSIoTConfigReadOnlyAccess                  = ManagedPolicy("arn:aws:iam::aws:policy/AWSIoTConfigReadOnlyAccess")
	ManagedPolicyAWSIoTDataAccess                            = ManagedPolicy("arn:aws:iam::aws:policy/AWSIoTDataAccess")
	ManagedPolicyAWSIoTFullAccess                            = ManagedPolicy("arn:aws:iam::aws:policy/AWSIoTFullAccess")
	ManagedPolicyAWSIoTLogging                               = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSIoTLogging")
	ManagedPolicyAWSIoTRuleActions                           = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSIoTRuleActions")
	ManagedPolicyAWSKeyManagementServicePowerUser            = ManagedPolicy("arn:aws:iam::aws:policy/AWSKeyManagementServicePowerUser")
	ManagedPolicyAWSLambdaBasicExecutionRole                 = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole")
	ManagedPolicyAWSLambdaDynamoDBExecutionRole              = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSLambdaDynamoDBExecutionRole")
	ManagedPolicyAWSLambdaENIManagementAccess                = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSLambdaENIManagementAccess")
	ManagedPolicyAWSLambdaExecute                            = ManagedPolicy("arn:aws:iam::aws:policy/AWSLambdaExecute")
	// Deprecated: This has been deprecated in favour of `LambdaFullAccess`
	ManagedPolicyAWSLambdaFullAccess           = ManagedPolicy("arn:aws:iam::aws:policy/AWSLambdaFullAccess")
	ManagedPolicyLambdaFullAccess              = ManagedPolicy("arn:aws:iam::aws:policy/AWSLambda_FullAccess")
	ManagedPolicyAWSLambdaInvocationDynamoDB   = ManagedPolicy("arn:aws:iam::aws:policy/AWSLambdaInvocation-DynamoDB")
	ManagedPolicyAWSLambdaKinesisExecutionRole = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSLambdaKinesisExecutionRole")
	// Deprecated: This has been deprecated in favour of `LambdaReadOnlyAccess`
	ManagedPolicyAWSLambdaReadOnlyAccess                               = ManagedPolicy("arn:aws:iam::aws:policy/AWSLambdaReadOnlyAccess")
	ManagedPolicyLambdaReadOnlyAccess                                  = ManagedPolicy("arn:aws:iam::aws:policy/AWSLambda_ReadOnlyAccess")
	ManagedPolicyAWSLambdaRole                                         = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSLambdaRole")
	ManagedPolicyAWSLambdaVPCAccessExecutionRole                       = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole")
	ManagedPolicyAWSMarketplaceFullAccess                              = ManagedPolicy("arn:aws:iam::aws:policy/AWSMarketplaceFullAccess")
	ManagedPolicyAWSMarketplaceGetEntitlements                         = ManagedPolicy("arn:aws:iam::aws:policy/AWSMarketplaceGetEntitlements")
	ManagedPolicyAWSMarketplaceManageSubscriptions                     = ManagedPolicy("arn:aws:iam::aws:policy/AWSMarketplaceManageSubscriptions")
	ManagedPolicyAWSMarketplaceMeteringFullAccess                      = ManagedPolicy("arn:aws:iam::aws:policy/AWSMarketplaceMeteringFullAccess")
	ManagedPolicyAWSMarketplaceReadonly                                = ManagedPolicy("arn:aws:iam::aws:policy/AWSMarketplaceRead-only")
	ManagedPolicy_AWSMobileHub_FullAccess                              = ManagedPolicy("arn:aws:iam::aws:policy/AWSMobileHub_FullAccess")
	ManagedPolicy_AWSMobileHub_ReadOnly                                = ManagedPolicy("arn:aws:iam::aws:policy/AWSMobileHub_ReadOnly")
	ManagedPolicy_AWSMobileHub_ServiceUseOnly                          = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSMobileHub_ServiceUseOnly")
	ManagedPolicyAWSOpsWorksCMInstanceProfileRole                      = ManagedPolicy("arn:aws:iam::aws:policy/AWSOpsWorksCMInstanceProfileRole")
	ManagedPolicyAWSOpsWorksCMServiceRole                              = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSOpsWorksCMServiceRole")
	ManagedPolicyAWSOpsWorksCloudWatchLogs                             = ManagedPolicy("arn:aws:iam::aws:policy/AWSOpsWorksCloudWatchLogs")
	ManagedPolicyAWSOpsWorksFullAccess                                 = ManagedPolicy("arn:aws:iam::aws:policy/AWSOpsWorksFullAccess")
	ManagedPolicyAWSOpsWorksInstanceRegistration                       = ManagedPolicy("arn:aws:iam::aws:policy/AWSOpsWorksInstanceRegistration")
	ManagedPolicyAWSOpsWorksRegisterCLI                                = ManagedPolicy("arn:aws:iam::aws:policy/AWSOpsWorksRegisterCLI")
	ManagedPolicyAWSOpsWorksRole                                       = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSOpsWorksRole")
	ManagedPolicyAWSQuickSightDescribeRD                               = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSQuickSightDescribeRDS")
	ManagedPolicyAWSQuickSightDescribeRedshift                         = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSQuickSightDescribeRedshift")
	ManagedPolicyAWSQuickSightListIAM                                  = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSQuickSightListIAM")
	ManagedPolicyAWSQuicksightAthenaAccess                             = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSQuicksightAthenaAccess")
	ManagedPolicyAWSStepFunctionsConsoleFullAccess                     = ManagedPolicy("arn:aws:iam::aws:policy/AWSStepFunctionsConsoleFullAccess")
	ManagedPolicyAWSStepFunctionsFullAccess                            = ManagedPolicy("arn:aws:iam::aws:policy/AWSStepFunctionsFullAccess")
	ManagedPolicyAWSStepFunctionsReadOnlyAccess                        = ManagedPolicy("arn:aws:iam::aws:policy/AWSStepFunctionsReadOnlyAccess")
	ManagedPolicyAWSStorageGatewayFullAccess                           = ManagedPolicy("arn:aws:iam::aws:policy/AWSStorageGatewayFullAccess")
	ManagedPolicyAWSStorageGatewayReadOnlyAccess                       = ManagedPolicy("arn:aws:iam::aws:policy/AWSStorageGatewayReadOnlyAccess")
	ManagedPolicyAWSSupportAccess                                      = ManagedPolicy("arn:aws:iam::aws:policy/AWSSupportAccess")
	ManagedPolicyAWSWAFFullAccess                                      = ManagedPolicy("arn:aws:iam::aws:policy/AWSWAFFullAccess")
	ManagedPolicyAWSWAFReadOnlyAccess                                  = ManagedPolicy("arn:aws:iam::aws:policy/AWSWAFReadOnlyAccess")
	ManagedPolicyAWSXrayFullAccess                                     = ManagedPolicy("arn:aws:iam::aws:policy/AWSXrayFullAccess")
	ManagedPolicyAWSXrayReadOnlyAccess                                 = ManagedPolicy("arn:aws:iam::aws:policy/AWSXrayReadOnlyAccess")
	ManagedPolicyAWSXrayWriteOnlyAccess                                = ManagedPolicy("arn:aws:iam::aws:policy/AWSXrayWriteOnlyAccess")
	ManagedPolicyAWSXRayDaemonWriteAccess                              = ManagedPolicy("arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess")
	ManagedPolicyAdministratorAccess                                   = ManagedPolicy("arn:aws:iam::aws:policy/AdministratorAccess")
	ManagedPolicyAmazonAPIGatewayAdministrator                         = ManagedPolicy("arn:aws:iam::aws:policy/AmazonAPIGatewayAdministrator")
	ManagedPolicyAmazonAPIGatewayInvokeFullAccess                      = ManagedPolicy("arn:aws:iam::aws:policy/AmazonAPIGatewayInvokeFullAccess")
	ManagedPolicyAmazonAPIGatewayPushToCloudWatchLogs                  = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonAPIGatewayPushToCloudWatchLogs")
	ManagedPolicyAmazonAppStreamFullAccess                             = ManagedPolicy("arn:aws:iam::aws:policy/AmazonAppStreamFullAccess")
	ManagedPolicyAmazonAppStreamReadOnlyAccess                         = ManagedPolicy("arn:aws:iam::aws:policy/AmazonAppStreamReadOnlyAccess")
	ManagedPolicyAmazonAppStreamServiceAccess                          = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonAppStreamServiceAccess")
	ManagedPolicyAmazonAthenaFullAccess                                = ManagedPolicy("arn:aws:iam::aws:policy/AmazonAthenaFullAccess")
	ManagedPolicyAmazonCloudDirectoryFullAccess                        = ManagedPolicy("arn:aws:iam::aws:policy/AmazonCloudDirectoryFullAccess")
	ManagedPolicyAmazonCloudDirectoryReadOnlyAccess                    = ManagedPolicy("arn:aws:iam::aws:policy/AmazonCloudDirectoryReadOnlyAccess")
	ManagedPolicyAmazonCognitoDeveloperAuthenticatedIdentities         = ManagedPolicy("arn:aws:iam::aws:policy/AmazonCognitoDeveloperAuthenticatedIdentities")
	ManagedPolicyAmazonCognitoPowerUser                                = ManagedPolicy("arn:aws:iam::aws:policy/AmazonCognitoPowerUser")
	ManagedPolicyAmazonCognitoReadOnly                                 = ManagedPolicy("arn:aws:iam::aws:policy/AmazonCognitoReadOnly")
	ManagedPolicyAmazonDMSCloudWatchLogsRole                           = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonDMSCloudWatchLogsRole")
	ManagedPolicyAmazonDMSRedshiftS3Role                               = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonDMSRedshiftS3Role")
	ManagedPolicyAmazonDMSVPCManagementRole                            = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonDMSVPCManagementRole")
	ManagedPolicyAmazonDRSVPCManagement                                = ManagedPolicy("arn:aws:iam::aws:policy/AmazonDRSVPCManagement")
	ManagedPolicyAmazonDynamoDBFullAccess                              = ManagedPolicy("arn:aws:iam::aws:policy/AmazonDynamoDBFullAccess")
	ManagedPolicyAmazonDynamoDBFullAccesswithDataPipeline              = ManagedPolicy("arn:aws:iam::aws:policy/AmazonDynamoDBFullAccesswithDataPipeline")
	ManagedPolicyAmazonDynamoDBReadOnlyAccess                          = ManagedPolicy("arn:aws:iam::aws:policy/AmazonDynamoDBReadOnlyAccess")
	ManagedPolicyAmazonEC2ContainerRegistryFullAccess                  = ManagedPolicy("arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess")
	ManagedPolicyAmazonEC2ContainerRegistryPowerUser                   = ManagedPolicy("arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryPowerUser")
	ManagedPolicyAmazonEC2ContainerRegistryReadOnly                    = ManagedPolicy("arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly")
	ManagedPolicyAmazonEC2ContainerServiceAutoscaleRole                = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceAutoscaleRole")
	ManagedPolicyAmazonEC2ContainerServiceFullAccess                   = ManagedPolicy("arn:aws:iam::aws:policy/AmazonEC2ContainerServiceFullAccess")
	ManagedPolicyAmazonEC2ContainerServiceRole                         = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceRole")
	ManagedPolicyAmazonEC2ContainerServiceforEC2Role                   = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role")
	ManagedPolicyAmazonEC2FullAccess                                   = ManagedPolicy("arn:aws:iam::aws:policy/AmazonEC2FullAccess")
	ManagedPolicyAmazonEC2ReadOnlyAccess                               = ManagedPolicy("arn:aws:iam::aws:policy/AmazonEC2ReadOnlyAccess")
	ManagedPolicyAmazonEC2ReportsAccess                                = ManagedPolicy("arn:aws:iam::aws:policy/AmazonEC2ReportsAccess")
	ManagedPolicyAmazonEC2RoleforAWSCodeDeploy                         = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonEC2RoleforAWSCodeDeploy")
	ManagedPolicyAmazonEC2RoleforDataPipelineRole                      = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonEC2RoleforDataPipelineRole")
	ManagedPolicyAmazonEC2RoleforSSM                                   = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonEC2RoleforSSM")
	ManagedPolicyAmazonEC2SpotFleetAutoscaleRole                       = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonEC2SpotFleetAutoscaleRole")
	ManagedPolicyAmazonEC2SpotFleetRole                                = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonEC2SpotFleetRole")
	ManagedPolicyAmazonEC2SpotFleetTaggingRole                         = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonEC2SpotFleetTaggingRole")
	ManagedPolicyAmazonECSFullAccess                                   = ManagedPolicy("arn:aws:iam::aws:policy/AmazonECS_FullAccess")
	ManagedPolicyAmazonECSServiceRolePolicy                            = ManagedPolicy("arn:aws:iam::aws:policy/aws-service-role/AmazonECSServiceRolePolicy")
	ManagedPolicyAmazonECSTaskExecutionRolePolicy                      = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy")
	ManagedPolicyAmazonESFullAccess                                    = ManagedPolicy("arn:aws:iam::aws:policy/AmazonESFullAccess")
	ManagedPolicyAmazonESReadOnlyAccess                                = ManagedPolicy("arn:aws:iam::aws:policy/AmazonESReadOnlyAccess")
	ManagedPolicyAmazonElastiCacheFullAccess                           = ManagedPolicy("arn:aws:iam::aws:policy/AmazonElastiCacheFullAccess")
	ManagedPolicyAmazonElastiCacheReadOnlyAccess                       = ManagedPolicy("arn:aws:iam::aws:policy/AmazonElastiCacheReadOnlyAccess")
	ManagedPolicyAmazonElasticFileSystemFullAccess                     = ManagedPolicy("arn:aws:iam::aws:policy/AmazonElasticFileSystemFullAccess")
	ManagedPolicyAmazonElasticFileSystemReadOnlyAccess                 = ManagedPolicy("arn:aws:iam::aws:policy/AmazonElasticFileSystemReadOnlyAccess")
	ManagedPolicyAmazonElasticMapReduceFullAccess                      = ManagedPolicy("arn:aws:iam::aws:policy/AmazonElasticMapReduceFullAccess")
	ManagedPolicyAmazonElasticMapReduceReadOnlyAccess                  = ManagedPolicy("arn:aws:iam::aws:policy/AmazonElasticMapReduceReadOnlyAccess")
	ManagedPolicyAmazonElasticMapReduceRole                            = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonElasticMapReduceRole")
	ManagedPolicyAmazonElasticMapReduceforAutoScalingRole              = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonElasticMapReduceforAutoScalingRole")
	ManagedPolicyAmazonElasticMapReduceforEC2Role                      = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonElasticMapReduceforEC2Role")
	ManagedPolicyAmazonElasticTranscoderFullAccess                     = ManagedPolicy("arn:aws:iam::aws:policy/AmazonElasticTranscoderFullAccess")
	ManagedPolicyAmazonElasticTranscoderJobsSubmitter                  = ManagedPolicy("arn:aws:iam::aws:policy/AmazonElasticTranscoderJobsSubmitter")
	ManagedPolicyAmazonElasticTranscoderReadOnlyAccess                 = ManagedPolicy("arn:aws:iam::aws:policy/AmazonElasticTranscoderReadOnlyAccess")
	ManagedPolicyAmazonElasticTranscoderRole                           = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonElasticTranscoderRole")
	ManagedPolicyAmazonGlacierFullAccess                               = ManagedPolicy("arn:aws:iam::aws:policy/AmazonGlacierFullAccess")
	ManagedPolicyAmazonGlacierReadOnlyAccess                           = ManagedPolicy("arn:aws:iam::aws:policy/AmazonGlacierReadOnlyAccess")
	ManagedPolicyAmazonInspectorFullAccess                             = ManagedPolicy("arn:aws:iam::aws:policy/AmazonInspectorFullAccess")
	ManagedPolicyAmazonInspectorReadOnlyAccess                         = ManagedPolicy("arn:aws:iam::aws:policy/AmazonInspectorReadOnlyAccess")
	ManagedPolicyAmazonKinesisAnalyticsFullAccess                      = ManagedPolicy("arn:aws:iam::aws:policy/AmazonKinesisAnalyticsFullAccess")
	ManagedPolicyAmazonKinesisAnalyticsReadOnly                        = ManagedPolicy("arn:aws:iam::aws:policy/AmazonKinesisAnalyticsReadOnly")
	ManagedPolicyAmazonKinesisFirehoseFullAccess                       = ManagedPolicy("arn:aws:iam::aws:policy/AmazonKinesisFirehoseFullAccess")
	ManagedPolicyAmazonKinesisFirehoseReadOnlyAccess                   = ManagedPolicy("arn:aws:iam::aws:policy/AmazonKinesisFirehoseReadOnlyAccess")
	ManagedPolicyAmazonKinesisFullAccess                               = ManagedPolicy("arn:aws:iam::aws:policy/AmazonKinesisFullAccess")
	ManagedPolicyAmazonKinesisReadOnlyAccess                           = ManagedPolicy("arn:aws:iam::aws:policy/AmazonKinesisReadOnlyAccess")
	ManagedPolicyAmazonLexFullAccess                                   = ManagedPolicy("arn:aws:iam::aws:policy/AmazonLexFullAccess")
	ManagedPolicyAmazonLexReadOnly                                     = ManagedPolicy("arn:aws:iam::aws:policy/AmazonLexReadOnly")
	ManagedPolicyAmazonLexRunBotsOnly                                  = ManagedPolicy("arn:aws:iam::aws:policy/AmazonLexRunBotsOnly")
	ManagedPolicyAmazonMachineLearningBatchPredictionsAccess           = ManagedPolicy("arn:aws:iam::aws:policy/AmazonMachineLearningBatchPredictionsAccess")
	ManagedPolicyAmazonMachineLearningCreateOnlyAccess                 = ManagedPolicy("arn:aws:iam::aws:policy/AmazonMachineLearningCreateOnlyAccess")
	ManagedPolicyAmazonMachineLearningFullAccess                       = ManagedPolicy("arn:aws:iam::aws:policy/AmazonMachineLearningFullAccess")
	ManagedPolicyAmazonMachineLearningManageRealTimeEndpointOnlyAccess = ManagedPolicy("arn:aws:iam::aws:policy/AmazonMachineLearningManageRealTimeEndpointOnlyAccess")
	ManagedPolicyAmazonMachineLearningReadOnlyAccess                   = ManagedPolicy("arn:aws:iam::aws:policy/AmazonMachineLearningReadOnlyAccess")
	ManagedPolicyAmazonMachineLearningRealTimePredictionOnlyAccess     = ManagedPolicy("arn:aws:iam::aws:policy/AmazonMachineLearningRealTimePredictionOnlyAccess")
	ManagedPolicyAmazonMachineLearningRoleforRedshiftDataSource        = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonMachineLearningRoleforRedshiftDataSource")
	ManagedPolicyAmazonMechanicalTurkFullAccess                        = ManagedPolicy("arn:aws:iam::aws:policy/AmazonMechanicalTurkFullAccess")
	ManagedPolicyAmazonMechanicalTurkReadOnly                          = ManagedPolicy("arn:aws:iam::aws:policy/AmazonMechanicalTurkReadOnly")
	ManagedPolicyAmazonMobileAnalyticsFinancialReportAccess            = ManagedPolicy("arn:aws:iam::aws:policy/AmazonMobileAnalyticsFinancialReportAccess")
	ManagedPolicyAmazonMobileAnalyticsFullAccess                       = ManagedPolicy("arn:aws:iam::aws:policy/AmazonMobileAnalyticsFullAccess")
	ManagedPolicyAmazonMobileAnalyticsNonfinancialReportAccess         = ManagedPolicy("arn:aws:iam::aws:policy/AmazonMobileAnalyticsNon-financialReportAccess")
	ManagedPolicyAmazonMobileAnalyticsWriteOnlyAccess                  = ManagedPolicy("arn:aws:iam::aws:policy/AmazonMobileAnalyticsWriteOnlyAccess")
	ManagedPolicyAmazonPollyFullAccess                                 = ManagedPolicy("arn:aws:iam::aws:policy/AmazonPollyFullAccess")
	ManagedPolicyAmazonPollyReadOnlyAccess                             = ManagedPolicy("arn:aws:iam::aws:policy/AmazonPollyReadOnlyAccess")
	ManagedPolicyAmazonRDSDirectoryServiceAccess                       = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonRDSDirectoryServiceAccess")
	ManagedPolicyAmazonRDSEnhancedMonitoringRole                       = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonRDSEnhancedMonitoringRole")
	ManagedPolicyAmazonRDSDataFullAccess                               = ManagedPolicy("arn:aws:iam::aws:policy/AmazonRDSDataFullAccess")
	ManagedPolicyAmazonRDSFullAccess                                   = ManagedPolicy("arn:aws:iam::aws:policy/AmazonRDSFullAccess")
	ManagedPolicyAmazonRDSReadOnlyAccess                               = ManagedPolicy("arn:aws:iam::aws:policy/AmazonRDSReadOnlyAccess")
	ManagedPolicyAmazonRedshiftFullAccess                              = ManagedPolicy("arn:aws:iam::aws:policy/AmazonRedshiftFullAccess")
	ManagedPolicyAmazonRedshiftReadOnlyAccess                          = ManagedPolicy("arn:aws:iam::aws:policy/AmazonRedshiftReadOnlyAccess")
	ManagedPolicyAmazonRekognitionFullAccess                           = ManagedPolicy("arn:aws:iam::aws:policy/AmazonRekognitionFullAccess")
	ManagedPolicyAmazonRekognitionReadOnlyAccess                       = ManagedPolicy("arn:aws:iam::aws:policy/AmazonRekognitionReadOnlyAccess")
	ManagedPolicyAmazonRoute53DomainsFullAccess                        = ManagedPolicy("arn:aws:iam::aws:policy/AmazonRoute53DomainsFullAccess")
	ManagedPolicyAmazonRoute53DomainsReadOnlyAccess                    = ManagedPolicy("arn:aws:iam::aws:policy/AmazonRoute53DomainsReadOnlyAccess")
	ManagedPolicyAmazonRoute53FullAccess                               = ManagedPolicy("arn:aws:iam::aws:policy/AmazonRoute53FullAccess")
	ManagedPolicyAmazonRoute53ReadOnlyAccess                           = ManagedPolicy("arn:aws:iam::aws:policy/AmazonRoute53ReadOnlyAccess")
	ManagedPolicyAmazonS3FullAccess                                    = ManagedPolicy("arn:aws:iam::aws:policy/AmazonS3FullAccess")
	ManagedPolicyAmazonS3ReadOnlyAccess                                = ManagedPolicy("arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess")
	ManagedPolicyAmazonSESFullAccess                                   = ManagedPolicy("arn:aws:iam::aws:policy/AmazonSESFullAccess")
	ManagedPolicyAmazonSESReadOnlyAccess                               = ManagedPolicy("arn:aws:iam::aws:policy/AmazonSESReadOnlyAccess")
	ManagedPolicyAmazonSNSFullAccess                                   = ManagedPolicy("arn:aws:iam::aws:policy/AmazonSNSFullAccess")
	ManagedPolicyAmazonSNSReadOnlyAccess                               = ManagedPolicy("arn:aws:iam::aws:policy/AmazonSNSReadOnlyAccess")
	ManagedPolicyAmazonSNSRole                                         = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonSNSRole")
	ManagedPolicyAmazonSQSFullAccess                                   = ManagedPolicy("arn:aws:iam::aws:policy/AmazonSQSFullAccess")
	ManagedPolicyAmazonSQSReadOnlyAccess                               = ManagedPolicy("arn:aws:iam::aws:policy/AmazonSQSReadOnlyAccess")
	ManagedPolicyAWSLambdaSQSQueueExecutionRole                        = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AWSLambdaSQSQueueExecutionRole")
	ManagedPolicyAmazonSSMAutomationApproverAccess                     = ManagedPolicy("arn:aws:iam::aws:policy/AmazonSSMAutomationApproverAccess")
	ManagedPolicyAmazonSSMAutomationRole                               = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonSSMAutomationRole")
	ManagedPolicyAmazonSSMDirectoryServiceAccess                       = ManagedPolicy("arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess")
	ManagedPolicyAmazonSSMFullAccess                                   = ManagedPolicy("arn:aws:iam::aws:policy/AmazonSSMFullAccess")
	ManagedPolicyAmazonSSMMaintenanceWindowRole                        = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AmazonSSMMaintenanceWindowRole")
	ManagedPolicyAmazonSSMPatchAssociation                             = ManagedPolicy("arn:aws:iam::aws:policy/AmazonSSMPatchAssociation")
	ManagedPolicyAmazonSSMReadOnlyAccess                               = ManagedPolicy("arn:aws:iam::aws:policy/AmazonSSMReadOnlyAccess")
	ManagedPolicyAmazonSSMManagedInstanceCore                          = ManagedPolicy("arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore")
	ManagedPolicyAmazonVPCFullAccess                                   = ManagedPolicy("arn:aws:iam::aws:policy/AmazonVPCFullAccess")
	ManagedPolicyAmazonVPCReadOnlyAccess                               = ManagedPolicy("arn:aws:iam::aws:policy/AmazonVPCReadOnlyAccess")
	ManagedPolicyAmazonWorkMailFullAccess                              = ManagedPolicy("arn:aws:iam::aws:policy/AmazonWorkMailFullAccess")
	ManagedPolicyAmazonWorkMailReadOnlyAccess                          = ManagedPolicy("arn:aws:iam::aws:policy/AmazonWorkMailReadOnlyAccess")
	ManagedPolicyAmazonWorkSpacesAdmin                                 = ManagedPolicy("arn:aws:iam::aws:policy/AmazonWorkSpacesAdmin")
	ManagedPolicyAmazonWorkSpacesApplicationManagerAdminAccess         = ManagedPolicy("arn:aws:iam::aws:policy/AmazonWorkSpacesApplicationManagerAdminAccess")
	ManagedPolicyAmazonZocaloFullAccess                                = ManagedPolicy("arn:aws:iam::aws:policy/AmazonZocaloFullAccess")
	ManagedPolicyAmazonZocaloReadOnlyAccess                            = ManagedPolicy("arn:aws:iam::aws:policy/AmazonZocaloReadOnlyAccess")
	ManagedPolicyApplicationAutoScalingForAmazonAppStreamAccess        = ManagedPolicy("arn:aws:iam::aws:policy/service-role/ApplicationAutoScalingForAmazonAppStreamAccess")
	ManagedPolicyAutoScalingConsoleFullAccess                          = ManagedPolicy("arn:aws:iam::aws:policy/AutoScalingConsoleFullAccess")
	ManagedPolicyAutoScalingConsoleReadOnlyAccess                      = ManagedPolicy("arn:aws:iam::aws:policy/AutoScalingConsoleReadOnlyAccess")
	ManagedPolicyAutoScalingFullAccess                                 = ManagedPolicy("arn:aws:iam::aws:policy/AutoScalingFullAccess")
	ManagedPolicyAutoScalingNotificationAccessRole                     = ManagedPolicy("arn:aws:iam::aws:policy/service-role/AutoScalingNotificationAccessRole")
	ManagedPolicyAutoScalingReadOnlyAccess                             = ManagedPolicy("arn:aws:iam::aws:policy/AutoScalingReadOnlyAccess")
	ManagedPolicyBilling                                               = ManagedPolicy("arn:aws:iam::aws:policy/job-function/Billing")
	ManagedPolicyCloudFrontFullAccess                                  = ManagedPolicy("arn:aws:iam::aws:policy/CloudFrontFullAccess")
	ManagedPolicyCloudFrontReadOnlyAccess                              = ManagedPolicy("arn:aws:iam::aws:policy/CloudFrontReadOnlyAccess")
	ManagedPolicyCloudSearchFullAccess                                 = ManagedPolicy("arn:aws:iam::aws:policy/CloudSearchFullAccess")
	ManagedPolicyCloudSearchReadOnlyAccess                             = ManagedPolicy("arn:aws:iam::aws:policy/CloudSearchReadOnlyAccess")
	ManagedPolicyCloudWatchActionsEC2Access                            = ManagedPolicy("arn:aws:iam::aws:policy/CloudWatchActionsEC2Access")
	ManagedPolicyCloudWatchEventsBuiltInTargetExecutionAccess          = ManagedPolicy("arn:aws:iam::aws:policy/service-role/CloudWatchEventsBuiltInTargetExecutionAccess")
	ManagedPolicyCloudWatchEventsFullAccess                            = ManagedPolicy("arn:aws:iam::aws:policy/CloudWatchEventsFullAccess")
	ManagedPolicyCloudWatchEventsInvocationAccess                      = ManagedPolicy("arn:aws:iam::aws:policy/service-role/CloudWatchEventsInvocationAccess")
	ManagedPolicyCloudWatchEventsReadOnlyAccess                        = ManagedPolicy("arn:aws:iam::aws:policy/CloudWatchEventsReadOnlyAccess")
	ManagedPolicyCloudWatchFullAccess                                  = ManagedPolicy("arn:aws:iam::aws:policy/CloudWatchFullAccess")
	ManagedPolicyCloudWatchLogsFullAccess                              = ManagedPolicy("arn:aws:iam::aws:policy/CloudWatchLogsFullAccess")
	ManagedPolicyCloudWatchLogsReadOnlyAccess                          = ManagedPolicy("arn:aws:iam::aws:policy/CloudWatchLogsReadOnlyAccess")
	ManagedPolicyCloudWatchReadOnlyAccess                              = ManagedPolicy("arn:aws:iam::aws:policy/CloudWatchReadOnlyAccess")
	ManagedPolicyDataScientist                                         = ManagedPolicy("arn:aws:iam::aws:policy/job-function/DataScientist")
	ManagedPolicyDatabaseAdministrator                                 = ManagedPolicy("arn:aws:iam::aws:policy/job-function/DatabaseAdministrator")
	ManagedPolicyIAMFullAccess                                         = ManagedPolicy("arn:aws:iam::aws:policy/IAMFullAccess")
	ManagedPolicyIAMReadOnlyAccess                                     = ManagedPolicy("arn:aws:iam::aws:policy/IAMReadOnlyAccess")
	ManagedPolicyIAMSelfManageServiceSpecificCredentials               = ManagedPolicy("arn:aws:iam::aws:policy/IAMSelfManageServiceSpecificCredentials")
	ManagedPolicyIAMUserChangePassword                                 = ManagedPolicy("arn:aws:iam::aws:policy/IAMUserChangePassword")
	ManagedPolicyIAMUserSSHKeys                                        = ManagedPolicy("arn:aws:iam::aws:policy/IAMUserSSHKeys")
	ManagedPolicyNetworkAdministrator                                  = ManagedPolicy("arn:aws:iam::aws:policy/job-function/NetworkAdministrator")
	ManagedPolicyPowerUserAccess                                       = ManagedPolicy("arn:aws:iam::aws:policy/PowerUserAccess")
	ManagedPolicyRDSCloudHsmAuthorizationRole                          = ManagedPolicy("arn:aws:iam::aws:policy/service-role/RDSCloudHsmAuthorizationRole")
	ManagedPolicyReadOnlyAccess                                        = ManagedPolicy("arn:aws:iam::aws:policy/ReadOnlyAccess")
	ManagedPolicyResourceGroupsandTagEditorFullAccess                  = ManagedPolicy("arn:aws:iam::aws:policy/ResourceGroupsandTagEditorFullAccess")
	ManagedPolicyResourceGroupsandTagEditorReadOnlyAccess              = ManagedPolicy("arn:aws:iam::aws:policy/ResourceGroupsandTagEditorReadOnlyAccess")
	ManagedPolicySecurityAudit                                         = ManagedPolicy("arn:aws:iam::aws:policy/SecurityAudit")
	ManagedPolicyServerMigrationConnector                              = ManagedPolicy("arn:aws:iam::aws:policy/ServerMigrationConnector")
	ManagedPolicyServerMigrationServiceRole                            = ManagedPolicy("arn:aws:iam::aws:policy/service-role/ServerMigrationServiceRole")
	ManagedPolicyServiceCatalogAdminFullAccess                         = ManagedPolicy("arn:aws:iam::aws:policy/ServiceCatalogAdminFullAccess")
	ManagedPolicyServiceCatalogAdminReadOnlyAccess                     = ManagedPolicy("arn:aws:iam::aws:policy/ServiceCatalogAdminReadOnlyAccess")
	ManagedPolicyServiceCatalogEndUserAccess                           = ManagedPolicy("arn:aws:iam::aws:policy/ServiceCatalogEndUserAccess")
	ManagedPolicyServiceCatalogEndUserFullAccess                       = ManagedPolicy("arn:aws:iam::aws:policy/ServiceCatalogEndUserFullAccess")
	ManagedPolicySimpleWorkflowFullAccess                              = ManagedPolicy("arn:aws:iam::aws:policy/SimpleWorkflowFullAccess")
	ManagedPolicySupportUser                                           = ManagedPolicy("arn:aws:iam::aws:policy/job-function/SupportUser")
	ManagedPolicySystemAdministrator                                   = ManagedPolicy("arn:aws:iam::aws:policy/job-function/SystemAdministrator")
	ManagedPolicyVMImportExportRoleForAWSConnector                     = ManagedPolicy("arn:aws:iam::aws:policy/service-role/VMImportExportRoleForAWSConnector")
	ManagedPolicyViewOnlyAccess                                        = ManagedPolicy("arn:aws:iam::aws:policy/job-function/ViewOnlyAccess")
)

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessKey 

type AccessKey struct {
	pulumi.CustomResourceState

	// Date and time in [RFC3339 format](https://tools.ietf.org/html/rfc3339#section-5.8) that the access key was created.
	CreateDate      pulumi.StringOutput `pulumi:"createDate"`
	EncryptedSecret pulumi.StringOutput `pulumi:"encryptedSecret"`
	// The fingerprint of the PGP key used to encrypt the secret. This attribute is not available for imported resources.
	KeyFingerprint pulumi.StringOutput `pulumi:"keyFingerprint"`
	// Either a base-64 encoded PGP public key, or a
	// keybase username in the form `keybase:some_person_that_exists`, for use
	// in the `encryptedSecret` output attribute.
	PgpKey pulumi.StringPtrOutput `pulumi:"pgpKey"`
	// The secret access key. This attribute is not available for imported resources. Note that this will be written to the state file. If you use this, please protect your backend state file judiciously. Alternatively, you may supply a `pgpKey` instead, which will prevent the secret from being stored in plaintext, at the cost of preventing the use of the secret key in automation.
	Secret pulumi.StringOutput `pulumi:"secret"`
	// The secret access key converted into an SES SMTP password by applying [AWS's documented Sigv4 conversion algorithm](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/smtp-credentials.html#smtp-credentials-convert). This attribute is not available for imported resources. As SigV4 is region specific, valid Provider regions are `ap-south-1`, `ap-southeast-2`, `eu-central-1`, `eu-west-1`, `us-east-1` and `us-west-2`. See current [AWS SES regions](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region).
	SesSmtpPasswordV4 pulumi.StringOutput `pulumi:"sesSmtpPasswordV4"`
	// The access key status to apply. Defaults to `Active`.
	// Valid values are `Active` and `Inactive`.
	Status pulumi.StringOutput `pulumi:"status"`
	// The IAM user to associate with this access key.
	User pulumi.StringOutput `pulumi:"user"`
}

Provides an IAM access key. This is a set of credentials that allow API requests to be made as an IAM user.

## Example Usage

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		lbUser, err := iam.NewUser(ctx, "lbUser", &iam.UserArgs{
			Path: pulumi.String("/system/"),
		})
		if err != nil {
			return err
		}
		lbAccessKey, err := iam.NewAccessKey(ctx, "lbAccessKey", &iam.AccessKeyArgs{
			User:   lbUser.Name,
			PgpKey: pulumi.String("keybase:some_person_that_exists"),
		})
		if err != nil {
			return err
		}
		_, err = iam.NewUserPolicy(ctx, "lbRo", &iam.UserPolicyArgs{
			User:   lbUser.Name,
			Policy: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "  \"Version\": \"2012-10-17\",\n", "  \"Statement\": [\n", "    {\n", "      \"Action\": [\n", "        \"ec2:Describe*\"\n", "      ],\n", "      \"Effect\": \"Allow\",\n", "      \"Resource\": \"*\"\n", "    }\n", "  ]\n", "}\n")),
		})
		if err != nil {
			return err
		}
		ctx.Export("secret", lbAccessKey.EncryptedSecret)
		return nil
	})
}

```

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testUser, err := iam.NewUser(ctx, "testUser", &iam.UserArgs{
			Path: pulumi.String("/test/"),
		})
		if err != nil {
			return err
		}
		testAccessKey, err := iam.NewAccessKey(ctx, "testAccessKey", &iam.AccessKeyArgs{
			User: testUser.Name,
		})
		if err != nil {
			return err
		}
		ctx.Export("awsIamSmtpPasswordV4", testAccessKey.SesSmtpPasswordV4)
		return nil
	})
}

```

## Import

IAM Access Keys can be imported using the identifier, e.g.

```sh 

$ pulumi import aws:iam/accessKey:AccessKey example AKIA1234567890

``` 

Resource attributes such as `encrypted_secret`, `key_fingerprint`, `pgp_key`, `secret`, and `ses_smtp_password_v4` are not available for imported resources as this information cannot be read from the IAM API.

func GetAccessKey 

func GetAccessKey(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AccessKeyState, opts ...pulumi.ResourceOption) (*AccessKey, error)

GetAccessKey gets an existing AccessKey resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewAccessKey 

func NewAccessKey(ctx *pulumi.Context,
	name string, args *AccessKeyArgs, opts ...pulumi.ResourceOption) (*AccessKey, error)

NewAccessKey registers a new resource with the given unique name, arguments, and options.

func (*AccessKey) ElementType added in v3.13.0 

func (*AccessKey) ElementType() reflect.Type

func (*AccessKey) ToAccessKeyOutput added in v3.13.0 

func (i *AccessKey) ToAccessKeyOutput() AccessKeyOutput

func (*AccessKey) ToAccessKeyOutputWithContext added in v3.13.0 

func (i *AccessKey) ToAccessKeyOutputWithContext(ctx context.Context) AccessKeyOutput

func (*AccessKey) ToAccessKeyPtrOutput added in v3.25.0 

func (i *AccessKey) ToAccessKeyPtrOutput() AccessKeyPtrOutput

func (*AccessKey) ToAccessKeyPtrOutputWithContext added in v3.25.0 

func (i *AccessKey) ToAccessKeyPtrOutputWithContext(ctx context.Context) AccessKeyPtrOutput

type AccessKeyArgs 

type AccessKeyArgs struct {
	// Either a base-64 encoded PGP public key, or a
	// keybase username in the form `keybase:some_person_that_exists`, for use
	// in the `encryptedSecret` output attribute.
	PgpKey pulumi.StringPtrInput
	// The access key status to apply. Defaults to `Active`.
	// Valid values are `Active` and `Inactive`.
	Status pulumi.StringPtrInput
	// The IAM user to associate with this access key.
	User pulumi.StringInput
}

The set of arguments for constructing a AccessKey resource.

func (AccessKeyArgs) ElementType 

func (AccessKeyArgs) ElementType() reflect.Type

type AccessKeyArray added in v3.25.0 

type AccessKeyArray []AccessKeyInput

func (AccessKeyArray) ElementType added in v3.25.0 

func (AccessKeyArray) ElementType() reflect.Type

func (AccessKeyArray) ToAccessKeyArrayOutput added in v3.25.0 

func (i AccessKeyArray) ToAccessKeyArrayOutput() AccessKeyArrayOutput

func (AccessKeyArray) ToAccessKeyArrayOutputWithContext added in v3.25.0 

func (i AccessKeyArray) ToAccessKeyArrayOutputWithContext(ctx context.Context) AccessKeyArrayOutput

type AccessKeyArrayInput added in v3.25.0 

type AccessKeyArrayInput interface {
	pulumi.Input

	ToAccessKeyArrayOutput() AccessKeyArrayOutput
	ToAccessKeyArrayOutputWithContext(context.Context) AccessKeyArrayOutput
}

AccessKeyArrayInput is an input type that accepts AccessKeyArray and AccessKeyArrayOutput values. You can construct a concrete instance of `AccessKeyArrayInput` via: 

AccessKeyArray{ AccessKeyArgs{...} }

type AccessKeyArrayOutput added in v3.25.0 

type AccessKeyArrayOutput struct{ *pulumi.OutputState }

func (AccessKeyArrayOutput) ElementType added in v3.25.0 

func (AccessKeyArrayOutput) ElementType() reflect.Type

func (AccessKeyArrayOutput) Index added in v3.25.0 

func (o AccessKeyArrayOutput) Index(i pulumi.IntInput) AccessKeyOutput

func (AccessKeyArrayOutput) ToAccessKeyArrayOutput added in v3.25.0 

func (o AccessKeyArrayOutput) ToAccessKeyArrayOutput() AccessKeyArrayOutput

func (AccessKeyArrayOutput) ToAccessKeyArrayOutputWithContext added in v3.25.0 

func (o AccessKeyArrayOutput) ToAccessKeyArrayOutputWithContext(ctx context.Context) AccessKeyArrayOutput

type AccessKeyInput added in v3.13.0 

type AccessKeyInput interface {
	pulumi.Input

	ToAccessKeyOutput() AccessKeyOutput
	ToAccessKeyOutputWithContext(ctx context.Context) AccessKeyOutput
}

type AccessKeyMap added in v3.25.0 

type AccessKeyMap map[string]AccessKeyInput

func (AccessKeyMap) ElementType added in v3.25.0 

func (AccessKeyMap) ElementType() reflect.Type

func (AccessKeyMap) ToAccessKeyMapOutput added in v3.25.0 

func (i AccessKeyMap) ToAccessKeyMapOutput() AccessKeyMapOutput

func (AccessKeyMap) ToAccessKeyMapOutputWithContext added in v3.25.0 

func (i AccessKeyMap) ToAccessKeyMapOutputWithContext(ctx context.Context) AccessKeyMapOutput

type AccessKeyMapInput added in v3.25.0 

type AccessKeyMapInput interface {
	pulumi.Input

	ToAccessKeyMapOutput() AccessKeyMapOutput
	ToAccessKeyMapOutputWithContext(context.Context) AccessKeyMapOutput
}

AccessKeyMapInput is an input type that accepts AccessKeyMap and AccessKeyMapOutput values. You can construct a concrete instance of `AccessKeyMapInput` via: 

AccessKeyMap{ "key": AccessKeyArgs{...} }

type AccessKeyMapOutput added in v3.25.0 

type AccessKeyMapOutput struct{ *pulumi.OutputState }

func (AccessKeyMapOutput) ElementType added in v3.25.0 

func (AccessKeyMapOutput) ElementType() reflect.Type

func (AccessKeyMapOutput) MapIndex added in v3.25.0 

func (o AccessKeyMapOutput) MapIndex(k pulumi.StringInput) AccessKeyOutput

func (AccessKeyMapOutput) ToAccessKeyMapOutput added in v3.25.0 

func (o AccessKeyMapOutput) ToAccessKeyMapOutput() AccessKeyMapOutput

func (AccessKeyMapOutput) ToAccessKeyMapOutputWithContext added in v3.25.0 

func (o AccessKeyMapOutput) ToAccessKeyMapOutputWithContext(ctx context.Context) AccessKeyMapOutput

type AccessKeyOutput added in v3.13.0 

type AccessKeyOutput struct {
	*pulumi.OutputState
}

func (AccessKeyOutput) ElementType added in v3.13.0 

func (AccessKeyOutput) ElementType() reflect.Type

func (AccessKeyOutput) ToAccessKeyOutput added in v3.13.0 

func (o AccessKeyOutput) ToAccessKeyOutput() AccessKeyOutput

func (AccessKeyOutput) ToAccessKeyOutputWithContext added in v3.13.0 

func (o AccessKeyOutput) ToAccessKeyOutputWithContext(ctx context.Context) AccessKeyOutput

func (AccessKeyOutput) ToAccessKeyPtrOutput added in v3.25.0 

func (o AccessKeyOutput) ToAccessKeyPtrOutput() AccessKeyPtrOutput

func (AccessKeyOutput) ToAccessKeyPtrOutputWithContext added in v3.25.0 

func (o AccessKeyOutput) ToAccessKeyPtrOutputWithContext(ctx context.Context) AccessKeyPtrOutput

type AccessKeyPtrInput added in v3.25.0 

type AccessKeyPtrInput interface {
	pulumi.Input

	ToAccessKeyPtrOutput() AccessKeyPtrOutput
	ToAccessKeyPtrOutputWithContext(ctx context.Context) AccessKeyPtrOutput
}

type AccessKeyPtrOutput added in v3.25.0 

type AccessKeyPtrOutput struct {
	*pulumi.OutputState
}

func (AccessKeyPtrOutput) ElementType added in v3.25.0 

func (AccessKeyPtrOutput) ElementType() reflect.Type

func (AccessKeyPtrOutput) ToAccessKeyPtrOutput added in v3.25.0 

func (o AccessKeyPtrOutput) ToAccessKeyPtrOutput() AccessKeyPtrOutput

func (AccessKeyPtrOutput) ToAccessKeyPtrOutputWithContext added in v3.25.0 

func (o AccessKeyPtrOutput) ToAccessKeyPtrOutputWithContext(ctx context.Context) AccessKeyPtrOutput

type AccessKeyState 

type AccessKeyState struct {
	// Date and time in [RFC3339 format](https://tools.ietf.org/html/rfc3339#section-5.8) that the access key was created.
	CreateDate      pulumi.StringPtrInput
	EncryptedSecret pulumi.StringPtrInput
	// The fingerprint of the PGP key used to encrypt the secret. This attribute is not available for imported resources.
	KeyFingerprint pulumi.StringPtrInput
	// Either a base-64 encoded PGP public key, or a
	// keybase username in the form `keybase:some_person_that_exists`, for use
	// in the `encryptedSecret` output attribute.
	PgpKey pulumi.StringPtrInput
	// The secret access key. This attribute is not available for imported resources. Note that this will be written to the state file. If you use this, please protect your backend state file judiciously. Alternatively, you may supply a `pgpKey` instead, which will prevent the secret from being stored in plaintext, at the cost of preventing the use of the secret key in automation.
	Secret pulumi.StringPtrInput
	// The secret access key converted into an SES SMTP password by applying [AWS's documented Sigv4 conversion algorithm](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/smtp-credentials.html#smtp-credentials-convert). This attribute is not available for imported resources. As SigV4 is region specific, valid Provider regions are `ap-south-1`, `ap-southeast-2`, `eu-central-1`, `eu-west-1`, `us-east-1` and `us-west-2`. See current [AWS SES regions](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region).
	SesSmtpPasswordV4 pulumi.StringPtrInput
	// The access key status to apply. Defaults to `Active`.
	// Valid values are `Active` and `Inactive`.
	Status pulumi.StringPtrInput
	// The IAM user to associate with this access key.
	User pulumi.StringPtrInput
}

func (AccessKeyState) ElementType 

func (AccessKeyState) ElementType() reflect.Type

type AccountAlias 

type AccountAlias struct {
	pulumi.CustomResourceState

	// The account alias
	AccountAlias pulumi.StringOutput `pulumi:"accountAlias"`
}

> **Note:** There is only a single account alias per AWS account.

Manages the account alias for the AWS Account.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := iam.NewAccountAlias(ctx, "alias", &iam.AccountAliasArgs{
			AccountAlias: pulumi.String("my-account-alias"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

The current Account Alias can be imported using the `account_alias`, e.g.

```sh 

$ pulumi import aws:iam/accountAlias:AccountAlias alias my-account-alias

```

func GetAccountAlias 

func GetAccountAlias(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AccountAliasState, opts ...pulumi.ResourceOption) (*AccountAlias, error)

GetAccountAlias gets an existing AccountAlias resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewAccountAlias 

func NewAccountAlias(ctx *pulumi.Context,
	name string, args *AccountAliasArgs, opts ...pulumi.ResourceOption) (*AccountAlias, error)

NewAccountAlias registers a new resource with the given unique name, arguments, and options.

func (*AccountAlias) ElementType added in v3.13.0 

func (*AccountAlias) ElementType() reflect.Type

func (*AccountAlias) ToAccountAliasOutput added in v3.13.0 

func (i *AccountAlias) ToAccountAliasOutput() AccountAliasOutput

func (*AccountAlias) ToAccountAliasOutputWithContext added in v3.13.0 

func (i *AccountAlias) ToAccountAliasOutputWithContext(ctx context.Context) AccountAliasOutput

func (*AccountAlias) ToAccountAliasPtrOutput added in v3.25.0 

func (i *AccountAlias) ToAccountAliasPtrOutput() AccountAliasPtrOutput

func (*AccountAlias) ToAccountAliasPtrOutputWithContext added in v3.25.0 

func (i *AccountAlias) ToAccountAliasPtrOutputWithContext(ctx context.Context) AccountAliasPtrOutput

type AccountAliasArgs 

type AccountAliasArgs struct {
	// The account alias
	AccountAlias pulumi.StringInput
}

The set of arguments for constructing a AccountAlias resource.

func (AccountAliasArgs) ElementType 

func (AccountAliasArgs) ElementType() reflect.Type

type AccountAliasArray added in v3.25.0 

type AccountAliasArray []AccountAliasInput

func (AccountAliasArray) ElementType added in v3.25.0 

func (AccountAliasArray) ElementType() reflect.Type

func (AccountAliasArray) ToAccountAliasArrayOutput added in v3.25.0 

func (i AccountAliasArray) ToAccountAliasArrayOutput() AccountAliasArrayOutput

func (AccountAliasArray) ToAccountAliasArrayOutputWithContext added in v3.25.0 

func (i AccountAliasArray) ToAccountAliasArrayOutputWithContext(ctx context.Context) AccountAliasArrayOutput

type AccountAliasArrayInput added in v3.25.0 

type AccountAliasArrayInput interface {
	pulumi.Input

	ToAccountAliasArrayOutput() AccountAliasArrayOutput
	ToAccountAliasArrayOutputWithContext(context.Context) AccountAliasArrayOutput
}

AccountAliasArrayInput is an input type that accepts AccountAliasArray and AccountAliasArrayOutput values. You can construct a concrete instance of `AccountAliasArrayInput` via: 

AccountAliasArray{ AccountAliasArgs{...} }

type AccountAliasArrayOutput added in v3.25.0 

type AccountAliasArrayOutput struct{ *pulumi.OutputState }

func (AccountAliasArrayOutput) ElementType added in v3.25.0 

func (AccountAliasArrayOutput) ElementType() reflect.Type

func (AccountAliasArrayOutput) Index added in v3.25.0 

func (o AccountAliasArrayOutput) Index(i pulumi.IntInput) AccountAliasOutput

func (AccountAliasArrayOutput) ToAccountAliasArrayOutput added in v3.25.0 

func (o AccountAliasArrayOutput) ToAccountAliasArrayOutput() AccountAliasArrayOutput

func (AccountAliasArrayOutput) ToAccountAliasArrayOutputWithContext added in v3.25.0 

func (o AccountAliasArrayOutput) ToAccountAliasArrayOutputWithContext(ctx context.Context) AccountAliasArrayOutput

type AccountAliasInput added in v3.13.0 

type AccountAliasInput interface {
	pulumi.Input

	ToAccountAliasOutput() AccountAliasOutput
	ToAccountAliasOutputWithContext(ctx context.Context) AccountAliasOutput
}

type AccountAliasMap added in v3.25.0 

type AccountAliasMap map[string]AccountAliasInput

func (AccountAliasMap) ElementType added in v3.25.0 

func (AccountAliasMap) ElementType() reflect.Type

func (AccountAliasMap) ToAccountAliasMapOutput added in v3.25.0 

func (i AccountAliasMap) ToAccountAliasMapOutput() AccountAliasMapOutput

func (AccountAliasMap) ToAccountAliasMapOutputWithContext added in v3.25.0 

func (i AccountAliasMap) ToAccountAliasMapOutputWithContext(ctx context.Context) AccountAliasMapOutput

type AccountAliasMapInput added in v3.25.0 

type AccountAliasMapInput interface {
	pulumi.Input

	ToAccountAliasMapOutput() AccountAliasMapOutput
	ToAccountAliasMapOutputWithContext(context.Context) AccountAliasMapOutput
}

AccountAliasMapInput is an input type that accepts AccountAliasMap and AccountAliasMapOutput values. You can construct a concrete instance of `AccountAliasMapInput` via: 

AccountAliasMap{ "key": AccountAliasArgs{...} }

type AccountAliasMapOutput added in v3.25.0 

type AccountAliasMapOutput struct{ *pulumi.OutputState }

func (AccountAliasMapOutput) ElementType added in v3.25.0 

func (AccountAliasMapOutput) ElementType() reflect.Type

func (AccountAliasMapOutput) MapIndex added in v3.25.0 

func (o AccountAliasMapOutput) MapIndex(k pulumi.StringInput) AccountAliasOutput

func (AccountAliasMapOutput) ToAccountAliasMapOutput added in v3.25.0 

func (o AccountAliasMapOutput) ToAccountAliasMapOutput() AccountAliasMapOutput

func (AccountAliasMapOutput) ToAccountAliasMapOutputWithContext added in v3.25.0 

func (o AccountAliasMapOutput) ToAccountAliasMapOutputWithContext(ctx context.Context) AccountAliasMapOutput

type AccountAliasOutput added in v3.13.0 

type AccountAliasOutput struct {
	*pulumi.OutputState
}

func (AccountAliasOutput) ElementType added in v3.13.0 

func (AccountAliasOutput) ElementType() reflect.Type

func (AccountAliasOutput) ToAccountAliasOutput added in v3.13.0 

func (o AccountAliasOutput) ToAccountAliasOutput() AccountAliasOutput

func (AccountAliasOutput) ToAccountAliasOutputWithContext added in v3.13.0 

func (o AccountAliasOutput) ToAccountAliasOutputWithContext(ctx context.Context) AccountAliasOutput

func (AccountAliasOutput) ToAccountAliasPtrOutput added in v3.25.0 

func (o AccountAliasOutput) ToAccountAliasPtrOutput() AccountAliasPtrOutput

func (AccountAliasOutput) ToAccountAliasPtrOutputWithContext added in v3.25.0 

func (o AccountAliasOutput) ToAccountAliasPtrOutputWithContext(ctx context.Context) AccountAliasPtrOutput

type AccountAliasPtrInput added in v3.25.0 

type AccountAliasPtrInput interface {
	pulumi.Input

	ToAccountAliasPtrOutput() AccountAliasPtrOutput
	ToAccountAliasPtrOutputWithContext(ctx context.Context) AccountAliasPtrOutput
}

type AccountAliasPtrOutput added in v3.25.0 

type AccountAliasPtrOutput struct {
	*pulumi.OutputState
}

func (AccountAliasPtrOutput) ElementType added in v3.25.0 

func (AccountAliasPtrOutput) ElementType() reflect.Type

func (AccountAliasPtrOutput) ToAccountAliasPtrOutput added in v3.25.0 

func (o AccountAliasPtrOutput) ToAccountAliasPtrOutput() AccountAliasPtrOutput

func (AccountAliasPtrOutput) ToAccountAliasPtrOutputWithContext added in v3.25.0 

func (o AccountAliasPtrOutput) ToAccountAliasPtrOutputWithContext(ctx context.Context) AccountAliasPtrOutput

type AccountAliasState 

type AccountAliasState struct {
	// The account alias
	AccountAlias pulumi.StringPtrInput
}

func (AccountAliasState) ElementType 

func (AccountAliasState) ElementType() reflect.Type

type AccountPasswordPolicy 

type AccountPasswordPolicy struct {
	pulumi.CustomResourceState

	// Whether to allow users to change their own password
	AllowUsersToChangePassword pulumi.BoolPtrOutput `pulumi:"allowUsersToChangePassword"`
	// Indicates whether passwords in the account expire. Returns `true` if `maxPasswordAge` contains a value greater than `0`. Returns `false` if it is `0` or _not present_.
	ExpirePasswords pulumi.BoolOutput `pulumi:"expirePasswords"`
	// Whether users are prevented from setting a new password after their password has expired (i.e. require administrator reset)
	HardExpiry pulumi.BoolOutput `pulumi:"hardExpiry"`
	// The number of days that an user password is valid.
	MaxPasswordAge pulumi.IntOutput `pulumi:"maxPasswordAge"`
	// Minimum length to require for user passwords.
	MinimumPasswordLength pulumi.IntPtrOutput `pulumi:"minimumPasswordLength"`
	// The number of previous passwords that users are prevented from reusing.
	PasswordReusePrevention pulumi.IntOutput `pulumi:"passwordReusePrevention"`
	// Whether to require lowercase characters for user passwords.
	RequireLowercaseCharacters pulumi.BoolOutput `pulumi:"requireLowercaseCharacters"`
	// Whether to require numbers for user passwords.
	RequireNumbers pulumi.BoolOutput `pulumi:"requireNumbers"`
	// Whether to require symbols for user passwords.
	RequireSymbols pulumi.BoolOutput `pulumi:"requireSymbols"`
	// Whether to require uppercase characters for user passwords.
	RequireUppercaseCharacters pulumi.BoolOutput `pulumi:"requireUppercaseCharacters"`
}

> **Note:** There is only a single policy allowed per AWS account. An existing policy will be lost when using this resource as an effect of this limitation.

Manages Password Policy for the AWS Account. See more about [Account Password Policy](http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_passwords_account-policy.html) in the official AWS docs.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := iam.NewAccountPasswordPolicy(ctx, "strict", &iam.AccountPasswordPolicyArgs{
			AllowUsersToChangePassword: pulumi.Bool(true),
			MinimumPasswordLength:      pulumi.Int(8),
			RequireLowercaseCharacters: pulumi.Bool(true),
			RequireNumbers:             pulumi.Bool(true),
			RequireSymbols:             pulumi.Bool(true),
			RequireUppercaseCharacters: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IAM Account Password Policy can be imported using the word `iam-account-password-policy`, e.g.

```sh 

$ pulumi import aws:iam/accountPasswordPolicy:AccountPasswordPolicy strict iam-account-password-policy

```

func GetAccountPasswordPolicy 

func GetAccountPasswordPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AccountPasswordPolicyState, opts ...pulumi.ResourceOption) (*AccountPasswordPolicy, error)

GetAccountPasswordPolicy gets an existing AccountPasswordPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewAccountPasswordPolicy 

func NewAccountPasswordPolicy(ctx *pulumi.Context,
	name string, args *AccountPasswordPolicyArgs, opts ...pulumi.ResourceOption) (*AccountPasswordPolicy, error)

NewAccountPasswordPolicy registers a new resource with the given unique name, arguments, and options.

func (*AccountPasswordPolicy) ElementType added in v3.13.0 

func (*AccountPasswordPolicy) ElementType() reflect.Type

func (*AccountPasswordPolicy) ToAccountPasswordPolicyOutput added in v3.13.0 

func (i *AccountPasswordPolicy) ToAccountPasswordPolicyOutput() AccountPasswordPolicyOutput

func (*AccountPasswordPolicy) ToAccountPasswordPolicyOutputWithContext added in v3.13.0 

func (i *AccountPasswordPolicy) ToAccountPasswordPolicyOutputWithContext(ctx context.Context) AccountPasswordPolicyOutput

func (*AccountPasswordPolicy) ToAccountPasswordPolicyPtrOutput added in v3.25.0 

func (i *AccountPasswordPolicy) ToAccountPasswordPolicyPtrOutput() AccountPasswordPolicyPtrOutput

func (*AccountPasswordPolicy) ToAccountPasswordPolicyPtrOutputWithContext added in v3.25.0 

func (i *AccountPasswordPolicy) ToAccountPasswordPolicyPtrOutputWithContext(ctx context.Context) AccountPasswordPolicyPtrOutput

type AccountPasswordPolicyArgs 

type AccountPasswordPolicyArgs struct {
	// Whether to allow users to change their own password
	AllowUsersToChangePassword pulumi.BoolPtrInput
	// Whether users are prevented from setting a new password after their password has expired (i.e. require administrator reset)
	HardExpiry pulumi.BoolPtrInput
	// The number of days that an user password is valid.
	MaxPasswordAge pulumi.IntPtrInput
	// Minimum length to require for user passwords.
	MinimumPasswordLength pulumi.IntPtrInput
	// The number of previous passwords that users are prevented from reusing.
	PasswordReusePrevention pulumi.IntPtrInput
	// Whether to require lowercase characters for user passwords.
	RequireLowercaseCharacters pulumi.BoolPtrInput
	// Whether to require numbers for user passwords.
	RequireNumbers pulumi.BoolPtrInput
	// Whether to require symbols for user passwords.
	RequireSymbols pulumi.BoolPtrInput
	// Whether to require uppercase characters for user passwords.
	RequireUppercaseCharacters pulumi.BoolPtrInput
}

The set of arguments for constructing a AccountPasswordPolicy resource.

func (AccountPasswordPolicyArgs) ElementType 

func (AccountPasswordPolicyArgs) ElementType() reflect.Type

type AccountPasswordPolicyArray added in v3.25.0 

type AccountPasswordPolicyArray []AccountPasswordPolicyInput

func (AccountPasswordPolicyArray) ElementType added in v3.25.0 

func (AccountPasswordPolicyArray) ElementType() reflect.Type

func (AccountPasswordPolicyArray) ToAccountPasswordPolicyArrayOutput added in v3.25.0 

func (i AccountPasswordPolicyArray) ToAccountPasswordPolicyArrayOutput() AccountPasswordPolicyArrayOutput

func (AccountPasswordPolicyArray) ToAccountPasswordPolicyArrayOutputWithContext added in v3.25.0 

func (i AccountPasswordPolicyArray) ToAccountPasswordPolicyArrayOutputWithContext(ctx context.Context) AccountPasswordPolicyArrayOutput

type AccountPasswordPolicyArrayInput added in v3.25.0 

type AccountPasswordPolicyArrayInput interface {
	pulumi.Input

	ToAccountPasswordPolicyArrayOutput() AccountPasswordPolicyArrayOutput
	ToAccountPasswordPolicyArrayOutputWithContext(context.Context) AccountPasswordPolicyArrayOutput
}

AccountPasswordPolicyArrayInput is an input type that accepts AccountPasswordPolicyArray and AccountPasswordPolicyArrayOutput values. You can construct a concrete instance of `AccountPasswordPolicyArrayInput` via: 

AccountPasswordPolicyArray{ AccountPasswordPolicyArgs{...} }

type AccountPasswordPolicyArrayOutput added in v3.25.0 

type AccountPasswordPolicyArrayOutput struct{ *pulumi.OutputState }

func (AccountPasswordPolicyArrayOutput) ElementType added in v3.25.0 

func (AccountPasswordPolicyArrayOutput) ElementType() reflect.Type

func (AccountPasswordPolicyArrayOutput) Index added in v3.25.0 

func (o AccountPasswordPolicyArrayOutput) Index(i pulumi.IntInput) AccountPasswordPolicyOutput

func (AccountPasswordPolicyArrayOutput) ToAccountPasswordPolicyArrayOutput added in v3.25.0 

func (o AccountPasswordPolicyArrayOutput) ToAccountPasswordPolicyArrayOutput() AccountPasswordPolicyArrayOutput

func (AccountPasswordPolicyArrayOutput) ToAccountPasswordPolicyArrayOutputWithContext added in v3.25.0 

func (o AccountPasswordPolicyArrayOutput) ToAccountPasswordPolicyArrayOutputWithContext(ctx context.Context) AccountPasswordPolicyArrayOutput

type AccountPasswordPolicyInput added in v3.13.0 

type AccountPasswordPolicyInput interface {
	pulumi.Input

	ToAccountPasswordPolicyOutput() AccountPasswordPolicyOutput
	ToAccountPasswordPolicyOutputWithContext(ctx context.Context) AccountPasswordPolicyOutput
}

type AccountPasswordPolicyMap added in v3.25.0 

type AccountPasswordPolicyMap map[string]AccountPasswordPolicyInput

func (AccountPasswordPolicyMap) ElementType added in v3.25.0 

func (AccountPasswordPolicyMap) ElementType() reflect.Type

func (AccountPasswordPolicyMap) ToAccountPasswordPolicyMapOutput added in v3.25.0 

func (i AccountPasswordPolicyMap) ToAccountPasswordPolicyMapOutput() AccountPasswordPolicyMapOutput

func (AccountPasswordPolicyMap) ToAccountPasswordPolicyMapOutputWithContext added in v3.25.0 

func (i AccountPasswordPolicyMap) ToAccountPasswordPolicyMapOutputWithContext(ctx context.Context) AccountPasswordPolicyMapOutput

type AccountPasswordPolicyMapInput added in v3.25.0 

type AccountPasswordPolicyMapInput interface {
	pulumi.Input

	ToAccountPasswordPolicyMapOutput() AccountPasswordPolicyMapOutput
	ToAccountPasswordPolicyMapOutputWithContext(context.Context) AccountPasswordPolicyMapOutput
}

AccountPasswordPolicyMapInput is an input type that accepts AccountPasswordPolicyMap and AccountPasswordPolicyMapOutput values. You can construct a concrete instance of `AccountPasswordPolicyMapInput` via: 

AccountPasswordPolicyMap{ "key": AccountPasswordPolicyArgs{...} }

type AccountPasswordPolicyMapOutput added in v3.25.0 

type AccountPasswordPolicyMapOutput struct{ *pulumi.OutputState }

func (AccountPasswordPolicyMapOutput) ElementType added in v3.25.0 

func (AccountPasswordPolicyMapOutput) ElementType() reflect.Type

func (AccountPasswordPolicyMapOutput) MapIndex added in v3.25.0 

func (o AccountPasswordPolicyMapOutput) MapIndex(k pulumi.StringInput) AccountPasswordPolicyOutput

func (AccountPasswordPolicyMapOutput) ToAccountPasswordPolicyMapOutput added in v3.25.0 

func (o AccountPasswordPolicyMapOutput) ToAccountPasswordPolicyMapOutput() AccountPasswordPolicyMapOutput

func (AccountPasswordPolicyMapOutput) ToAccountPasswordPolicyMapOutputWithContext added in v3.25.0 

func (o AccountPasswordPolicyMapOutput) ToAccountPasswordPolicyMapOutputWithContext(ctx context.Context) AccountPasswordPolicyMapOutput

type AccountPasswordPolicyOutput added in v3.13.0 

type AccountPasswordPolicyOutput struct {
	*pulumi.OutputState
}

func (AccountPasswordPolicyOutput) ElementType added in v3.13.0 

func (AccountPasswordPolicyOutput) ElementType() reflect.Type

func (AccountPasswordPolicyOutput) ToAccountPasswordPolicyOutput added in v3.13.0 

func (o AccountPasswordPolicyOutput) ToAccountPasswordPolicyOutput() AccountPasswordPolicyOutput

func (AccountPasswordPolicyOutput) ToAccountPasswordPolicyOutputWithContext added in v3.13.0 

func (o AccountPasswordPolicyOutput) ToAccountPasswordPolicyOutputWithContext(ctx context.Context) AccountPasswordPolicyOutput

func (AccountPasswordPolicyOutput) ToAccountPasswordPolicyPtrOutput added in v3.25.0 

func (o AccountPasswordPolicyOutput) ToAccountPasswordPolicyPtrOutput() AccountPasswordPolicyPtrOutput

func (AccountPasswordPolicyOutput) ToAccountPasswordPolicyPtrOutputWithContext added in v3.25.0 

func (o AccountPasswordPolicyOutput) ToAccountPasswordPolicyPtrOutputWithContext(ctx context.Context) AccountPasswordPolicyPtrOutput

type AccountPasswordPolicyPtrInput added in v3.25.0 

type AccountPasswordPolicyPtrInput interface {
	pulumi.Input

	ToAccountPasswordPolicyPtrOutput() AccountPasswordPolicyPtrOutput
	ToAccountPasswordPolicyPtrOutputWithContext(ctx context.Context) AccountPasswordPolicyPtrOutput
}

type AccountPasswordPolicyPtrOutput added in v3.25.0 

type AccountPasswordPolicyPtrOutput struct {
	*pulumi.OutputState
}

func (AccountPasswordPolicyPtrOutput) ElementType added in v3.25.0 

func (AccountPasswordPolicyPtrOutput) ElementType() reflect.Type

func (AccountPasswordPolicyPtrOutput) ToAccountPasswordPolicyPtrOutput added in v3.25.0 

func (o AccountPasswordPolicyPtrOutput) ToAccountPasswordPolicyPtrOutput() AccountPasswordPolicyPtrOutput

func (AccountPasswordPolicyPtrOutput) ToAccountPasswordPolicyPtrOutputWithContext added in v3.25.0 

func (o AccountPasswordPolicyPtrOutput) ToAccountPasswordPolicyPtrOutputWithContext(ctx context.Context) AccountPasswordPolicyPtrOutput

type AccountPasswordPolicyState 

type AccountPasswordPolicyState struct {
	// Whether to allow users to change their own password
	AllowUsersToChangePassword pulumi.BoolPtrInput
	// Indicates whether passwords in the account expire. Returns `true` if `maxPasswordAge` contains a value greater than `0`. Returns `false` if it is `0` or _not present_.
	ExpirePasswords pulumi.BoolPtrInput
	// Whether users are prevented from setting a new password after their password has expired (i.e. require administrator reset)
	HardExpiry pulumi.BoolPtrInput
	// The number of days that an user password is valid.
	MaxPasswordAge pulumi.IntPtrInput
	// Minimum length to require for user passwords.
	MinimumPasswordLength pulumi.IntPtrInput
	// The number of previous passwords that users are prevented from reusing.
	PasswordReusePrevention pulumi.IntPtrInput
	// Whether to require lowercase characters for user passwords.
	RequireLowercaseCharacters pulumi.BoolPtrInput
	// Whether to require numbers for user passwords.
	RequireNumbers pulumi.BoolPtrInput
	// Whether to require symbols for user passwords.
	RequireSymbols pulumi.BoolPtrInput
	// Whether to require uppercase characters for user passwords.
	RequireUppercaseCharacters pulumi.BoolPtrInput
}

func (AccountPasswordPolicyState) ElementType 

func (AccountPasswordPolicyState) ElementType() reflect.Type

type GetGroupUser 

type GetGroupUser struct {
	// The Amazon Resource Name (ARN) specifying the iam user.
	Arn string `pulumi:"arn"`
	// The path to the iam user.
	Path string `pulumi:"path"`
	// The stable and unique string identifying the iam user.
	UserId string `pulumi:"userId"`
	// The name of the iam user.
	UserName string `pulumi:"userName"`
}

type GetGroupUserArgs 

type GetGroupUserArgs struct {
	// The Amazon Resource Name (ARN) specifying the iam user.
	Arn pulumi.StringInput `pulumi:"arn"`
	// The path to the iam user.
	Path pulumi.StringInput `pulumi:"path"`
	// The stable and unique string identifying the iam user.
	UserId pulumi.StringInput `pulumi:"userId"`
	// The name of the iam user.
	UserName pulumi.StringInput `pulumi:"userName"`
}

func (GetGroupUserArgs) ElementType 

func (GetGroupUserArgs) ElementType() reflect.Type

func (GetGroupUserArgs) ToGetGroupUserOutput 

func (i GetGroupUserArgs) ToGetGroupUserOutput() GetGroupUserOutput

func (GetGroupUserArgs) ToGetGroupUserOutputWithContext 

func (i GetGroupUserArgs) ToGetGroupUserOutputWithContext(ctx context.Context) GetGroupUserOutput

type GetGroupUserArray 

type GetGroupUserArray []GetGroupUserInput

func (GetGroupUserArray) ElementType 

func (GetGroupUserArray) ElementType() reflect.Type

func (GetGroupUserArray) ToGetGroupUserArrayOutput 

func (i GetGroupUserArray) ToGetGroupUserArrayOutput() GetGroupUserArrayOutput

func (GetGroupUserArray) ToGetGroupUserArrayOutputWithContext 

func (i GetGroupUserArray) ToGetGroupUserArrayOutputWithContext(ctx context.Context) GetGroupUserArrayOutput

type GetGroupUserArrayInput 

type GetGroupUserArrayInput interface {
	pulumi.Input

	ToGetGroupUserArrayOutput() GetGroupUserArrayOutput
	ToGetGroupUserArrayOutputWithContext(context.Context) GetGroupUserArrayOutput
}

GetGroupUserArrayInput is an input type that accepts GetGroupUserArray and GetGroupUserArrayOutput values. You can construct a concrete instance of `GetGroupUserArrayInput` via: 

GetGroupUserArray{ GetGroupUserArgs{...} }

type GetGroupUserArrayOutput 

type GetGroupUserArrayOutput struct{ *pulumi.OutputState }

func (GetGroupUserArrayOutput) ElementType 

func (GetGroupUserArrayOutput) ElementType() reflect.Type

func (GetGroupUserArrayOutput) Index 

func (o GetGroupUserArrayOutput) Index(i pulumi.IntInput) GetGroupUserOutput

func (GetGroupUserArrayOutput) ToGetGroupUserArrayOutput 

func (o GetGroupUserArrayOutput) ToGetGroupUserArrayOutput() GetGroupUserArrayOutput

func (GetGroupUserArrayOutput) ToGetGroupUserArrayOutputWithContext 

func (o GetGroupUserArrayOutput) ToGetGroupUserArrayOutputWithContext(ctx context.Context) GetGroupUserArrayOutput

type GetGroupUserInput 

type GetGroupUserInput interface {
	pulumi.Input

	ToGetGroupUserOutput() GetGroupUserOutput
	ToGetGroupUserOutputWithContext(context.Context) GetGroupUserOutput
}

GetGroupUserInput is an input type that accepts GetGroupUserArgs and GetGroupUserOutput values. You can construct a concrete instance of `GetGroupUserInput` via: 

GetGroupUserArgs{...}

type GetGroupUserOutput 

type GetGroupUserOutput struct{ *pulumi.OutputState }

func (GetGroupUserOutput) Arn 

func (o GetGroupUserOutput) Arn() pulumi.StringOutput

The Amazon Resource Name (ARN) specifying the iam user.

func (GetGroupUserOutput) ElementType 

func (GetGroupUserOutput) ElementType() reflect.Type

func (GetGroupUserOutput) Path 

func (o GetGroupUserOutput) Path() pulumi.StringOutput

The path to the iam user.

func (GetGroupUserOutput) ToGetGroupUserOutput 

func (o GetGroupUserOutput) ToGetGroupUserOutput() GetGroupUserOutput

func (GetGroupUserOutput) ToGetGroupUserOutputWithContext 

func (o GetGroupUserOutput) ToGetGroupUserOutputWithContext(ctx context.Context) GetGroupUserOutput

func (GetGroupUserOutput) UserId 

func (o GetGroupUserOutput) UserId() pulumi.StringOutput

The stable and unique string identifying the iam user.

func (GetGroupUserOutput) UserName 

func (o GetGroupUserOutput) UserName() pulumi.StringOutput

The name of the iam user.

type GetPolicyDocumentArgs 

type GetPolicyDocumentArgs struct {
	// IAM policy document whose statements with non-blank `sid`s will override statements with the same `sid` from documents assigned to the `sourceJson`, `sourcePolicyDocuments`, and `overridePolicyDocuments` arguments. Non-overriding statements will be added to the exported document.
	OverrideJson *string `pulumi:"overrideJson"`
	// List of IAM policy documents that are merged together into the exported document. In merging, statements with non-blank `sid`s will override statements with the same `sid` from earlier documents in the list. Statements with non-blank `sid`s will also override statements with the same `sid` from documents provided in the `sourceJson` and `sourcePolicyDocuments` arguments.  Non-overriding statements will be added to the exported document.
	OverridePolicyDocuments []string `pulumi:"overridePolicyDocuments"`
	// ID for the policy document.
	PolicyId *string `pulumi:"policyId"`
	// IAM policy document used as a base for the exported policy document. Statements with the same `sid` from documents assigned to the `overrideJson` and `overridePolicyDocuments` arguments will override source statements.
	SourceJson *string `pulumi:"sourceJson"`
	// List of IAM policy documents that are merged together into the exported document. Statements defined in `sourcePolicyDocuments` or `sourceJson` must have unique `sid`s. Statements with the same `sid` from documents assigned to the `overrideJson` and `overridePolicyDocuments` arguments will override source statements.
	SourcePolicyDocuments []string `pulumi:"sourcePolicyDocuments"`
	// Configuration block for a policy statement. Detailed below.
	Statements []GetPolicyDocumentStatement `pulumi:"statements"`
	// IAM policy document version. Valid values are `2008-10-17` and `2012-10-17`. Defaults to `2012-10-17`. For more information, see the [AWS IAM User Guide](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_version.html).
	Version *string `pulumi:"version"`
}

A collection of arguments for invoking getPolicyDocument.

type GetPolicyDocumentResult 

type GetPolicyDocumentResult struct {
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// Standard JSON policy document rendered based on the arguments above.
	Json                    string                       `pulumi:"json"`
	OverrideJson            *string                      `pulumi:"overrideJson"`
	OverridePolicyDocuments []string                     `pulumi:"overridePolicyDocuments"`
	PolicyId                *string                      `pulumi:"policyId"`
	SourceJson              *string                      `pulumi:"sourceJson"`
	SourcePolicyDocuments   []string                     `pulumi:"sourcePolicyDocuments"`
	Statements              []GetPolicyDocumentStatement `pulumi:"statements"`
	Version                 *string                      `pulumi:"version"`
}

A collection of values returned by getPolicyDocument.

func GetPolicyDocument 

func GetPolicyDocument(ctx *pulumi.Context, args *GetPolicyDocumentArgs, opts ...pulumi.InvokeOption) (*GetPolicyDocumentResult, error)

Generates an IAM policy document in JSON format for use with resources that expect policy documents such as `iam.Policy`.

Using this data source to generate policy documents is *optional*. It is also valid to use literal JSON strings in your configuration or to use the `file` interpolation function to read a raw JSON policy document from a file.

## Example Usage ### Example with Both Source and Override Documents

You can also combine `sourceJson` and `overrideJson` in the same document.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		source, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
			Statements: []iam.GetPolicyDocumentStatement{
				iam.GetPolicyDocumentStatement{
					Sid: "OverridePlaceholder",
					Actions: []string{
						"ec2:DescribeAccountAttributes",
					},
					Resources: []string{
						"*",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		override, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
			Statements: []iam.GetPolicyDocumentStatement{
				iam.GetPolicyDocumentStatement{
					Sid: "OverridePlaceholder",
					Actions: []string{
						"s3:GetObject",
					},
					Resources: []string{
						"*",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		opt0 := source.Json
		opt1 := override.Json
		_, err = iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
			SourceJson:   &opt0,
			OverrideJson: &opt1,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

`data.aws_iam_policy_document.politik.json` will evaluate to:

```go package main

import ( 

"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}

```

type GetPolicyDocumentStatement 

type GetPolicyDocumentStatement struct {
	// List of actions that this statement either allows or denies. For example, `["ec2:RunInstances", "s3:*"]`.
	Actions []string `pulumi:"actions"`
	// Configuration block for a condition. Detailed below.
	Conditions []GetPolicyDocumentStatementCondition `pulumi:"conditions"`
	// Whether this statement allows or denies the given actions. Valid values are `Allow` and `Deny`. Defaults to `Allow`.
	Effect *string `pulumi:"effect"`
	// List of actions that this statement does *not* apply to. Use to apply a policy statement to all actions *except* those listed.
	NotActions []string `pulumi:"notActions"`
	// Like `principals` except these are principals that the statement does *not* apply to.
	NotPrincipals []GetPolicyDocumentStatementNotPrincipal `pulumi:"notPrincipals"`
	// List of resource ARNs that this statement does *not* apply to. Use to apply a policy statement to all resources *except* those listed.
	NotResources []string `pulumi:"notResources"`
	// Configuration block for principals. Detailed below.
	Principals []GetPolicyDocumentStatementPrincipal `pulumi:"principals"`
	// List of resource ARNs that this statement applies to. This is required by AWS if used for an IAM policy.
	Resources []string `pulumi:"resources"`
	// Sid (statement ID) is an identifier for a policy statement.
	Sid *string `pulumi:"sid"`
}

type GetPolicyDocumentStatementArgs 

type GetPolicyDocumentStatementArgs struct {
	// List of actions that this statement either allows or denies. For example, `["ec2:RunInstances", "s3:*"]`.
	Actions pulumi.StringArrayInput `pulumi:"actions"`
	// Configuration block for a condition. Detailed below.
	Conditions GetPolicyDocumentStatementConditionArrayInput `pulumi:"conditions"`
	// Whether this statement allows or denies the given actions. Valid values are `Allow` and `Deny`. Defaults to `Allow`.
	Effect pulumi.StringPtrInput `pulumi:"effect"`
	// List of actions that this statement does *not* apply to. Use to apply a policy statement to all actions *except* those listed.
	NotActions pulumi.StringArrayInput `pulumi:"notActions"`
	// Like `principals` except these are principals that the statement does *not* apply to.
	NotPrincipals GetPolicyDocumentStatementNotPrincipalArrayInput `pulumi:"notPrincipals"`
	// List of resource ARNs that this statement does *not* apply to. Use to apply a policy statement to all resources *except* those listed.
	NotResources pulumi.StringArrayInput `pulumi:"notResources"`
	// Configuration block for principals. Detailed below.
	Principals GetPolicyDocumentStatementPrincipalArrayInput `pulumi:"principals"`
	// List of resource ARNs that this statement applies to. This is required by AWS if used for an IAM policy.
	Resources pulumi.StringArrayInput `pulumi:"resources"`
	// Sid (statement ID) is an identifier for a policy statement.
	Sid pulumi.StringPtrInput `pulumi:"sid"`
}

func (GetPolicyDocumentStatementArgs) ElementType 

func (GetPolicyDocumentStatementArgs) ElementType() reflect.Type

func (GetPolicyDocumentStatementArgs) ToGetPolicyDocumentStatementOutput 

func (i GetPolicyDocumentStatementArgs) ToGetPolicyDocumentStatementOutput() GetPolicyDocumentStatementOutput

func (GetPolicyDocumentStatementArgs) ToGetPolicyDocumentStatementOutputWithContext 

func (i GetPolicyDocumentStatementArgs) ToGetPolicyDocumentStatementOutputWithContext(ctx context.Context) GetPolicyDocumentStatementOutput

type GetPolicyDocumentStatementArray 

type GetPolicyDocumentStatementArray []GetPolicyDocumentStatementInput

func (GetPolicyDocumentStatementArray) ElementType 

func (GetPolicyDocumentStatementArray) ElementType() reflect.Type

func (GetPolicyDocumentStatementArray) ToGetPolicyDocumentStatementArrayOutput 

func (i GetPolicyDocumentStatementArray) ToGetPolicyDocumentStatementArrayOutput() GetPolicyDocumentStatementArrayOutput

func (GetPolicyDocumentStatementArray) ToGetPolicyDocumentStatementArrayOutputWithContext 

func (i GetPolicyDocumentStatementArray) ToGetPolicyDocumentStatementArrayOutputWithContext(ctx context.Context) GetPolicyDocumentStatementArrayOutput

type GetPolicyDocumentStatementArrayInput 

type GetPolicyDocumentStatementArrayInput interface {
	pulumi.Input

	ToGetPolicyDocumentStatementArrayOutput() GetPolicyDocumentStatementArrayOutput
	ToGetPolicyDocumentStatementArrayOutputWithContext(context.Context) GetPolicyDocumentStatementArrayOutput
}

GetPolicyDocumentStatementArrayInput is an input type that accepts GetPolicyDocumentStatementArray and GetPolicyDocumentStatementArrayOutput values. You can construct a concrete instance of `GetPolicyDocumentStatementArrayInput` via: 

GetPolicyDocumentStatementArray{ GetPolicyDocumentStatementArgs{...} }

type GetPolicyDocumentStatementArrayOutput 

type GetPolicyDocumentStatementArrayOutput struct{ *pulumi.OutputState }

func (GetPolicyDocumentStatementArrayOutput) ElementType 

func (GetPolicyDocumentStatementArrayOutput) ElementType() reflect.Type

func (GetPolicyDocumentStatementArrayOutput) Index 

func (o GetPolicyDocumentStatementArrayOutput) Index(i pulumi.IntInput) GetPolicyDocumentStatementOutput

func (GetPolicyDocumentStatementArrayOutput) ToGetPolicyDocumentStatementArrayOutput 

func (o GetPolicyDocumentStatementArrayOutput) ToGetPolicyDocumentStatementArrayOutput() GetPolicyDocumentStatementArrayOutput

func (GetPolicyDocumentStatementArrayOutput) ToGetPolicyDocumentStatementArrayOutputWithContext 

func (o GetPolicyDocumentStatementArrayOutput) ToGetPolicyDocumentStatementArrayOutputWithContext(ctx context.Context) GetPolicyDocumentStatementArrayOutput

type GetPolicyDocumentStatementCondition 

type GetPolicyDocumentStatementCondition struct {
	// Name of the [IAM condition operator](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) to evaluate.
	Test string `pulumi:"test"`
	// Values to evaluate the condition against. If multiple values are provided, the condition matches if at least one of them applies. That is, AWS evaluates multiple values as though using an "OR" boolean operation.
	Values []string `pulumi:"values"`
	// Name of a [Context Variable](http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#AvailableKeys) to apply the condition to. Context variables may either be standard AWS variables starting with `aws:` or service-specific variables prefixed with the service name.
	Variable string `pulumi:"variable"`
}

type GetPolicyDocumentStatementConditionArgs 

type GetPolicyDocumentStatementConditionArgs struct {
	// Name of the [IAM condition operator](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) to evaluate.
	Test pulumi.StringInput `pulumi:"test"`
	// Values to evaluate the condition against. If multiple values are provided, the condition matches if at least one of them applies. That is, AWS evaluates multiple values as though using an "OR" boolean operation.
	Values pulumi.StringArrayInput `pulumi:"values"`
	// Name of a [Context Variable](http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#AvailableKeys) to apply the condition to. Context variables may either be standard AWS variables starting with `aws:` or service-specific variables prefixed with the service name.
	Variable pulumi.StringInput `pulumi:"variable"`
}

func (GetPolicyDocumentStatementConditionArgs) ElementType 

func (GetPolicyDocumentStatementConditionArgs) ElementType() reflect.Type

func (GetPolicyDocumentStatementConditionArgs) ToGetPolicyDocumentStatementConditionOutput 

func (i GetPolicyDocumentStatementConditionArgs) ToGetPolicyDocumentStatementConditionOutput() GetPolicyDocumentStatementConditionOutput

func (GetPolicyDocumentStatementConditionArgs) ToGetPolicyDocumentStatementConditionOutputWithContext 

func (i GetPolicyDocumentStatementConditionArgs) ToGetPolicyDocumentStatementConditionOutputWithContext(ctx context.Context) GetPolicyDocumentStatementConditionOutput

type GetPolicyDocumentStatementConditionArray 

type GetPolicyDocumentStatementConditionArray []GetPolicyDocumentStatementConditionInput

func (GetPolicyDocumentStatementConditionArray) ElementType 

func (GetPolicyDocumentStatementConditionArray) ElementType() reflect.Type

func (GetPolicyDocumentStatementConditionArray) ToGetPolicyDocumentStatementConditionArrayOutput 

func (i GetPolicyDocumentStatementConditionArray) ToGetPolicyDocumentStatementConditionArrayOutput() GetPolicyDocumentStatementConditionArrayOutput

func (GetPolicyDocumentStatementConditionArray) ToGetPolicyDocumentStatementConditionArrayOutputWithContext 

func (i GetPolicyDocumentStatementConditionArray) ToGetPolicyDocumentStatementConditionArrayOutputWithContext(ctx context.Context) GetPolicyDocumentStatementConditionArrayOutput

type GetPolicyDocumentStatementConditionArrayInput 

type GetPolicyDocumentStatementConditionArrayInput interface {
	pulumi.Input

	ToGetPolicyDocumentStatementConditionArrayOutput() GetPolicyDocumentStatementConditionArrayOutput
	ToGetPolicyDocumentStatementConditionArrayOutputWithContext(context.Context) GetPolicyDocumentStatementConditionArrayOutput
}

GetPolicyDocumentStatementConditionArrayInput is an input type that accepts GetPolicyDocumentStatementConditionArray and GetPolicyDocumentStatementConditionArrayOutput values. You can construct a concrete instance of `GetPolicyDocumentStatementConditionArrayInput` via: 

GetPolicyDocumentStatementConditionArray{ GetPolicyDocumentStatementConditionArgs{...} }

type GetPolicyDocumentStatementConditionArrayOutput 

type GetPolicyDocumentStatementConditionArrayOutput struct{ *pulumi.OutputState }

func (GetPolicyDocumentStatementConditionArrayOutput) ElementType 

func (GetPolicyDocumentStatementConditionArrayOutput) ElementType() reflect.Type

func (GetPolicyDocumentStatementConditionArrayOutput) Index 

func (o GetPolicyDocumentStatementConditionArrayOutput) Index(i pulumi.IntInput) GetPolicyDocumentStatementConditionOutput

func (GetPolicyDocumentStatementConditionArrayOutput) ToGetPolicyDocumentStatementConditionArrayOutput 

func (o GetPolicyDocumentStatementConditionArrayOutput) ToGetPolicyDocumentStatementConditionArrayOutput() GetPolicyDocumentStatementConditionArrayOutput

func (GetPolicyDocumentStatementConditionArrayOutput) ToGetPolicyDocumentStatementConditionArrayOutputWithContext 

func (o GetPolicyDocumentStatementConditionArrayOutput) ToGetPolicyDocumentStatementConditionArrayOutputWithContext(ctx context.Context) GetPolicyDocumentStatementConditionArrayOutput

type GetPolicyDocumentStatementConditionInput 

type GetPolicyDocumentStatementConditionInput interface {
	pulumi.Input

	ToGetPolicyDocumentStatementConditionOutput() GetPolicyDocumentStatementConditionOutput
	ToGetPolicyDocumentStatementConditionOutputWithContext(context.Context) GetPolicyDocumentStatementConditionOutput
}

GetPolicyDocumentStatementConditionInput is an input type that accepts GetPolicyDocumentStatementConditionArgs and GetPolicyDocumentStatementConditionOutput values. You can construct a concrete instance of `GetPolicyDocumentStatementConditionInput` via: 

GetPolicyDocumentStatementConditionArgs{...}

type GetPolicyDocumentStatementConditionOutput 

type GetPolicyDocumentStatementConditionOutput struct{ *pulumi.OutputState }

func (GetPolicyDocumentStatementConditionOutput) ElementType 

func (GetPolicyDocumentStatementConditionOutput) ElementType() reflect.Type

func (GetPolicyDocumentStatementConditionOutput) Test 

func (o GetPolicyDocumentStatementConditionOutput) Test() pulumi.StringOutput

Name of the [IAM condition operator](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) to evaluate.

func (GetPolicyDocumentStatementConditionOutput) ToGetPolicyDocumentStatementConditionOutput 

func (o GetPolicyDocumentStatementConditionOutput) ToGetPolicyDocumentStatementConditionOutput() GetPolicyDocumentStatementConditionOutput

func (GetPolicyDocumentStatementConditionOutput) ToGetPolicyDocumentStatementConditionOutputWithContext 

func (o GetPolicyDocumentStatementConditionOutput) ToGetPolicyDocumentStatementConditionOutputWithContext(ctx context.Context) GetPolicyDocumentStatementConditionOutput

func (GetPolicyDocumentStatementConditionOutput) Values 

func (o GetPolicyDocumentStatementConditionOutput) Values() pulumi.StringArrayOutput

Values to evaluate the condition against. If multiple values are provided, the condition matches if at least one of them applies. That is, AWS evaluates multiple values as though using an "OR" boolean operation.

func (GetPolicyDocumentStatementConditionOutput) Variable 

func (o GetPolicyDocumentStatementConditionOutput) Variable() pulumi.StringOutput

Name of a [Context Variable](http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#AvailableKeys) to apply the condition to. Context variables may either be standard AWS variables starting with `aws:` or service-specific variables prefixed with the service name.

type GetPolicyDocumentStatementInput 

type GetPolicyDocumentStatementInput interface {
	pulumi.Input

	ToGetPolicyDocumentStatementOutput() GetPolicyDocumentStatementOutput
	ToGetPolicyDocumentStatementOutputWithContext(context.Context) GetPolicyDocumentStatementOutput
}

GetPolicyDocumentStatementInput is an input type that accepts GetPolicyDocumentStatementArgs and GetPolicyDocumentStatementOutput values. You can construct a concrete instance of `GetPolicyDocumentStatementInput` via: 

GetPolicyDocumentStatementArgs{...}

type GetPolicyDocumentStatementNotPrincipal 

type GetPolicyDocumentStatementNotPrincipal struct {
	// List of identifiers for principals. When `type` is `AWS`, these are IAM principal ARNs, e.g. `arn:aws:iam::12345678901:role/yak-role`.  When `type` is `Service`, these are AWS Service roles, e.g. `lambda.amazonaws.com`. When `type` is `Federated`, these are web identity users or SAML provider ARNs, e.g. `accounts.google.com` or `arn:aws:iam::12345678901:saml-provider/yak-saml-provider`. When `type` is `CanonicalUser`, these are [canonical user IDs](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html#FindingCanonicalId), e.g. `79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be`.
	Identifiers []string `pulumi:"identifiers"`
	// Type of principal. Valid values include `AWS`, `Service`, `Federated`, and `CanonicalUser`.
	Type string `pulumi:"type"`
}

type GetPolicyDocumentStatementNotPrincipalArgs 

type GetPolicyDocumentStatementNotPrincipalArgs struct {
	// List of identifiers for principals. When `type` is `AWS`, these are IAM principal ARNs, e.g. `arn:aws:iam::12345678901:role/yak-role`.  When `type` is `Service`, these are AWS Service roles, e.g. `lambda.amazonaws.com`. When `type` is `Federated`, these are web identity users or SAML provider ARNs, e.g. `accounts.google.com` or `arn:aws:iam::12345678901:saml-provider/yak-saml-provider`. When `type` is `CanonicalUser`, these are [canonical user IDs](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html#FindingCanonicalId), e.g. `79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be`.
	Identifiers pulumi.StringArrayInput `pulumi:"identifiers"`
	// Type of principal. Valid values include `AWS`, `Service`, `Federated`, and `CanonicalUser`.
	Type pulumi.StringInput `pulumi:"type"`
}

func (GetPolicyDocumentStatementNotPrincipalArgs) ElementType 

func (GetPolicyDocumentStatementNotPrincipalArgs) ElementType() reflect.Type

func (GetPolicyDocumentStatementNotPrincipalArgs) ToGetPolicyDocumentStatementNotPrincipalOutput 

func (i GetPolicyDocumentStatementNotPrincipalArgs) ToGetPolicyDocumentStatementNotPrincipalOutput() GetPolicyDocumentStatementNotPrincipalOutput

func (GetPolicyDocumentStatementNotPrincipalArgs) ToGetPolicyDocumentStatementNotPrincipalOutputWithContext 

func (i GetPolicyDocumentStatementNotPrincipalArgs) ToGetPolicyDocumentStatementNotPrincipalOutputWithContext(ctx context.Context) GetPolicyDocumentStatementNotPrincipalOutput

type GetPolicyDocumentStatementNotPrincipalArray 

type GetPolicyDocumentStatementNotPrincipalArray []GetPolicyDocumentStatementNotPrincipalInput

func (GetPolicyDocumentStatementNotPrincipalArray) ElementType 

func (GetPolicyDocumentStatementNotPrincipalArray) ElementType() reflect.Type

func (GetPolicyDocumentStatementNotPrincipalArray) ToGetPolicyDocumentStatementNotPrincipalArrayOutput 

func (i GetPolicyDocumentStatementNotPrincipalArray) ToGetPolicyDocumentStatementNotPrincipalArrayOutput() GetPolicyDocumentStatementNotPrincipalArrayOutput

func (GetPolicyDocumentStatementNotPrincipalArray) ToGetPolicyDocumentStatementNotPrincipalArrayOutputWithContext 

func (i GetPolicyDocumentStatementNotPrincipalArray) ToGetPolicyDocumentStatementNotPrincipalArrayOutputWithContext(ctx context.Context) GetPolicyDocumentStatementNotPrincipalArrayOutput

type GetPolicyDocumentStatementNotPrincipalArrayInput 

type GetPolicyDocumentStatementNotPrincipalArrayInput interface {
	pulumi.Input

	ToGetPolicyDocumentStatementNotPrincipalArrayOutput() GetPolicyDocumentStatementNotPrincipalArrayOutput
	ToGetPolicyDocumentStatementNotPrincipalArrayOutputWithContext(context.Context) GetPolicyDocumentStatementNotPrincipalArrayOutput
}

GetPolicyDocumentStatementNotPrincipalArrayInput is an input type that accepts GetPolicyDocumentStatementNotPrincipalArray and GetPolicyDocumentStatementNotPrincipalArrayOutput values. You can construct a concrete instance of `GetPolicyDocumentStatementNotPrincipalArrayInput` via: 

GetPolicyDocumentStatementNotPrincipalArray{ GetPolicyDocumentStatementNotPrincipalArgs{...} }

type GetPolicyDocumentStatementNotPrincipalArrayOutput 

type GetPolicyDocumentStatementNotPrincipalArrayOutput struct{ *pulumi.OutputState }

func (GetPolicyDocumentStatementNotPrincipalArrayOutput) ElementType 

func (GetPolicyDocumentStatementNotPrincipalArrayOutput) ElementType() reflect.Type

func (GetPolicyDocumentStatementNotPrincipalArrayOutput) Index 

func (o GetPolicyDocumentStatementNotPrincipalArrayOutput) Index(i pulumi.IntInput) GetPolicyDocumentStatementNotPrincipalOutput

func (GetPolicyDocumentStatementNotPrincipalArrayOutput) ToGetPolicyDocumentStatementNotPrincipalArrayOutput 

func (o GetPolicyDocumentStatementNotPrincipalArrayOutput) ToGetPolicyDocumentStatementNotPrincipalArrayOutput() GetPolicyDocumentStatementNotPrincipalArrayOutput

func (GetPolicyDocumentStatementNotPrincipalArrayOutput) ToGetPolicyDocumentStatementNotPrincipalArrayOutputWithContext 

func (o GetPolicyDocumentStatementNotPrincipalArrayOutput) ToGetPolicyDocumentStatementNotPrincipalArrayOutputWithContext(ctx context.Context) GetPolicyDocumentStatementNotPrincipalArrayOutput

type GetPolicyDocumentStatementNotPrincipalInput 

type GetPolicyDocumentStatementNotPrincipalInput interface {
	pulumi.Input

	ToGetPolicyDocumentStatementNotPrincipalOutput() GetPolicyDocumentStatementNotPrincipalOutput
	ToGetPolicyDocumentStatementNotPrincipalOutputWithContext(context.Context) GetPolicyDocumentStatementNotPrincipalOutput
}

GetPolicyDocumentStatementNotPrincipalInput is an input type that accepts GetPolicyDocumentStatementNotPrincipalArgs and GetPolicyDocumentStatementNotPrincipalOutput values. You can construct a concrete instance of `GetPolicyDocumentStatementNotPrincipalInput` via: 

GetPolicyDocumentStatementNotPrincipalArgs{...}

type GetPolicyDocumentStatementNotPrincipalOutput 

type GetPolicyDocumentStatementNotPrincipalOutput struct{ *pulumi.OutputState }

func (GetPolicyDocumentStatementNotPrincipalOutput) ElementType 

func (GetPolicyDocumentStatementNotPrincipalOutput) ElementType() reflect.Type

func (GetPolicyDocumentStatementNotPrincipalOutput) Identifiers 

func (o GetPolicyDocumentStatementNotPrincipalOutput) Identifiers() pulumi.StringArrayOutput

List of identifiers for principals. When `type` is `AWS`, these are IAM principal ARNs, e.g. `arn:aws:iam::12345678901:role/yak-role`. When `type` is `Service`, these are AWS Service roles, e.g. `lambda.amazonaws.com`. When `type` is `Federated`, these are web identity users or SAML provider ARNs, e.g. `accounts.google.com` or `arn:aws:iam::12345678901:saml-provider/yak-saml-provider`. When `type` is `CanonicalUser`, these are [canonical user IDs](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html#FindingCanonicalId), e.g. `79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be`.

func (GetPolicyDocumentStatementNotPrincipalOutput) ToGetPolicyDocumentStatementNotPrincipalOutput 

func (o GetPolicyDocumentStatementNotPrincipalOutput) ToGetPolicyDocumentStatementNotPrincipalOutput() GetPolicyDocumentStatementNotPrincipalOutput

func (GetPolicyDocumentStatementNotPrincipalOutput) ToGetPolicyDocumentStatementNotPrincipalOutputWithContext 

func (o GetPolicyDocumentStatementNotPrincipalOutput) ToGetPolicyDocumentStatementNotPrincipalOutputWithContext(ctx context.Context) GetPolicyDocumentStatementNotPrincipalOutput

func (GetPolicyDocumentStatementNotPrincipalOutput) Type 

func (o GetPolicyDocumentStatementNotPrincipalOutput) Type() pulumi.StringOutput

Type of principal. Valid values include `AWS`, `Service`, `Federated`, and `CanonicalUser`.

type GetPolicyDocumentStatementOutput 

type GetPolicyDocumentStatementOutput struct{ *pulumi.OutputState }

func (GetPolicyDocumentStatementOutput) Actions 

func (o GetPolicyDocumentStatementOutput) Actions() pulumi.StringArrayOutput

List of actions that this statement either allows or denies. For example, `["ec2:RunInstances", "s3:*"]`.

func (GetPolicyDocumentStatementOutput) Conditions 

func (o GetPolicyDocumentStatementOutput) Conditions() GetPolicyDocumentStatementConditionArrayOutput

Configuration block for a condition. Detailed below.

func (GetPolicyDocumentStatementOutput) Effect 

func (o GetPolicyDocumentStatementOutput) Effect() pulumi.StringPtrOutput

Whether this statement allows or denies the given actions. Valid values are `Allow` and `Deny`. Defaults to `Allow`.

func (GetPolicyDocumentStatementOutput) ElementType 

func (GetPolicyDocumentStatementOutput) ElementType() reflect.Type

func (GetPolicyDocumentStatementOutput) NotActions 

func (o GetPolicyDocumentStatementOutput) NotActions() pulumi.StringArrayOutput

List of actions that this statement does *not* apply to. Use to apply a policy statement to all actions *except* those listed.

func (GetPolicyDocumentStatementOutput) NotPrincipals 

func (o GetPolicyDocumentStatementOutput) NotPrincipals() GetPolicyDocumentStatementNotPrincipalArrayOutput

Like `principals` except these are principals that the statement does *not* apply to.

func (GetPolicyDocumentStatementOutput) NotResources 

func (o GetPolicyDocumentStatementOutput) NotResources() pulumi.StringArrayOutput

List of resource ARNs that this statement does *not* apply to. Use to apply a policy statement to all resources *except* those listed.

func (GetPolicyDocumentStatementOutput) Principals 

func (o GetPolicyDocumentStatementOutput) Principals() GetPolicyDocumentStatementPrincipalArrayOutput

Configuration block for principals. Detailed below.

func (GetPolicyDocumentStatementOutput) Resources 

func (o GetPolicyDocumentStatementOutput) Resources() pulumi.StringArrayOutput

List of resource ARNs that this statement applies to. This is required by AWS if used for an IAM policy.

func (GetPolicyDocumentStatementOutput) Sid 

func (o GetPolicyDocumentStatementOutput) Sid() pulumi.StringPtrOutput

Sid (statement ID) is an identifier for a policy statement.

func (GetPolicyDocumentStatementOutput) ToGetPolicyDocumentStatementOutput 

func (o GetPolicyDocumentStatementOutput) ToGetPolicyDocumentStatementOutput() GetPolicyDocumentStatementOutput

func (GetPolicyDocumentStatementOutput) ToGetPolicyDocumentStatementOutputWithContext 

func (o GetPolicyDocumentStatementOutput) ToGetPolicyDocumentStatementOutputWithContext(ctx context.Context) GetPolicyDocumentStatementOutput

type GetPolicyDocumentStatementPrincipal 

type GetPolicyDocumentStatementPrincipal struct {
	// List of identifiers for principals. When `type` is `AWS`, these are IAM principal ARNs, e.g. `arn:aws:iam::12345678901:role/yak-role`.  When `type` is `Service`, these are AWS Service roles, e.g. `lambda.amazonaws.com`. When `type` is `Federated`, these are web identity users or SAML provider ARNs, e.g. `accounts.google.com` or `arn:aws:iam::12345678901:saml-provider/yak-saml-provider`. When `type` is `CanonicalUser`, these are [canonical user IDs](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html#FindingCanonicalId), e.g. `79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be`.
	Identifiers []string `pulumi:"identifiers"`
	// Type of principal. Valid values include `AWS`, `Service`, `Federated`, and `CanonicalUser`.
	Type string `pulumi:"type"`
}

type GetPolicyDocumentStatementPrincipalArgs 

type GetPolicyDocumentStatementPrincipalArgs struct {
	// List of identifiers for principals. When `type` is `AWS`, these are IAM principal ARNs, e.g. `arn:aws:iam::12345678901:role/yak-role`.  When `type` is `Service`, these are AWS Service roles, e.g. `lambda.amazonaws.com`. When `type` is `Federated`, these are web identity users or SAML provider ARNs, e.g. `accounts.google.com` or `arn:aws:iam::12345678901:saml-provider/yak-saml-provider`. When `type` is `CanonicalUser`, these are [canonical user IDs](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html#FindingCanonicalId), e.g. `79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be`.
	Identifiers pulumi.StringArrayInput `pulumi:"identifiers"`
	// Type of principal. Valid values include `AWS`, `Service`, `Federated`, and `CanonicalUser`.
	Type pulumi.StringInput `pulumi:"type"`
}

func (GetPolicyDocumentStatementPrincipalArgs) ElementType 

func (GetPolicyDocumentStatementPrincipalArgs) ElementType() reflect.Type

func (GetPolicyDocumentStatementPrincipalArgs) ToGetPolicyDocumentStatementPrincipalOutput 

func (i GetPolicyDocumentStatementPrincipalArgs) ToGetPolicyDocumentStatementPrincipalOutput() GetPolicyDocumentStatementPrincipalOutput

func (GetPolicyDocumentStatementPrincipalArgs) ToGetPolicyDocumentStatementPrincipalOutputWithContext 

func (i GetPolicyDocumentStatementPrincipalArgs) ToGetPolicyDocumentStatementPrincipalOutputWithContext(ctx context.Context) GetPolicyDocumentStatementPrincipalOutput

type GetPolicyDocumentStatementPrincipalArray 

type GetPolicyDocumentStatementPrincipalArray []GetPolicyDocumentStatementPrincipalInput

func (GetPolicyDocumentStatementPrincipalArray) ElementType 

func (GetPolicyDocumentStatementPrincipalArray) ElementType() reflect.Type

func (GetPolicyDocumentStatementPrincipalArray) ToGetPolicyDocumentStatementPrincipalArrayOutput 

func (i GetPolicyDocumentStatementPrincipalArray) ToGetPolicyDocumentStatementPrincipalArrayOutput() GetPolicyDocumentStatementPrincipalArrayOutput

func (GetPolicyDocumentStatementPrincipalArray) ToGetPolicyDocumentStatementPrincipalArrayOutputWithContext 

func (i GetPolicyDocumentStatementPrincipalArray) ToGetPolicyDocumentStatementPrincipalArrayOutputWithContext(ctx context.Context) GetPolicyDocumentStatementPrincipalArrayOutput

type GetPolicyDocumentStatementPrincipalArrayInput 

type GetPolicyDocumentStatementPrincipalArrayInput interface {
	pulumi.Input

	ToGetPolicyDocumentStatementPrincipalArrayOutput() GetPolicyDocumentStatementPrincipalArrayOutput
	ToGetPolicyDocumentStatementPrincipalArrayOutputWithContext(context.Context) GetPolicyDocumentStatementPrincipalArrayOutput
}

GetPolicyDocumentStatementPrincipalArrayInput is an input type that accepts GetPolicyDocumentStatementPrincipalArray and GetPolicyDocumentStatementPrincipalArrayOutput values. You can construct a concrete instance of `GetPolicyDocumentStatementPrincipalArrayInput` via: 

GetPolicyDocumentStatementPrincipalArray{ GetPolicyDocumentStatementPrincipalArgs{...} }

type GetPolicyDocumentStatementPrincipalArrayOutput 

type GetPolicyDocumentStatementPrincipalArrayOutput struct{ *pulumi.OutputState }

func (GetPolicyDocumentStatementPrincipalArrayOutput) ElementType 

func (GetPolicyDocumentStatementPrincipalArrayOutput) ElementType() reflect.Type

func (GetPolicyDocumentStatementPrincipalArrayOutput) Index 

func (o GetPolicyDocumentStatementPrincipalArrayOutput) Index(i pulumi.IntInput) GetPolicyDocumentStatementPrincipalOutput

func (GetPolicyDocumentStatementPrincipalArrayOutput) ToGetPolicyDocumentStatementPrincipalArrayOutput 

func (o GetPolicyDocumentStatementPrincipalArrayOutput) ToGetPolicyDocumentStatementPrincipalArrayOutput() GetPolicyDocumentStatementPrincipalArrayOutput

func (GetPolicyDocumentStatementPrincipalArrayOutput) ToGetPolicyDocumentStatementPrincipalArrayOutputWithContext 

func (o GetPolicyDocumentStatementPrincipalArrayOutput) ToGetPolicyDocumentStatementPrincipalArrayOutputWithContext(ctx context.Context) GetPolicyDocumentStatementPrincipalArrayOutput

type GetPolicyDocumentStatementPrincipalInput 

type GetPolicyDocumentStatementPrincipalInput interface {
	pulumi.Input

	ToGetPolicyDocumentStatementPrincipalOutput() GetPolicyDocumentStatementPrincipalOutput
	ToGetPolicyDocumentStatementPrincipalOutputWithContext(context.Context) GetPolicyDocumentStatementPrincipalOutput
}

GetPolicyDocumentStatementPrincipalInput is an input type that accepts GetPolicyDocumentStatementPrincipalArgs and GetPolicyDocumentStatementPrincipalOutput values. You can construct a concrete instance of `GetPolicyDocumentStatementPrincipalInput` via: 

GetPolicyDocumentStatementPrincipalArgs{...}

type GetPolicyDocumentStatementPrincipalOutput 

type GetPolicyDocumentStatementPrincipalOutput struct{ *pulumi.OutputState }

func (GetPolicyDocumentStatementPrincipalOutput) ElementType 

func (GetPolicyDocumentStatementPrincipalOutput) ElementType() reflect.Type

func (GetPolicyDocumentStatementPrincipalOutput) Identifiers 

func (o GetPolicyDocumentStatementPrincipalOutput) Identifiers() pulumi.StringArrayOutput

List of identifiers for principals. When `type` is `AWS`, these are IAM principal ARNs, e.g. `arn:aws:iam::12345678901:role/yak-role`. When `type` is `Service`, these are AWS Service roles, e.g. `lambda.amazonaws.com`. When `type` is `Federated`, these are web identity users or SAML provider ARNs, e.g. `accounts.google.com` or `arn:aws:iam::12345678901:saml-provider/yak-saml-provider`. When `type` is `CanonicalUser`, these are [canonical user IDs](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html#FindingCanonicalId), e.g. `79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be`.

func (GetPolicyDocumentStatementPrincipalOutput) ToGetPolicyDocumentStatementPrincipalOutput 

func (o GetPolicyDocumentStatementPrincipalOutput) ToGetPolicyDocumentStatementPrincipalOutput() GetPolicyDocumentStatementPrincipalOutput

func (GetPolicyDocumentStatementPrincipalOutput) ToGetPolicyDocumentStatementPrincipalOutputWithContext 

func (o GetPolicyDocumentStatementPrincipalOutput) ToGetPolicyDocumentStatementPrincipalOutputWithContext(ctx context.Context) GetPolicyDocumentStatementPrincipalOutput

func (GetPolicyDocumentStatementPrincipalOutput) Type 

func (o GetPolicyDocumentStatementPrincipalOutput) Type() pulumi.StringOutput

Type of principal. Valid values include `AWS`, `Service`, `Federated`, and `CanonicalUser`.

type Group 

type Group struct {
	pulumi.CustomResourceState

	// The ARN assigned by AWS for this group.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The group's name. The name must consist of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: `=,.@-_.`. Group names are not distinguished by case. For example, you cannot create groups named both "ADMINS" and "admins".
	Name pulumi.StringOutput `pulumi:"name"`
	// Path in which to create the group.
	Path pulumi.StringPtrOutput `pulumi:"path"`
	// The [unique ID][1] assigned by AWS.
	UniqueId pulumi.StringOutput `pulumi:"uniqueId"`
}

Provides an IAM group.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := iam.NewGroup(ctx, "developers", &iam.GroupArgs{
			Path: pulumi.String("/users/"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IAM Groups can be imported using the `name`, e.g.

```sh 

$ pulumi import aws:iam/group:Group developers developers

```

func GetGroup 

func GetGroup(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *GroupState, opts ...pulumi.ResourceOption) (*Group, error)

GetGroup gets an existing Group resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewGroup 

func NewGroup(ctx *pulumi.Context,
	name string, args *GroupArgs, opts ...pulumi.ResourceOption) (*Group, error)

NewGroup registers a new resource with the given unique name, arguments, and options.

func (*Group) ElementType added in v3.13.0 

func (*Group) ElementType() reflect.Type

func (*Group) ToGroupOutput added in v3.13.0 

func (i *Group) ToGroupOutput() GroupOutput

func (*Group) ToGroupOutputWithContext added in v3.13.0 

func (i *Group) ToGroupOutputWithContext(ctx context.Context) GroupOutput

func (*Group) ToGroupPtrOutput added in v3.25.0 

func (i *Group) ToGroupPtrOutput() GroupPtrOutput

func (*Group) ToGroupPtrOutputWithContext added in v3.25.0 

func (i *Group) ToGroupPtrOutputWithContext(ctx context.Context) GroupPtrOutput

type GroupArgs 

type GroupArgs struct {
	// The group's name. The name must consist of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: `=,.@-_.`. Group names are not distinguished by case. For example, you cannot create groups named both "ADMINS" and "admins".
	Name pulumi.StringPtrInput
	// Path in which to create the group.
	Path pulumi.StringPtrInput
}

The set of arguments for constructing a Group resource.

func (GroupArgs) ElementType 

func (GroupArgs) ElementType() reflect.Type

type GroupArray added in v3.25.0 

type GroupArray []GroupInput

func (GroupArray) ElementType added in v3.25.0 

func (GroupArray) ElementType() reflect.Type

func (GroupArray) ToGroupArrayOutput added in v3.25.0 

func (i GroupArray) ToGroupArrayOutput() GroupArrayOutput

func (GroupArray) ToGroupArrayOutputWithContext added in v3.25.0 

func (i GroupArray) ToGroupArrayOutputWithContext(ctx context.Context) GroupArrayOutput

type GroupArrayInput added in v3.25.0 

type GroupArrayInput interface {
	pulumi.Input

	ToGroupArrayOutput() GroupArrayOutput
	ToGroupArrayOutputWithContext(context.Context) GroupArrayOutput
}

GroupArrayInput is an input type that accepts GroupArray and GroupArrayOutput values. You can construct a concrete instance of `GroupArrayInput` via: 

GroupArray{ GroupArgs{...} }

type GroupArrayOutput added in v3.25.0 

type GroupArrayOutput struct{ *pulumi.OutputState }

func (GroupArrayOutput) ElementType added in v3.25.0 

func (GroupArrayOutput) ElementType() reflect.Type

func (GroupArrayOutput) Index added in v3.25.0 

func (o GroupArrayOutput) Index(i pulumi.IntInput) GroupOutput

func (GroupArrayOutput) ToGroupArrayOutput added in v3.25.0 

func (o GroupArrayOutput) ToGroupArrayOutput() GroupArrayOutput

func (GroupArrayOutput) ToGroupArrayOutputWithContext added in v3.25.0 

func (o GroupArrayOutput) ToGroupArrayOutputWithContext(ctx context.Context) GroupArrayOutput

type GroupInput added in v3.13.0 

type GroupInput interface {
	pulumi.Input

	ToGroupOutput() GroupOutput
	ToGroupOutputWithContext(ctx context.Context) GroupOutput
}

type GroupMap added in v3.25.0 

type GroupMap map[string]GroupInput

func (GroupMap) ElementType added in v3.25.0 

func (GroupMap) ElementType() reflect.Type

func (GroupMap) ToGroupMapOutput added in v3.25.0 

func (i GroupMap) ToGroupMapOutput() GroupMapOutput

func (GroupMap) ToGroupMapOutputWithContext added in v3.25.0 

func (i GroupMap) ToGroupMapOutputWithContext(ctx context.Context) GroupMapOutput

type GroupMapInput added in v3.25.0 

type GroupMapInput interface {
	pulumi.Input

	ToGroupMapOutput() GroupMapOutput
	ToGroupMapOutputWithContext(context.Context) GroupMapOutput
}

GroupMapInput is an input type that accepts GroupMap and GroupMapOutput values. You can construct a concrete instance of `GroupMapInput` via: 

GroupMap{ "key": GroupArgs{...} }

type GroupMapOutput added in v3.25.0 

type GroupMapOutput struct{ *pulumi.OutputState }

func (GroupMapOutput) ElementType added in v3.25.0 

func (GroupMapOutput) ElementType() reflect.Type

func (GroupMapOutput) MapIndex added in v3.25.0 

func (o GroupMapOutput) MapIndex(k pulumi.StringInput) GroupOutput

func (GroupMapOutput) ToGroupMapOutput added in v3.25.0 

func (o GroupMapOutput) ToGroupMapOutput() GroupMapOutput

func (GroupMapOutput) ToGroupMapOutputWithContext added in v3.25.0 

func (o GroupMapOutput) ToGroupMapOutputWithContext(ctx context.Context) GroupMapOutput

type GroupMembership 

type GroupMembership struct {
	pulumi.CustomResourceState

	// The IAM Group name to attach the list of `users` to
	Group pulumi.StringOutput `pulumi:"group"`
	// The name to identify the Group Membership
	Name pulumi.StringOutput `pulumi:"name"`
	// A list of IAM User names to associate with the Group
	Users pulumi.StringArrayOutput `pulumi:"users"`
}

> **WARNING:** Multiple iam.GroupMembership resources with the same group name will produce inconsistent behavior!

Provides a top level resource to manage IAM Group membership for IAM Users. For more information on managing IAM Groups or IAM Users, see IAM Groups or IAM Users

> **Note:** `iam.GroupMembership` will conflict with itself if used more than once with the same group. To non-exclusively manage the users in a group, see the `iam.UserGroupMembership` resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		group, err := iam.NewGroup(ctx, "group", nil)
		if err != nil {
			return err
		}
		userOne, err := iam.NewUser(ctx, "userOne", nil)
		if err != nil {
			return err
		}
		userTwo, err := iam.NewUser(ctx, "userTwo", nil)
		if err != nil {
			return err
		}
		_, err = iam.NewGroupMembership(ctx, "team", &iam.GroupMembershipArgs{
			Users: pulumi.StringArray{
				userOne.Name,
				userTwo.Name,
			},
			Group: group.Name,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetGroupMembership 

func GetGroupMembership(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *GroupMembershipState, opts ...pulumi.ResourceOption) (*GroupMembership, error)

GetGroupMembership gets an existing GroupMembership resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewGroupMembership 

func NewGroupMembership(ctx *pulumi.Context,
	name string, args *GroupMembershipArgs, opts ...pulumi.ResourceOption) (*GroupMembership, error)

NewGroupMembership registers a new resource with the given unique name, arguments, and options.

func (*GroupMembership) ElementType added in v3.13.0 

func (*GroupMembership) ElementType() reflect.Type

func (*GroupMembership) ToGroupMembershipOutput added in v3.13.0 

func (i *GroupMembership) ToGroupMembershipOutput() GroupMembershipOutput

func (*GroupMembership) ToGroupMembershipOutputWithContext added in v3.13.0 

func (i *GroupMembership) ToGroupMembershipOutputWithContext(ctx context.Context) GroupMembershipOutput

func (*GroupMembership) ToGroupMembershipPtrOutput added in v3.25.0 

func (i *GroupMembership) ToGroupMembershipPtrOutput() GroupMembershipPtrOutput

func (*GroupMembership) ToGroupMembershipPtrOutputWithContext added in v3.25.0 

func (i *GroupMembership) ToGroupMembershipPtrOutputWithContext(ctx context.Context) GroupMembershipPtrOutput

type GroupMembershipArgs 

type GroupMembershipArgs struct {
	// The IAM Group name to attach the list of `users` to
	Group pulumi.StringInput
	// The name to identify the Group Membership
	Name pulumi.StringPtrInput
	// A list of IAM User names to associate with the Group
	Users pulumi.StringArrayInput
}

The set of arguments for constructing a GroupMembership resource.

func (GroupMembershipArgs) ElementType 

func (GroupMembershipArgs) ElementType() reflect.Type

type GroupMembershipArray added in v3.25.0 

type GroupMembershipArray []GroupMembershipInput

func (GroupMembershipArray) ElementType added in v3.25.0 

func (GroupMembershipArray) ElementType() reflect.Type

func (GroupMembershipArray) ToGroupMembershipArrayOutput added in v3.25.0 

func (i GroupMembershipArray) ToGroupMembershipArrayOutput() GroupMembershipArrayOutput

func (GroupMembershipArray) ToGroupMembershipArrayOutputWithContext added in v3.25.0 

func (i GroupMembershipArray) ToGroupMembershipArrayOutputWithContext(ctx context.Context) GroupMembershipArrayOutput

type GroupMembershipArrayInput added in v3.25.0 

type GroupMembershipArrayInput interface {
	pulumi.Input

	ToGroupMembershipArrayOutput() GroupMembershipArrayOutput
	ToGroupMembershipArrayOutputWithContext(context.Context) GroupMembershipArrayOutput
}

GroupMembershipArrayInput is an input type that accepts GroupMembershipArray and GroupMembershipArrayOutput values. You can construct a concrete instance of `GroupMembershipArrayInput` via: 

GroupMembershipArray{ GroupMembershipArgs{...} }

type GroupMembershipArrayOutput added in v3.25.0 

type GroupMembershipArrayOutput struct{ *pulumi.OutputState }

func (GroupMembershipArrayOutput) ElementType added in v3.25.0 

func (GroupMembershipArrayOutput) ElementType() reflect.Type

func (GroupMembershipArrayOutput) Index added in v3.25.0 

func (o GroupMembershipArrayOutput) Index(i pulumi.IntInput) GroupMembershipOutput

func (GroupMembershipArrayOutput) ToGroupMembershipArrayOutput added in v3.25.0 

func (o GroupMembershipArrayOutput) ToGroupMembershipArrayOutput() GroupMembershipArrayOutput

func (GroupMembershipArrayOutput) ToGroupMembershipArrayOutputWithContext added in v3.25.0 

func (o GroupMembershipArrayOutput) ToGroupMembershipArrayOutputWithContext(ctx context.Context) GroupMembershipArrayOutput

type GroupMembershipInput added in v3.13.0 

type GroupMembershipInput interface {
	pulumi.Input

	ToGroupMembershipOutput() GroupMembershipOutput
	ToGroupMembershipOutputWithContext(ctx context.Context) GroupMembershipOutput
}

type GroupMembershipMap added in v3.25.0 

type GroupMembershipMap map[string]GroupMembershipInput

func (GroupMembershipMap) ElementType added in v3.25.0 

func (GroupMembershipMap) ElementType() reflect.Type

func (GroupMembershipMap) ToGroupMembershipMapOutput added in v3.25.0 

func (i GroupMembershipMap) ToGroupMembershipMapOutput() GroupMembershipMapOutput

func (GroupMembershipMap) ToGroupMembershipMapOutputWithContext added in v3.25.0 

func (i GroupMembershipMap) ToGroupMembershipMapOutputWithContext(ctx context.Context) GroupMembershipMapOutput

type GroupMembershipMapInput added in v3.25.0 

type GroupMembershipMapInput interface {
	pulumi.Input

	ToGroupMembershipMapOutput() GroupMembershipMapOutput
	ToGroupMembershipMapOutputWithContext(context.Context) GroupMembershipMapOutput
}

GroupMembershipMapInput is an input type that accepts GroupMembershipMap and GroupMembershipMapOutput values. You can construct a concrete instance of `GroupMembershipMapInput` via: 

GroupMembershipMap{ "key": GroupMembershipArgs{...} }

type GroupMembershipMapOutput added in v3.25.0 

type GroupMembershipMapOutput struct{ *pulumi.OutputState }

func (GroupMembershipMapOutput) ElementType added in v3.25.0 

func (GroupMembershipMapOutput) ElementType() reflect.Type

func (GroupMembershipMapOutput) MapIndex added in v3.25.0 

func (o GroupMembershipMapOutput) MapIndex(k pulumi.StringInput) GroupMembershipOutput

func (GroupMembershipMapOutput) ToGroupMembershipMapOutput added in v3.25.0 

func (o GroupMembershipMapOutput) ToGroupMembershipMapOutput() GroupMembershipMapOutput

func (GroupMembershipMapOutput) ToGroupMembershipMapOutputWithContext added in v3.25.0 

func (o GroupMembershipMapOutput) ToGroupMembershipMapOutputWithContext(ctx context.Context) GroupMembershipMapOutput

type GroupMembershipOutput added in v3.13.0 

type GroupMembershipOutput struct {
	*pulumi.OutputState
}

func (GroupMembershipOutput) ElementType added in v3.13.0 

func (GroupMembershipOutput) ElementType() reflect.Type

func (GroupMembershipOutput) ToGroupMembershipOutput added in v3.13.0 

func (o GroupMembershipOutput) ToGroupMembershipOutput() GroupMembershipOutput

func (GroupMembershipOutput) ToGroupMembershipOutputWithContext added in v3.13.0 

func (o GroupMembershipOutput) ToGroupMembershipOutputWithContext(ctx context.Context) GroupMembershipOutput

func (GroupMembershipOutput) ToGroupMembershipPtrOutput added in v3.25.0 

func (o GroupMembershipOutput) ToGroupMembershipPtrOutput() GroupMembershipPtrOutput

func (GroupMembershipOutput) ToGroupMembershipPtrOutputWithContext added in v3.25.0 

func (o GroupMembershipOutput) ToGroupMembershipPtrOutputWithContext(ctx context.Context) GroupMembershipPtrOutput

type GroupMembershipPtrInput added in v3.25.0 

type GroupMembershipPtrInput interface {
	pulumi.Input

	ToGroupMembershipPtrOutput() GroupMembershipPtrOutput
	ToGroupMembershipPtrOutputWithContext(ctx context.Context) GroupMembershipPtrOutput
}

type GroupMembershipPtrOutput added in v3.25.0 

type GroupMembershipPtrOutput struct {
	*pulumi.OutputState
}

func (GroupMembershipPtrOutput) ElementType added in v3.25.0 

func (GroupMembershipPtrOutput) ElementType() reflect.Type

func (GroupMembershipPtrOutput) ToGroupMembershipPtrOutput added in v3.25.0 

func (o GroupMembershipPtrOutput) ToGroupMembershipPtrOutput() GroupMembershipPtrOutput

func (GroupMembershipPtrOutput) ToGroupMembershipPtrOutputWithContext added in v3.25.0 

func (o GroupMembershipPtrOutput) ToGroupMembershipPtrOutputWithContext(ctx context.Context) GroupMembershipPtrOutput

type GroupMembershipState 

type GroupMembershipState struct {
	// The IAM Group name to attach the list of `users` to
	Group pulumi.StringPtrInput
	// The name to identify the Group Membership
	Name pulumi.StringPtrInput
	// A list of IAM User names to associate with the Group
	Users pulumi.StringArrayInput
}

func (GroupMembershipState) ElementType 

func (GroupMembershipState) ElementType() reflect.Type

type GroupOutput added in v3.13.0 

type GroupOutput struct {
	*pulumi.OutputState
}

func (GroupOutput) ElementType added in v3.13.0 

func (GroupOutput) ElementType() reflect.Type

func (GroupOutput) ToGroupOutput added in v3.13.0 

func (o GroupOutput) ToGroupOutput() GroupOutput

func (GroupOutput) ToGroupOutputWithContext added in v3.13.0 

func (o GroupOutput) ToGroupOutputWithContext(ctx context.Context) GroupOutput

func (GroupOutput) ToGroupPtrOutput added in v3.25.0 

func (o GroupOutput) ToGroupPtrOutput() GroupPtrOutput

func (GroupOutput) ToGroupPtrOutputWithContext added in v3.25.0 

func (o GroupOutput) ToGroupPtrOutputWithContext(ctx context.Context) GroupPtrOutput

type GroupPolicy 

type GroupPolicy struct {
	pulumi.CustomResourceState

	// The IAM group to attach to the policy.
	Group pulumi.StringOutput `pulumi:"group"`
	// The name of the policy. If omitted, this provider will
	// assign a random, unique name.
	Name pulumi.StringOutput `pulumi:"name"`
	// Creates a unique name beginning with the specified
	// prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrOutput `pulumi:"namePrefix"`
	// The policy document. This is a JSON formatted string.
	Policy pulumi.StringOutput `pulumi:"policy"`
}

Provides an IAM policy attached to a group.

## Example Usage

```go package main

import ( 

"encoding/json"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myDevelopers, err := iam.NewGroup(ctx, "myDevelopers", &iam.GroupArgs{
			Path: pulumi.String("/users/"),
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": []map[string]interface{}{
				map[string]interface{}{
					"Action": []string{
						"ec2:Describe*",
					},
					"Effect":   "Allow",
					"Resource": "*",
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = iam.NewGroupPolicy(ctx, "myDeveloperPolicy", &iam.GroupPolicyArgs{
			Group:  myDevelopers.Name,
			Policy: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IAM Group Policies can be imported using the `group_name:group_policy_name`, e.g.

```sh 

$ pulumi import aws:iam/groupPolicy:GroupPolicy mypolicy group_of_mypolicy_name:mypolicy_name

```

func GetGroupPolicy 

func GetGroupPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *GroupPolicyState, opts ...pulumi.ResourceOption) (*GroupPolicy, error)

GetGroupPolicy gets an existing GroupPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewGroupPolicy 

func NewGroupPolicy(ctx *pulumi.Context,
	name string, args *GroupPolicyArgs, opts ...pulumi.ResourceOption) (*GroupPolicy, error)

NewGroupPolicy registers a new resource with the given unique name, arguments, and options.

func (*GroupPolicy) ElementType added in v3.13.0 

func (*GroupPolicy) ElementType() reflect.Type

func (*GroupPolicy) ToGroupPolicyOutput added in v3.13.0 

func (i *GroupPolicy) ToGroupPolicyOutput() GroupPolicyOutput

func (*GroupPolicy) ToGroupPolicyOutputWithContext added in v3.13.0 

func (i *GroupPolicy) ToGroupPolicyOutputWithContext(ctx context.Context) GroupPolicyOutput

func (*GroupPolicy) ToGroupPolicyPtrOutput added in v3.25.0 

func (i *GroupPolicy) ToGroupPolicyPtrOutput() GroupPolicyPtrOutput

func (*GroupPolicy) ToGroupPolicyPtrOutputWithContext added in v3.25.0 

func (i *GroupPolicy) ToGroupPolicyPtrOutputWithContext(ctx context.Context) GroupPolicyPtrOutput

type GroupPolicyArgs 

type GroupPolicyArgs struct {
	// The IAM group to attach to the policy.
	Group pulumi.StringInput
	// The name of the policy. If omitted, this provider will
	// assign a random, unique name.
	Name pulumi.StringPtrInput
	// Creates a unique name beginning with the specified
	// prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrInput
	// The policy document. This is a JSON formatted string.
	Policy pulumi.Input
}

The set of arguments for constructing a GroupPolicy resource.

func (GroupPolicyArgs) ElementType 

func (GroupPolicyArgs) ElementType() reflect.Type

type GroupPolicyArray added in v3.25.0 

type GroupPolicyArray []GroupPolicyInput

func (GroupPolicyArray) ElementType added in v3.25.0 

func (GroupPolicyArray) ElementType() reflect.Type

func (GroupPolicyArray) ToGroupPolicyArrayOutput added in v3.25.0 

func (i GroupPolicyArray) ToGroupPolicyArrayOutput() GroupPolicyArrayOutput

func (GroupPolicyArray) ToGroupPolicyArrayOutputWithContext added in v3.25.0 

func (i GroupPolicyArray) ToGroupPolicyArrayOutputWithContext(ctx context.Context) GroupPolicyArrayOutput

type GroupPolicyArrayInput added in v3.25.0 

type GroupPolicyArrayInput interface {
	pulumi.Input

	ToGroupPolicyArrayOutput() GroupPolicyArrayOutput
	ToGroupPolicyArrayOutputWithContext(context.Context) GroupPolicyArrayOutput
}

GroupPolicyArrayInput is an input type that accepts GroupPolicyArray and GroupPolicyArrayOutput values. You can construct a concrete instance of `GroupPolicyArrayInput` via: 

GroupPolicyArray{ GroupPolicyArgs{...} }

type GroupPolicyArrayOutput added in v3.25.0 

type GroupPolicyArrayOutput struct{ *pulumi.OutputState }

func (GroupPolicyArrayOutput) ElementType added in v3.25.0 

func (GroupPolicyArrayOutput) ElementType() reflect.Type

func (GroupPolicyArrayOutput) Index added in v3.25.0 

func (o GroupPolicyArrayOutput) Index(i pulumi.IntInput) GroupPolicyOutput

func (GroupPolicyArrayOutput) ToGroupPolicyArrayOutput added in v3.25.0 

func (o GroupPolicyArrayOutput) ToGroupPolicyArrayOutput() GroupPolicyArrayOutput

func (GroupPolicyArrayOutput) ToGroupPolicyArrayOutputWithContext added in v3.25.0 

func (o GroupPolicyArrayOutput) ToGroupPolicyArrayOutputWithContext(ctx context.Context) GroupPolicyArrayOutput

type GroupPolicyAttachment 

type GroupPolicyAttachment struct {
	pulumi.CustomResourceState

	// The group the policy should be applied to
	Group pulumi.StringOutput `pulumi:"group"`
	// The ARN of the policy you want to apply
	PolicyArn pulumi.StringOutput `pulumi:"policyArn"`
}

Attaches a Managed IAM Policy to an IAM group

> **NOTE:** The usage of this resource conflicts with the `iam.PolicyAttachment` resource and will permanently show a difference if both are defined.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		group, err := iam.NewGroup(ctx, "group", nil)
		if err != nil {
			return err
		}
		policy, err := iam.NewPolicy(ctx, "policy", &iam.PolicyArgs{
			Description: pulumi.String("A test policy"),
			Policy:      pulumi.String("{ ... policy JSON ... }"),
		})
		if err != nil {
			return err
		}
		_, err = iam.NewGroupPolicyAttachment(ctx, "test_attach", &iam.GroupPolicyAttachmentArgs{
			Group:     group.Name,
			PolicyArn: policy.Arn,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IAM group policy attachments can be imported using the group name and policy arn separated by `/`.

```sh 

$ pulumi import aws:iam/groupPolicyAttachment:GroupPolicyAttachment test-attach test-group/arn:aws:iam::xxxxxxxxxxxx:policy/test-policy

```

func GetGroupPolicyAttachment 

func GetGroupPolicyAttachment(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *GroupPolicyAttachmentState, opts ...pulumi.ResourceOption) (*GroupPolicyAttachment, error)

GetGroupPolicyAttachment gets an existing GroupPolicyAttachment resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewGroupPolicyAttachment 

func NewGroupPolicyAttachment(ctx *pulumi.Context,
	name string, args *GroupPolicyAttachmentArgs, opts ...pulumi.ResourceOption) (*GroupPolicyAttachment, error)

NewGroupPolicyAttachment registers a new resource with the given unique name, arguments, and options.

func (*GroupPolicyAttachment) ElementType added in v3.13.0 

func (*GroupPolicyAttachment) ElementType() reflect.Type

func (*GroupPolicyAttachment) ToGroupPolicyAttachmentOutput added in v3.13.0 

func (i *GroupPolicyAttachment) ToGroupPolicyAttachmentOutput() GroupPolicyAttachmentOutput

func (*GroupPolicyAttachment) ToGroupPolicyAttachmentOutputWithContext added in v3.13.0 

func (i *GroupPolicyAttachment) ToGroupPolicyAttachmentOutputWithContext(ctx context.Context) GroupPolicyAttachmentOutput

func (*GroupPolicyAttachment) ToGroupPolicyAttachmentPtrOutput added in v3.25.0 

func (i *GroupPolicyAttachment) ToGroupPolicyAttachmentPtrOutput() GroupPolicyAttachmentPtrOutput

func (*GroupPolicyAttachment) ToGroupPolicyAttachmentPtrOutputWithContext added in v3.25.0 

func (i *GroupPolicyAttachment) ToGroupPolicyAttachmentPtrOutputWithContext(ctx context.Context) GroupPolicyAttachmentPtrOutput

type GroupPolicyAttachmentArgs 

type GroupPolicyAttachmentArgs struct {
	// The group the policy should be applied to
	Group pulumi.Input
	// The ARN of the policy you want to apply
	PolicyArn pulumi.StringInput
}

The set of arguments for constructing a GroupPolicyAttachment resource.

func (GroupPolicyAttachmentArgs) ElementType 

func (GroupPolicyAttachmentArgs) ElementType() reflect.Type

type GroupPolicyAttachmentArray added in v3.25.0 

type GroupPolicyAttachmentArray []GroupPolicyAttachmentInput

func (GroupPolicyAttachmentArray) ElementType added in v3.25.0 

func (GroupPolicyAttachmentArray) ElementType() reflect.Type

func (GroupPolicyAttachmentArray) ToGroupPolicyAttachmentArrayOutput added in v3.25.0 

func (i GroupPolicyAttachmentArray) ToGroupPolicyAttachmentArrayOutput() GroupPolicyAttachmentArrayOutput

func (GroupPolicyAttachmentArray) ToGroupPolicyAttachmentArrayOutputWithContext added in v3.25.0 

func (i GroupPolicyAttachmentArray) ToGroupPolicyAttachmentArrayOutputWithContext(ctx context.Context) GroupPolicyAttachmentArrayOutput

type GroupPolicyAttachmentArrayInput added in v3.25.0 

type GroupPolicyAttachmentArrayInput interface {
	pulumi.Input

	ToGroupPolicyAttachmentArrayOutput() GroupPolicyAttachmentArrayOutput
	ToGroupPolicyAttachmentArrayOutputWithContext(context.Context) GroupPolicyAttachmentArrayOutput
}

GroupPolicyAttachmentArrayInput is an input type that accepts GroupPolicyAttachmentArray and GroupPolicyAttachmentArrayOutput values. You can construct a concrete instance of `GroupPolicyAttachmentArrayInput` via: 

GroupPolicyAttachmentArray{ GroupPolicyAttachmentArgs{...} }

type GroupPolicyAttachmentArrayOutput added in v3.25.0 

type GroupPolicyAttachmentArrayOutput struct{ *pulumi.OutputState }

func (GroupPolicyAttachmentArrayOutput) ElementType added in v3.25.0 

func (GroupPolicyAttachmentArrayOutput) ElementType() reflect.Type

func (GroupPolicyAttachmentArrayOutput) Index added in v3.25.0 

func (o GroupPolicyAttachmentArrayOutput) Index(i pulumi.IntInput) GroupPolicyAttachmentOutput

func (GroupPolicyAttachmentArrayOutput) ToGroupPolicyAttachmentArrayOutput added in v3.25.0 

func (o GroupPolicyAttachmentArrayOutput) ToGroupPolicyAttachmentArrayOutput() GroupPolicyAttachmentArrayOutput

func (GroupPolicyAttachmentArrayOutput) ToGroupPolicyAttachmentArrayOutputWithContext added in v3.25.0 

func (o GroupPolicyAttachmentArrayOutput) ToGroupPolicyAttachmentArrayOutputWithContext(ctx context.Context) GroupPolicyAttachmentArrayOutput

type GroupPolicyAttachmentInput added in v3.13.0 

type GroupPolicyAttachmentInput interface {
	pulumi.Input

	ToGroupPolicyAttachmentOutput() GroupPolicyAttachmentOutput
	ToGroupPolicyAttachmentOutputWithContext(ctx context.Context) GroupPolicyAttachmentOutput
}

type GroupPolicyAttachmentMap added in v3.25.0 

type GroupPolicyAttachmentMap map[string]GroupPolicyAttachmentInput

func (GroupPolicyAttachmentMap) ElementType added in v3.25.0 

func (GroupPolicyAttachmentMap) ElementType() reflect.Type

func (GroupPolicyAttachmentMap) ToGroupPolicyAttachmentMapOutput added in v3.25.0 

func (i GroupPolicyAttachmentMap) ToGroupPolicyAttachmentMapOutput() GroupPolicyAttachmentMapOutput

func (GroupPolicyAttachmentMap) ToGroupPolicyAttachmentMapOutputWithContext added in v3.25.0 

func (i GroupPolicyAttachmentMap) ToGroupPolicyAttachmentMapOutputWithContext(ctx context.Context) GroupPolicyAttachmentMapOutput

type GroupPolicyAttachmentMapInput added in v3.25.0 

type GroupPolicyAttachmentMapInput interface {
	pulumi.Input

	ToGroupPolicyAttachmentMapOutput() GroupPolicyAttachmentMapOutput
	ToGroupPolicyAttachmentMapOutputWithContext(context.Context) GroupPolicyAttachmentMapOutput
}

GroupPolicyAttachmentMapInput is an input type that accepts GroupPolicyAttachmentMap and GroupPolicyAttachmentMapOutput values. You can construct a concrete instance of `GroupPolicyAttachmentMapInput` via: 

GroupPolicyAttachmentMap{ "key": GroupPolicyAttachmentArgs{...} }

type GroupPolicyAttachmentMapOutput added in v3.25.0 

type GroupPolicyAttachmentMapOutput struct{ *pulumi.OutputState }

func (GroupPolicyAttachmentMapOutput) ElementType added in v3.25.0 

func (GroupPolicyAttachmentMapOutput) ElementType() reflect.Type

func (GroupPolicyAttachmentMapOutput) MapIndex added in v3.25.0 

func (o GroupPolicyAttachmentMapOutput) MapIndex(k pulumi.StringInput) GroupPolicyAttachmentOutput

func (GroupPolicyAttachmentMapOutput) ToGroupPolicyAttachmentMapOutput added in v3.25.0 

func (o GroupPolicyAttachmentMapOutput) ToGroupPolicyAttachmentMapOutput() GroupPolicyAttachmentMapOutput

func (GroupPolicyAttachmentMapOutput) ToGroupPolicyAttachmentMapOutputWithContext added in v3.25.0 

func (o GroupPolicyAttachmentMapOutput) ToGroupPolicyAttachmentMapOutputWithContext(ctx context.Context) GroupPolicyAttachmentMapOutput

type GroupPolicyAttachmentOutput added in v3.13.0 

type GroupPolicyAttachmentOutput struct {
	*pulumi.OutputState
}

func (GroupPolicyAttachmentOutput) ElementType added in v3.13.0 

func (GroupPolicyAttachmentOutput) ElementType() reflect.Type

func (GroupPolicyAttachmentOutput) ToGroupPolicyAttachmentOutput added in v3.13.0 

func (o GroupPolicyAttachmentOutput) ToGroupPolicyAttachmentOutput() GroupPolicyAttachmentOutput

func (GroupPolicyAttachmentOutput) ToGroupPolicyAttachmentOutputWithContext added in v3.13.0 

func (o GroupPolicyAttachmentOutput) ToGroupPolicyAttachmentOutputWithContext(ctx context.Context) GroupPolicyAttachmentOutput

func (GroupPolicyAttachmentOutput) ToGroupPolicyAttachmentPtrOutput added in v3.25.0 

func (o GroupPolicyAttachmentOutput) ToGroupPolicyAttachmentPtrOutput() GroupPolicyAttachmentPtrOutput

func (GroupPolicyAttachmentOutput) ToGroupPolicyAttachmentPtrOutputWithContext added in v3.25.0 

func (o GroupPolicyAttachmentOutput) ToGroupPolicyAttachmentPtrOutputWithContext(ctx context.Context) GroupPolicyAttachmentPtrOutput

type GroupPolicyAttachmentPtrInput added in v3.25.0 

type GroupPolicyAttachmentPtrInput interface {
	pulumi.Input

	ToGroupPolicyAttachmentPtrOutput() GroupPolicyAttachmentPtrOutput
	ToGroupPolicyAttachmentPtrOutputWithContext(ctx context.Context) GroupPolicyAttachmentPtrOutput
}

type GroupPolicyAttachmentPtrOutput added in v3.25.0 

type GroupPolicyAttachmentPtrOutput struct {
	*pulumi.OutputState
}

func (GroupPolicyAttachmentPtrOutput) ElementType added in v3.25.0 

func (GroupPolicyAttachmentPtrOutput) ElementType() reflect.Type

func (GroupPolicyAttachmentPtrOutput) ToGroupPolicyAttachmentPtrOutput added in v3.25.0 

func (o GroupPolicyAttachmentPtrOutput) ToGroupPolicyAttachmentPtrOutput() GroupPolicyAttachmentPtrOutput

func (GroupPolicyAttachmentPtrOutput) ToGroupPolicyAttachmentPtrOutputWithContext added in v3.25.0 

func (o GroupPolicyAttachmentPtrOutput) ToGroupPolicyAttachmentPtrOutputWithContext(ctx context.Context) GroupPolicyAttachmentPtrOutput

type GroupPolicyAttachmentState 

type GroupPolicyAttachmentState struct {
	// The group the policy should be applied to
	Group pulumi.StringPtrInput
	// The ARN of the policy you want to apply
	PolicyArn pulumi.StringPtrInput
}

func (GroupPolicyAttachmentState) ElementType 

func (GroupPolicyAttachmentState) ElementType() reflect.Type

type GroupPolicyInput added in v3.13.0 

type GroupPolicyInput interface {
	pulumi.Input

	ToGroupPolicyOutput() GroupPolicyOutput
	ToGroupPolicyOutputWithContext(ctx context.Context) GroupPolicyOutput
}

type GroupPolicyMap added in v3.25.0 

type GroupPolicyMap map[string]GroupPolicyInput

func (GroupPolicyMap) ElementType added in v3.25.0 

func (GroupPolicyMap) ElementType() reflect.Type

func (GroupPolicyMap) ToGroupPolicyMapOutput added in v3.25.0 

func (i GroupPolicyMap) ToGroupPolicyMapOutput() GroupPolicyMapOutput

func (GroupPolicyMap) ToGroupPolicyMapOutputWithContext added in v3.25.0 

func (i GroupPolicyMap) ToGroupPolicyMapOutputWithContext(ctx context.Context) GroupPolicyMapOutput

type GroupPolicyMapInput added in v3.25.0 

type GroupPolicyMapInput interface {
	pulumi.Input

	ToGroupPolicyMapOutput() GroupPolicyMapOutput
	ToGroupPolicyMapOutputWithContext(context.Context) GroupPolicyMapOutput
}

GroupPolicyMapInput is an input type that accepts GroupPolicyMap and GroupPolicyMapOutput values. You can construct a concrete instance of `GroupPolicyMapInput` via: 

GroupPolicyMap{ "key": GroupPolicyArgs{...} }

type GroupPolicyMapOutput added in v3.25.0 

type GroupPolicyMapOutput struct{ *pulumi.OutputState }

func (GroupPolicyMapOutput) ElementType added in v3.25.0 

func (GroupPolicyMapOutput) ElementType() reflect.Type

func (GroupPolicyMapOutput) MapIndex added in v3.25.0 

func (o GroupPolicyMapOutput) MapIndex(k pulumi.StringInput) GroupPolicyOutput

func (GroupPolicyMapOutput) ToGroupPolicyMapOutput added in v3.25.0 

func (o GroupPolicyMapOutput) ToGroupPolicyMapOutput() GroupPolicyMapOutput

func (GroupPolicyMapOutput) ToGroupPolicyMapOutputWithContext added in v3.25.0 

func (o GroupPolicyMapOutput) ToGroupPolicyMapOutputWithContext(ctx context.Context) GroupPolicyMapOutput

type GroupPolicyOutput added in v3.13.0 

type GroupPolicyOutput struct {
	*pulumi.OutputState
}

func (GroupPolicyOutput) ElementType added in v3.13.0 

func (GroupPolicyOutput) ElementType() reflect.Type

func (GroupPolicyOutput) ToGroupPolicyOutput added in v3.13.0 

func (o GroupPolicyOutput) ToGroupPolicyOutput() GroupPolicyOutput

func (GroupPolicyOutput) ToGroupPolicyOutputWithContext added in v3.13.0 

func (o GroupPolicyOutput) ToGroupPolicyOutputWithContext(ctx context.Context) GroupPolicyOutput

func (GroupPolicyOutput) ToGroupPolicyPtrOutput added in v3.25.0 

func (o GroupPolicyOutput) ToGroupPolicyPtrOutput() GroupPolicyPtrOutput

func (GroupPolicyOutput) ToGroupPolicyPtrOutputWithContext added in v3.25.0 

func (o GroupPolicyOutput) ToGroupPolicyPtrOutputWithContext(ctx context.Context) GroupPolicyPtrOutput

type GroupPolicyPtrInput added in v3.25.0 

type GroupPolicyPtrInput interface {
	pulumi.Input

	ToGroupPolicyPtrOutput() GroupPolicyPtrOutput
	ToGroupPolicyPtrOutputWithContext(ctx context.Context) GroupPolicyPtrOutput
}

type GroupPolicyPtrOutput added in v3.25.0 

type GroupPolicyPtrOutput struct {
	*pulumi.OutputState
}

func (GroupPolicyPtrOutput) ElementType added in v3.25.0 

func (GroupPolicyPtrOutput) ElementType() reflect.Type

func (GroupPolicyPtrOutput) ToGroupPolicyPtrOutput added in v3.25.0 

func (o GroupPolicyPtrOutput) ToGroupPolicyPtrOutput() GroupPolicyPtrOutput

func (GroupPolicyPtrOutput) ToGroupPolicyPtrOutputWithContext added in v3.25.0 

func (o GroupPolicyPtrOutput) ToGroupPolicyPtrOutputWithContext(ctx context.Context) GroupPolicyPtrOutput

type GroupPolicyState 

type GroupPolicyState struct {
	// The IAM group to attach to the policy.
	Group pulumi.StringPtrInput
	// The name of the policy. If omitted, this provider will
	// assign a random, unique name.
	Name pulumi.StringPtrInput
	// Creates a unique name beginning with the specified
	// prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrInput
	// The policy document. This is a JSON formatted string.
	Policy pulumi.StringPtrInput
}

func (GroupPolicyState) ElementType 

func (GroupPolicyState) ElementType() reflect.Type

type GroupPtrInput added in v3.25.0 

type GroupPtrInput interface {
	pulumi.Input

	ToGroupPtrOutput() GroupPtrOutput
	ToGroupPtrOutputWithContext(ctx context.Context) GroupPtrOutput
}

type GroupPtrOutput added in v3.25.0 

type GroupPtrOutput struct {
	*pulumi.OutputState
}

func (GroupPtrOutput) ElementType added in v3.25.0 

func (GroupPtrOutput) ElementType() reflect.Type

func (GroupPtrOutput) ToGroupPtrOutput added in v3.25.0 

func (o GroupPtrOutput) ToGroupPtrOutput() GroupPtrOutput

func (GroupPtrOutput) ToGroupPtrOutputWithContext added in v3.25.0 

func (o GroupPtrOutput) ToGroupPtrOutputWithContext(ctx context.Context) GroupPtrOutput

type GroupState 

type GroupState struct {
	// The ARN assigned by AWS for this group.
	Arn pulumi.StringPtrInput
	// The group's name. The name must consist of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: `=,.@-_.`. Group names are not distinguished by case. For example, you cannot create groups named both "ADMINS" and "admins".
	Name pulumi.StringPtrInput
	// Path in which to create the group.
	Path pulumi.StringPtrInput
	// The [unique ID][1] assigned by AWS.
	UniqueId pulumi.StringPtrInput
}

func (GroupState) ElementType 

func (GroupState) ElementType() reflect.Type

type InstanceProfile 

type InstanceProfile struct {
	pulumi.CustomResourceState

	// ARN assigned by AWS to the instance profile.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// Creation timestamp of the instance profile.
	CreateDate pulumi.StringOutput `pulumi:"createDate"`
	// Name of the instance profile. If omitted, this provider will assign a random, unique name. Conflicts with `namePrefix`. Can be a string of characters consisting of upper and lowercase alphanumeric characters and these special characters: `_`, `+`, `=`, `,`, `.`, `@`, `-`. Spaces are not allowed.
	Name pulumi.StringOutput `pulumi:"name"`
	// Creates a unique name beginning with the specified prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrOutput `pulumi:"namePrefix"`
	// Path to the instance profile. For more information about paths, see [IAM Identifiers](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html) in the IAM User Guide. Can be a string of characters consisting of either a forward slash (`/`) by itself or a string that must begin and end with forward slashes. Can include any ASCII character from the ! (\u0021) through the DEL character (\u007F), including most punctuation characters, digits, and upper and lowercase letters.
	Path pulumi.StringPtrOutput `pulumi:"path"`
	// Name of the role to add to the profile.
	Role pulumi.StringPtrOutput `pulumi:"role"`
	// Map of resource tags for the IAM Instance Profile.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// [Unique ID][1] assigned by AWS.
	UniqueId pulumi.StringOutput `pulumi:"uniqueId"`
}

Provides an IAM instance profile.

## Example Usage

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		role, err := iam.NewRole(ctx, "role", &iam.RoleArgs{
			Path:             pulumi.String("/"),
			AssumeRolePolicy: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "    \"Version\": \"2012-10-17\",\n", "    \"Statement\": [\n", "        {\n", "            \"Action\": \"sts:AssumeRole\",\n", "            \"Principal\": {\n", "               \"Service\": \"ec2.amazonaws.com\"\n", "            },\n", "            \"Effect\": \"Allow\",\n", "            \"Sid\": \"\"\n", "        }\n", "    ]\n", "}\n")),
		})
		if err != nil {
			return err
		}
		_, err = iam.NewInstanceProfile(ctx, "testProfile", &iam.InstanceProfileArgs{
			Role: role.Name,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Instance Profiles can be imported using the `name`, e.g.

```sh 

$ pulumi import aws:iam/instanceProfile:InstanceProfile test_profile app-instance-profile-1

```

func GetInstanceProfile 

func GetInstanceProfile(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *InstanceProfileState, opts ...pulumi.ResourceOption) (*InstanceProfile, error)

GetInstanceProfile gets an existing InstanceProfile resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewInstanceProfile 

func NewInstanceProfile(ctx *pulumi.Context,
	name string, args *InstanceProfileArgs, opts ...pulumi.ResourceOption) (*InstanceProfile, error)

NewInstanceProfile registers a new resource with the given unique name, arguments, and options.

func (*InstanceProfile) ElementType added in v3.13.0 

func (*InstanceProfile) ElementType() reflect.Type

func (*InstanceProfile) ToInstanceProfileOutput added in v3.13.0 

func (i *InstanceProfile) ToInstanceProfileOutput() InstanceProfileOutput

func (*InstanceProfile) ToInstanceProfileOutputWithContext added in v3.13.0 

func (i *InstanceProfile) ToInstanceProfileOutputWithContext(ctx context.Context) InstanceProfileOutput

func (*InstanceProfile) ToInstanceProfilePtrOutput added in v3.25.0 

func (i *InstanceProfile) ToInstanceProfilePtrOutput() InstanceProfilePtrOutput

func (*InstanceProfile) ToInstanceProfilePtrOutputWithContext added in v3.25.0 

func (i *InstanceProfile) ToInstanceProfilePtrOutputWithContext(ctx context.Context) InstanceProfilePtrOutput

type InstanceProfileArgs 

type InstanceProfileArgs struct {
	// Name of the instance profile. If omitted, this provider will assign a random, unique name. Conflicts with `namePrefix`. Can be a string of characters consisting of upper and lowercase alphanumeric characters and these special characters: `_`, `+`, `=`, `,`, `.`, `@`, `-`. Spaces are not allowed.
	Name pulumi.StringPtrInput
	// Creates a unique name beginning with the specified prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrInput
	// Path to the instance profile. For more information about paths, see [IAM Identifiers](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html) in the IAM User Guide. Can be a string of characters consisting of either a forward slash (`/`) by itself or a string that must begin and end with forward slashes. Can include any ASCII character from the ! (\u0021) through the DEL character (\u007F), including most punctuation characters, digits, and upper and lowercase letters.
	Path pulumi.StringPtrInput
	// Name of the role to add to the profile.
	Role pulumi.Input
	// Map of resource tags for the IAM Instance Profile.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a InstanceProfile resource.

func (InstanceProfileArgs) ElementType 

func (InstanceProfileArgs) ElementType() reflect.Type

type InstanceProfileArray added in v3.25.0 

type InstanceProfileArray []InstanceProfileInput

func (InstanceProfileArray) ElementType added in v3.25.0 

func (InstanceProfileArray) ElementType() reflect.Type

func (InstanceProfileArray) ToInstanceProfileArrayOutput added in v3.25.0 

func (i InstanceProfileArray) ToInstanceProfileArrayOutput() InstanceProfileArrayOutput

func (InstanceProfileArray) ToInstanceProfileArrayOutputWithContext added in v3.25.0 

func (i InstanceProfileArray) ToInstanceProfileArrayOutputWithContext(ctx context.Context) InstanceProfileArrayOutput

type InstanceProfileArrayInput added in v3.25.0 

type InstanceProfileArrayInput interface {
	pulumi.Input

	ToInstanceProfileArrayOutput() InstanceProfileArrayOutput
	ToInstanceProfileArrayOutputWithContext(context.Context) InstanceProfileArrayOutput
}

InstanceProfileArrayInput is an input type that accepts InstanceProfileArray and InstanceProfileArrayOutput values. You can construct a concrete instance of `InstanceProfileArrayInput` via: 

InstanceProfileArray{ InstanceProfileArgs{...} }

type InstanceProfileArrayOutput added in v3.25.0 

type InstanceProfileArrayOutput struct{ *pulumi.OutputState }

func (InstanceProfileArrayOutput) ElementType added in v3.25.0 

func (InstanceProfileArrayOutput) ElementType() reflect.Type

func (InstanceProfileArrayOutput) Index added in v3.25.0 

func (o InstanceProfileArrayOutput) Index(i pulumi.IntInput) InstanceProfileOutput

func (InstanceProfileArrayOutput) ToInstanceProfileArrayOutput added in v3.25.0 

func (o InstanceProfileArrayOutput) ToInstanceProfileArrayOutput() InstanceProfileArrayOutput

func (InstanceProfileArrayOutput) ToInstanceProfileArrayOutputWithContext added in v3.25.0 

func (o InstanceProfileArrayOutput) ToInstanceProfileArrayOutputWithContext(ctx context.Context) InstanceProfileArrayOutput

type InstanceProfileInput added in v3.13.0 

type InstanceProfileInput interface {
	pulumi.Input

	ToInstanceProfileOutput() InstanceProfileOutput
	ToInstanceProfileOutputWithContext(ctx context.Context) InstanceProfileOutput
}

type InstanceProfileMap added in v3.25.0 

type InstanceProfileMap map[string]InstanceProfileInput

func (InstanceProfileMap) ElementType added in v3.25.0 

func (InstanceProfileMap) ElementType() reflect.Type

func (InstanceProfileMap) ToInstanceProfileMapOutput added in v3.25.0 

func (i InstanceProfileMap) ToInstanceProfileMapOutput() InstanceProfileMapOutput

func (InstanceProfileMap) ToInstanceProfileMapOutputWithContext added in v3.25.0 

func (i InstanceProfileMap) ToInstanceProfileMapOutputWithContext(ctx context.Context) InstanceProfileMapOutput

type InstanceProfileMapInput added in v3.25.0 

type InstanceProfileMapInput interface {
	pulumi.Input

	ToInstanceProfileMapOutput() InstanceProfileMapOutput
	ToInstanceProfileMapOutputWithContext(context.Context) InstanceProfileMapOutput
}

InstanceProfileMapInput is an input type that accepts InstanceProfileMap and InstanceProfileMapOutput values. You can construct a concrete instance of `InstanceProfileMapInput` via: 

InstanceProfileMap{ "key": InstanceProfileArgs{...} }

type InstanceProfileMapOutput added in v3.25.0 

type InstanceProfileMapOutput struct{ *pulumi.OutputState }

func (InstanceProfileMapOutput) ElementType added in v3.25.0 

func (InstanceProfileMapOutput) ElementType() reflect.Type

func (InstanceProfileMapOutput) MapIndex added in v3.25.0 

func (o InstanceProfileMapOutput) MapIndex(k pulumi.StringInput) InstanceProfileOutput

func (InstanceProfileMapOutput) ToInstanceProfileMapOutput added in v3.25.0 

func (o InstanceProfileMapOutput) ToInstanceProfileMapOutput() InstanceProfileMapOutput

func (InstanceProfileMapOutput) ToInstanceProfileMapOutputWithContext added in v3.25.0 

func (o InstanceProfileMapOutput) ToInstanceProfileMapOutputWithContext(ctx context.Context) InstanceProfileMapOutput

type InstanceProfileOutput added in v3.13.0 

type InstanceProfileOutput struct {
	*pulumi.OutputState
}

func (InstanceProfileOutput) ElementType added in v3.13.0 

func (InstanceProfileOutput) ElementType() reflect.Type

func (InstanceProfileOutput) ToInstanceProfileOutput added in v3.13.0 

func (o InstanceProfileOutput) ToInstanceProfileOutput() InstanceProfileOutput

func (InstanceProfileOutput) ToInstanceProfileOutputWithContext added in v3.13.0 

func (o InstanceProfileOutput) ToInstanceProfileOutputWithContext(ctx context.Context) InstanceProfileOutput

func (InstanceProfileOutput) ToInstanceProfilePtrOutput added in v3.25.0 

func (o InstanceProfileOutput) ToInstanceProfilePtrOutput() InstanceProfilePtrOutput

func (InstanceProfileOutput) ToInstanceProfilePtrOutputWithContext added in v3.25.0 

func (o InstanceProfileOutput) ToInstanceProfilePtrOutputWithContext(ctx context.Context) InstanceProfilePtrOutput

type InstanceProfilePtrInput added in v3.25.0 

type InstanceProfilePtrInput interface {
	pulumi.Input

	ToInstanceProfilePtrOutput() InstanceProfilePtrOutput
	ToInstanceProfilePtrOutputWithContext(ctx context.Context) InstanceProfilePtrOutput
}

type InstanceProfilePtrOutput added in v3.25.0 

type InstanceProfilePtrOutput struct {
	*pulumi.OutputState
}

func (InstanceProfilePtrOutput) ElementType added in v3.25.0 

func (InstanceProfilePtrOutput) ElementType() reflect.Type

func (InstanceProfilePtrOutput) ToInstanceProfilePtrOutput added in v3.25.0 

func (o InstanceProfilePtrOutput) ToInstanceProfilePtrOutput() InstanceProfilePtrOutput

func (InstanceProfilePtrOutput) ToInstanceProfilePtrOutputWithContext added in v3.25.0 

func (o InstanceProfilePtrOutput) ToInstanceProfilePtrOutputWithContext(ctx context.Context) InstanceProfilePtrOutput

type InstanceProfileState 

type InstanceProfileState struct {
	// ARN assigned by AWS to the instance profile.
	Arn pulumi.StringPtrInput
	// Creation timestamp of the instance profile.
	CreateDate pulumi.StringPtrInput
	// Name of the instance profile. If omitted, this provider will assign a random, unique name. Conflicts with `namePrefix`. Can be a string of characters consisting of upper and lowercase alphanumeric characters and these special characters: `_`, `+`, `=`, `,`, `.`, `@`, `-`. Spaces are not allowed.
	Name pulumi.StringPtrInput
	// Creates a unique name beginning with the specified prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrInput
	// Path to the instance profile. For more information about paths, see [IAM Identifiers](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html) in the IAM User Guide. Can be a string of characters consisting of either a forward slash (`/`) by itself or a string that must begin and end with forward slashes. Can include any ASCII character from the ! (\u0021) through the DEL character (\u007F), including most punctuation characters, digits, and upper and lowercase letters.
	Path pulumi.StringPtrInput
	// Name of the role to add to the profile.
	Role pulumi.StringPtrInput
	// Map of resource tags for the IAM Instance Profile.
	Tags pulumi.StringMapInput
	// [Unique ID][1] assigned by AWS.
	UniqueId pulumi.StringPtrInput
}

func (InstanceProfileState) ElementType 

func (InstanceProfileState) ElementType() reflect.Type

type LookupAccountAliasResult 

type LookupAccountAliasResult struct {
	// The alias associated with the AWS account.
	AccountAlias string `pulumi:"accountAlias"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
}

A collection of values returned by getAccountAlias.

func LookupAccountAlias 

func LookupAccountAlias(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*LookupAccountAliasResult, error)

The IAM Account Alias data source allows access to the account alias for the effective account in which this provider is working.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		current, err := iam.LookupAccountAlias(ctx, nil, nil)
		if err != nil {
			return err
		}
		ctx.Export("accountId", current.AccountAlias)
		return nil
	})
}

```

type LookupGroupArgs 

type LookupGroupArgs struct {
	// The friendly IAM group name to match.
	GroupName string `pulumi:"groupName"`
}

A collection of arguments for invoking getGroup.

type LookupGroupResult 

type LookupGroupResult struct {
	// The Amazon Resource Name (ARN) specifying the iam user.
	Arn string `pulumi:"arn"`
	// The stable and unique string identifying the group.
	GroupId   string `pulumi:"groupId"`
	GroupName string `pulumi:"groupName"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// The path to the iam user.
	Path string `pulumi:"path"`
	// List of objects containing group member information. See supported fields below.
	Users []GetGroupUser `pulumi:"users"`
}

A collection of values returned by getGroup.

func LookupGroup 

func LookupGroup(ctx *pulumi.Context, args *LookupGroupArgs, opts ...pulumi.InvokeOption) (*LookupGroupResult, error)

This data source can be used to fetch information about a specific IAM group. By using this data source, you can reference IAM group properties without having to hard code ARNs as input.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := iam.LookupGroup(ctx, &iam.LookupGroupArgs{
			GroupName: "an_example_group_name",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupInstanceProfileArgs 

type LookupInstanceProfileArgs struct {
	// The friendly IAM instance profile name to match.
	Name string `pulumi:"name"`
}

A collection of arguments for invoking getInstanceProfile.

type LookupInstanceProfileResult 

type LookupInstanceProfileResult struct {
	// The Amazon Resource Name (ARN) specifying the instance profile.
	Arn string `pulumi:"arn"`
	// The string representation of the date the instance profile
	// was created.
	CreateDate string `pulumi:"createDate"`
	// The provider-assigned unique ID for this managed resource.
	Id   string `pulumi:"id"`
	Name string `pulumi:"name"`
	// The path to the instance profile.
	Path string `pulumi:"path"`
	// The role arn associated with this instance profile.
	RoleArn string `pulumi:"roleArn"`
	// The role id associated with this instance profile.
	RoleId string `pulumi:"roleId"`
	// The role name associated with this instance profile.
	RoleName string `pulumi:"roleName"`
}

A collection of values returned by getInstanceProfile.

func LookupInstanceProfile 

func LookupInstanceProfile(ctx *pulumi.Context, args *LookupInstanceProfileArgs, opts ...pulumi.InvokeOption) (*LookupInstanceProfileResult, error)

This data source can be used to fetch information about a specific IAM instance profile. By using this data source, you can reference IAM instance profile properties without having to hard code ARNs as input.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := iam.LookupInstanceProfile(ctx, &iam.LookupInstanceProfileArgs{
			Name: "an_example_instance_profile_name",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupPolicyArgs 

type LookupPolicyArgs struct {
	// ARN of the IAM policy.
	Arn string `pulumi:"arn"`
	// Key-value mapping of tags for the IAM Policy
	Tags map[string]string `pulumi:"tags"`
}

A collection of arguments for invoking getPolicy.

type LookupPolicyResult 

type LookupPolicyResult struct {
	// The Amazon Resource Name (ARN) specifying the policy.
	Arn string `pulumi:"arn"`
	// The description of the policy.
	Description string `pulumi:"description"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// The name of the IAM policy.
	Name string `pulumi:"name"`
	// The path to the policy.
	Path string `pulumi:"path"`
	// The policy document of the policy.
	Policy string `pulumi:"policy"`
	// The policy's ID.
	PolicyId string `pulumi:"policyId"`
	// Key-value mapping of tags for the IAM Policy
	Tags map[string]string `pulumi:"tags"`
}

A collection of values returned by getPolicy.

func LookupPolicy 

func LookupPolicy(ctx *pulumi.Context, args *LookupPolicyArgs, opts ...pulumi.InvokeOption) (*LookupPolicyResult, error)

This data source can be used to fetch information about a specific IAM policy.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := iam.LookupPolicy(ctx, &iam.LookupPolicyArgs{
			Arn: "arn:aws:iam::123456789012:policy/UsersManageOwnCredentials",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupRoleArgs 

type LookupRoleArgs struct {
	// The friendly IAM role name to match.
	Name string `pulumi:"name"`
	// The tags attached to the role.
	Tags map[string]string `pulumi:"tags"`
}

A collection of arguments for invoking getRole.

type LookupRoleResult 

type LookupRoleResult struct {
	// The Amazon Resource Name (ARN) specifying the role.
	Arn string `pulumi:"arn"`
	// The policy document associated with the role.
	AssumeRolePolicy string `pulumi:"assumeRolePolicy"`
	// Creation date of the role in RFC 3339 format.
	CreateDate string `pulumi:"createDate"`
	// Description for the role.
	Description string `pulumi:"description"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// Maximum session duration.
	MaxSessionDuration int    `pulumi:"maxSessionDuration"`
	Name               string `pulumi:"name"`
	// The path to the role.
	Path string `pulumi:"path"`
	// The ARN of the policy that is used to set the permissions boundary for the role.
	PermissionsBoundary string `pulumi:"permissionsBoundary"`
	// The tags attached to the role.
	Tags map[string]string `pulumi:"tags"`
	// The stable and unique string identifying the role.
	UniqueId string `pulumi:"uniqueId"`
}

A collection of values returned by getRole.

func LookupRole 

func LookupRole(ctx *pulumi.Context, args *LookupRoleArgs, opts ...pulumi.InvokeOption) (*LookupRoleResult, error)

This data source can be used to fetch information about a specific IAM role. By using this data source, you can reference IAM role properties without having to hard code ARNs as input.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := iam.LookupRole(ctx, &iam.LookupRoleArgs{
			Name: "an_example_role_name",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupServerCertificateArgs 

type LookupServerCertificateArgs struct {
	// sort results by expiration date. returns the certificate with expiration date in furthest in the future.
	Latest *bool `pulumi:"latest"`
	// exact name of the cert to lookup
	Name *string `pulumi:"name"`
	// prefix of cert to filter by
	NamePrefix *string `pulumi:"namePrefix"`
	// prefix of path to filter by
	PathPrefix *string `pulumi:"pathPrefix"`
}

A collection of arguments for invoking getServerCertificate.

type LookupServerCertificateResult 

type LookupServerCertificateResult struct {
	Arn              string `pulumi:"arn"`
	CertificateBody  string `pulumi:"certificateBody"`
	CertificateChain string `pulumi:"certificateChain"`
	ExpirationDate   string `pulumi:"expirationDate"`
	// The provider-assigned unique ID for this managed resource.
	Id         string  `pulumi:"id"`
	Latest     *bool   `pulumi:"latest"`
	Name       string  `pulumi:"name"`
	NamePrefix *string `pulumi:"namePrefix"`
	Path       string  `pulumi:"path"`
	PathPrefix *string `pulumi:"pathPrefix"`
	UploadDate string  `pulumi:"uploadDate"`
}

A collection of values returned by getServerCertificate.

func LookupServerCertificate 

func LookupServerCertificate(ctx *pulumi.Context, args *LookupServerCertificateArgs, opts ...pulumi.InvokeOption) (*LookupServerCertificateResult, error)

Use this data source to lookup information about IAM Server Certificates.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/elb"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		opt0 := "my-domain.org"
		opt1 := true
		my_domain, err := iam.LookupServerCertificate(ctx, &iam.LookupServerCertificateArgs{
			NamePrefix: &opt0,
			Latest:     &opt1,
		}, nil)
		if err != nil {
			return err
		}
		_, err = elb.NewLoadBalancer(ctx, "elb", &elb.LoadBalancerArgs{
			Listeners: elb.LoadBalancerListenerArray{
				&elb.LoadBalancerListenerArgs{
					InstancePort:     pulumi.Int(8000),
					InstanceProtocol: pulumi.String("https"),
					LbPort:           pulumi.Int(443),
					LbProtocol:       pulumi.String("https"),
					SslCertificateId: pulumi.String(my_domain.Arn),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupUserArgs 

type LookupUserArgs struct {
	// Map of key-value pairs associated with the user.
	Tags map[string]string `pulumi:"tags"`
	// The friendly IAM user name to match.
	UserName string `pulumi:"userName"`
}

A collection of arguments for invoking getUser.

type LookupUserResult 

type LookupUserResult struct {
	// The Amazon Resource Name (ARN) assigned by AWS for this user.
	Arn string `pulumi:"arn"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// Path in which this user was created.
	Path string `pulumi:"path"`
	// The ARN of the policy that is used to set the permissions boundary for the user.
	PermissionsBoundary string `pulumi:"permissionsBoundary"`
	// Map of key-value pairs associated with the user.
	Tags map[string]string `pulumi:"tags"`
	// The unique ID assigned by AWS for this user.
	UserId string `pulumi:"userId"`
	// The name associated to this User
	UserName string `pulumi:"userName"`
}

A collection of values returned by getUser.

func LookupUser 

func LookupUser(ctx *pulumi.Context, args *LookupUserArgs, opts ...pulumi.InvokeOption) (*LookupUserResult, error)

This data source can be used to fetch information about a specific IAM user. By using this data source, you can reference IAM user properties without having to hard code ARNs or unique IDs as input.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := iam.LookupUser(ctx, &iam.LookupUserArgs{
			UserName: "an_example_user_name",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type ManagedPolicy added in v3.18.0 

type ManagedPolicy pulumi.String

func (ManagedPolicy) ElementType added in v3.18.0 

func (ManagedPolicy) ElementType() reflect.Type

func (ManagedPolicy) ToStringOutput added in v3.18.0 

func (e ManagedPolicy) ToStringOutput() pulumi.StringOutput

func (ManagedPolicy) ToStringOutputWithContext added in v3.18.0 

func (e ManagedPolicy) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ManagedPolicy) ToStringPtrOutput added in v3.18.0 

func (e ManagedPolicy) ToStringPtrOutput() pulumi.StringPtrOutput

func (ManagedPolicy) ToStringPtrOutputWithContext added in v3.18.0 

func (e ManagedPolicy) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type OpenIdConnectProvider 

type OpenIdConnectProvider struct {
	pulumi.CustomResourceState

	// The ARN assigned by AWS for this provider.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// A list of client IDs (also known as audiences). When a mobile or web app registers with an OpenID Connect provider, they establish a value that identifies the application. (This is the value that's sent as the clientId parameter on OAuth requests.)
	ClientIdLists pulumi.StringArrayOutput `pulumi:"clientIdLists"`
	// Map of resource tags for the IAM OIDC provider.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A list of server certificate thumbprints for the OpenID Connect (OIDC) identity provider's server certificate(s).
	ThumbprintLists pulumi.StringArrayOutput `pulumi:"thumbprintLists"`
	// The URL of the identity provider. Corresponds to the _iss_ claim.
	Url pulumi.StringOutput `pulumi:"url"`
}

Provides an IAM OpenID Connect provider.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := iam.NewOpenIdConnectProvider(ctx, "_default", &iam.OpenIdConnectProviderArgs{
			ClientIdLists: pulumi.StringArray{
				pulumi.String("266362248691-342342xasdasdasda-apps.googleusercontent.com"),
			},
			ThumbprintLists: []interface{}{},
			Url:             pulumi.String("https://accounts.google.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IAM OpenID Connect Providers can be imported using the `arn`, e.g.

```sh 

$ pulumi import aws:iam/openIdConnectProvider:OpenIdConnectProvider default arn:aws:iam::123456789012:oidc-provider/accounts.google.com

```

func GetOpenIdConnectProvider 

func GetOpenIdConnectProvider(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *OpenIdConnectProviderState, opts ...pulumi.ResourceOption) (*OpenIdConnectProvider, error)

GetOpenIdConnectProvider gets an existing OpenIdConnectProvider resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewOpenIdConnectProvider 

func NewOpenIdConnectProvider(ctx *pulumi.Context,
	name string, args *OpenIdConnectProviderArgs, opts ...pulumi.ResourceOption) (*OpenIdConnectProvider, error)

NewOpenIdConnectProvider registers a new resource with the given unique name, arguments, and options.

func (*OpenIdConnectProvider) ElementType added in v3.13.0 

func (*OpenIdConnectProvider) ElementType() reflect.Type

func (*OpenIdConnectProvider) ToOpenIdConnectProviderOutput added in v3.13.0 

func (i *OpenIdConnectProvider) ToOpenIdConnectProviderOutput() OpenIdConnectProviderOutput

func (*OpenIdConnectProvider) ToOpenIdConnectProviderOutputWithContext added in v3.13.0 

func (i *OpenIdConnectProvider) ToOpenIdConnectProviderOutputWithContext(ctx context.Context) OpenIdConnectProviderOutput

func (*OpenIdConnectProvider) ToOpenIdConnectProviderPtrOutput added in v3.25.0 

func (i *OpenIdConnectProvider) ToOpenIdConnectProviderPtrOutput() OpenIdConnectProviderPtrOutput

func (*OpenIdConnectProvider) ToOpenIdConnectProviderPtrOutputWithContext added in v3.25.0 

func (i *OpenIdConnectProvider) ToOpenIdConnectProviderPtrOutputWithContext(ctx context.Context) OpenIdConnectProviderPtrOutput

type OpenIdConnectProviderArgs 

type OpenIdConnectProviderArgs struct {
	// A list of client IDs (also known as audiences). When a mobile or web app registers with an OpenID Connect provider, they establish a value that identifies the application. (This is the value that's sent as the clientId parameter on OAuth requests.)
	ClientIdLists pulumi.StringArrayInput
	// Map of resource tags for the IAM OIDC provider.
	Tags pulumi.StringMapInput
	// A list of server certificate thumbprints for the OpenID Connect (OIDC) identity provider's server certificate(s).
	ThumbprintLists pulumi.StringArrayInput
	// The URL of the identity provider. Corresponds to the _iss_ claim.
	Url pulumi.StringInput
}

The set of arguments for constructing a OpenIdConnectProvider resource.

func (OpenIdConnectProviderArgs) ElementType 

func (OpenIdConnectProviderArgs) ElementType() reflect.Type

type OpenIdConnectProviderArray added in v3.25.0 

type OpenIdConnectProviderArray []OpenIdConnectProviderInput

func (OpenIdConnectProviderArray) ElementType added in v3.25.0 

func (OpenIdConnectProviderArray) ElementType() reflect.Type

func (OpenIdConnectProviderArray) ToOpenIdConnectProviderArrayOutput added in v3.25.0 

func (i OpenIdConnectProviderArray) ToOpenIdConnectProviderArrayOutput() OpenIdConnectProviderArrayOutput

func (OpenIdConnectProviderArray) ToOpenIdConnectProviderArrayOutputWithContext added in v3.25.0 

func (i OpenIdConnectProviderArray) ToOpenIdConnectProviderArrayOutputWithContext(ctx context.Context) OpenIdConnectProviderArrayOutput

type OpenIdConnectProviderArrayInput added in v3.25.0 

type OpenIdConnectProviderArrayInput interface {
	pulumi.Input

	ToOpenIdConnectProviderArrayOutput() OpenIdConnectProviderArrayOutput
	ToOpenIdConnectProviderArrayOutputWithContext(context.Context) OpenIdConnectProviderArrayOutput
}

OpenIdConnectProviderArrayInput is an input type that accepts OpenIdConnectProviderArray and OpenIdConnectProviderArrayOutput values. You can construct a concrete instance of `OpenIdConnectProviderArrayInput` via: 

OpenIdConnectProviderArray{ OpenIdConnectProviderArgs{...} }

type OpenIdConnectProviderArrayOutput added in v3.25.0 

type OpenIdConnectProviderArrayOutput struct{ *pulumi.OutputState }

func (OpenIdConnectProviderArrayOutput) ElementType added in v3.25.0 

func (OpenIdConnectProviderArrayOutput) ElementType() reflect.Type

func (OpenIdConnectProviderArrayOutput) Index added in v3.25.0 

func (o OpenIdConnectProviderArrayOutput) Index(i pulumi.IntInput) OpenIdConnectProviderOutput

func (OpenIdConnectProviderArrayOutput) ToOpenIdConnectProviderArrayOutput added in v3.25.0 

func (o OpenIdConnectProviderArrayOutput) ToOpenIdConnectProviderArrayOutput() OpenIdConnectProviderArrayOutput

func (OpenIdConnectProviderArrayOutput) ToOpenIdConnectProviderArrayOutputWithContext added in v3.25.0 

func (o OpenIdConnectProviderArrayOutput) ToOpenIdConnectProviderArrayOutputWithContext(ctx context.Context) OpenIdConnectProviderArrayOutput

type OpenIdConnectProviderInput added in v3.13.0 

type OpenIdConnectProviderInput interface {
	pulumi.Input

	ToOpenIdConnectProviderOutput() OpenIdConnectProviderOutput
	ToOpenIdConnectProviderOutputWithContext(ctx context.Context) OpenIdConnectProviderOutput
}

type OpenIdConnectProviderMap added in v3.25.0 

type OpenIdConnectProviderMap map[string]OpenIdConnectProviderInput

func (OpenIdConnectProviderMap) ElementType added in v3.25.0 

func (OpenIdConnectProviderMap) ElementType() reflect.Type

func (OpenIdConnectProviderMap) ToOpenIdConnectProviderMapOutput added in v3.25.0 

func (i OpenIdConnectProviderMap) ToOpenIdConnectProviderMapOutput() OpenIdConnectProviderMapOutput

func (OpenIdConnectProviderMap) ToOpenIdConnectProviderMapOutputWithContext added in v3.25.0 

func (i OpenIdConnectProviderMap) ToOpenIdConnectProviderMapOutputWithContext(ctx context.Context) OpenIdConnectProviderMapOutput

type OpenIdConnectProviderMapInput added in v3.25.0 

type OpenIdConnectProviderMapInput interface {
	pulumi.Input

	ToOpenIdConnectProviderMapOutput() OpenIdConnectProviderMapOutput
	ToOpenIdConnectProviderMapOutputWithContext(context.Context) OpenIdConnectProviderMapOutput
}

OpenIdConnectProviderMapInput is an input type that accepts OpenIdConnectProviderMap and OpenIdConnectProviderMapOutput values. You can construct a concrete instance of `OpenIdConnectProviderMapInput` via: 

OpenIdConnectProviderMap{ "key": OpenIdConnectProviderArgs{...} }

type OpenIdConnectProviderMapOutput added in v3.25.0 

type OpenIdConnectProviderMapOutput struct{ *pulumi.OutputState }

func (OpenIdConnectProviderMapOutput) ElementType added in v3.25.0 

func (OpenIdConnectProviderMapOutput) ElementType() reflect.Type

func (OpenIdConnectProviderMapOutput) MapIndex added in v3.25.0 

func (o OpenIdConnectProviderMapOutput) MapIndex(k pulumi.StringInput) OpenIdConnectProviderOutput

func (OpenIdConnectProviderMapOutput) ToOpenIdConnectProviderMapOutput added in v3.25.0 

func (o OpenIdConnectProviderMapOutput) ToOpenIdConnectProviderMapOutput() OpenIdConnectProviderMapOutput

func (OpenIdConnectProviderMapOutput) ToOpenIdConnectProviderMapOutputWithContext added in v3.25.0 

func (o OpenIdConnectProviderMapOutput) ToOpenIdConnectProviderMapOutputWithContext(ctx context.Context) OpenIdConnectProviderMapOutput

type OpenIdConnectProviderOutput added in v3.13.0 

type OpenIdConnectProviderOutput struct {
	*pulumi.OutputState
}

func (OpenIdConnectProviderOutput) ElementType added in v3.13.0 

func (OpenIdConnectProviderOutput) ElementType() reflect.Type

func (OpenIdConnectProviderOutput) ToOpenIdConnectProviderOutput added in v3.13.0 

func (o OpenIdConnectProviderOutput) ToOpenIdConnectProviderOutput() OpenIdConnectProviderOutput

func (OpenIdConnectProviderOutput) ToOpenIdConnectProviderOutputWithContext added in v3.13.0 

func (o OpenIdConnectProviderOutput) ToOpenIdConnectProviderOutputWithContext(ctx context.Context) OpenIdConnectProviderOutput

func (OpenIdConnectProviderOutput) ToOpenIdConnectProviderPtrOutput added in v3.25.0 

func (o OpenIdConnectProviderOutput) ToOpenIdConnectProviderPtrOutput() OpenIdConnectProviderPtrOutput

func (OpenIdConnectProviderOutput) ToOpenIdConnectProviderPtrOutputWithContext added in v3.25.0 

func (o OpenIdConnectProviderOutput) ToOpenIdConnectProviderPtrOutputWithContext(ctx context.Context) OpenIdConnectProviderPtrOutput

type OpenIdConnectProviderPtrInput added in v3.25.0 

type OpenIdConnectProviderPtrInput interface {
	pulumi.Input

	ToOpenIdConnectProviderPtrOutput() OpenIdConnectProviderPtrOutput
	ToOpenIdConnectProviderPtrOutputWithContext(ctx context.Context) OpenIdConnectProviderPtrOutput
}

type OpenIdConnectProviderPtrOutput added in v3.25.0 

type OpenIdConnectProviderPtrOutput struct {
	*pulumi.OutputState
}

func (OpenIdConnectProviderPtrOutput) ElementType added in v3.25.0 

func (OpenIdConnectProviderPtrOutput) ElementType() reflect.Type

func (OpenIdConnectProviderPtrOutput) ToOpenIdConnectProviderPtrOutput added in v3.25.0 

func (o OpenIdConnectProviderPtrOutput) ToOpenIdConnectProviderPtrOutput() OpenIdConnectProviderPtrOutput

func (OpenIdConnectProviderPtrOutput) ToOpenIdConnectProviderPtrOutputWithContext added in v3.25.0 

func (o OpenIdConnectProviderPtrOutput) ToOpenIdConnectProviderPtrOutputWithContext(ctx context.Context) OpenIdConnectProviderPtrOutput

type OpenIdConnectProviderState 

type OpenIdConnectProviderState struct {
	// The ARN assigned by AWS for this provider.
	Arn pulumi.StringPtrInput
	// A list of client IDs (also known as audiences). When a mobile or web app registers with an OpenID Connect provider, they establish a value that identifies the application. (This is the value that's sent as the clientId parameter on OAuth requests.)
	ClientIdLists pulumi.StringArrayInput
	// Map of resource tags for the IAM OIDC provider.
	Tags pulumi.StringMapInput
	// A list of server certificate thumbprints for the OpenID Connect (OIDC) identity provider's server certificate(s).
	ThumbprintLists pulumi.StringArrayInput
	// The URL of the identity provider. Corresponds to the _iss_ claim.
	Url pulumi.StringPtrInput
}

func (OpenIdConnectProviderState) ElementType 

func (OpenIdConnectProviderState) ElementType() reflect.Type

type Policy 

type Policy struct {
	pulumi.CustomResourceState

	// The ARN assigned by AWS to this policy.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// Description of the IAM policy.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// The name of the policy. If omitted, this provider will assign a random, unique name.
	Name pulumi.StringOutput `pulumi:"name"`
	// Creates a unique name beginning with the specified prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrOutput `pulumi:"namePrefix"`
	// Path in which to create the policy.
	// See [IAM Identifiers](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html) for more information.
	Path pulumi.StringPtrOutput `pulumi:"path"`
	// The policy document. This is a JSON formatted string.
	Policy pulumi.StringOutput `pulumi:"policy"`
	// The policy's ID.
	PolicyId pulumi.StringOutput `pulumi:"policyId"`
	// Map of resource tags for the IAM Policy
	Tags pulumi.StringMapOutput `pulumi:"tags"`
}

Provides an IAM policy.

## Example Usage

```go package main

import ( 

"encoding/json"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": []map[string]interface{}{
				map[string]interface{}{
					"Action": []string{
						"ec2:Describe*",
					},
					"Effect":   "Allow",
					"Resource": "*",
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err := iam.NewPolicy(ctx, "policy", &iam.PolicyArgs{
			Path:        pulumi.String("/"),
			Description: pulumi.String("My test policy"),
			Policy:      pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IAM Policies can be imported using the `arn`, e.g.

```sh 

$ pulumi import aws:iam/policy:Policy administrator arn:aws:iam::123456789012:policy/UsersManageOwnCredentials

```

func GetPolicy 

func GetPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *PolicyState, opts ...pulumi.ResourceOption) (*Policy, error)

GetPolicy gets an existing Policy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewPolicy 

func NewPolicy(ctx *pulumi.Context,
	name string, args *PolicyArgs, opts ...pulumi.ResourceOption) (*Policy, error)

NewPolicy registers a new resource with the given unique name, arguments, and options.

func (*Policy) ElementType added in v3.13.0 

func (*Policy) ElementType() reflect.Type

func (*Policy) ToPolicyOutput added in v3.13.0 

func (i *Policy) ToPolicyOutput() PolicyOutput

func (*Policy) ToPolicyOutputWithContext added in v3.13.0 

func (i *Policy) ToPolicyOutputWithContext(ctx context.Context) PolicyOutput

func (*Policy) ToPolicyPtrOutput added in v3.25.0 

func (i *Policy) ToPolicyPtrOutput() PolicyPtrOutput

func (*Policy) ToPolicyPtrOutputWithContext added in v3.25.0 

func (i *Policy) ToPolicyPtrOutputWithContext(ctx context.Context) PolicyPtrOutput

type PolicyArgs 

type PolicyArgs struct {
	// Description of the IAM policy.
	Description pulumi.StringPtrInput
	// The name of the policy. If omitted, this provider will assign a random, unique name.
	Name pulumi.StringPtrInput
	// Creates a unique name beginning with the specified prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrInput
	// Path in which to create the policy.
	// See [IAM Identifiers](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html) for more information.
	Path pulumi.StringPtrInput
	// The policy document. This is a JSON formatted string.
	Policy pulumi.Input
	// Map of resource tags for the IAM Policy
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a Policy resource.

func (PolicyArgs) ElementType 

func (PolicyArgs) ElementType() reflect.Type

type PolicyArray added in v3.25.0 

type PolicyArray []PolicyInput

func (PolicyArray) ElementType added in v3.25.0 

func (PolicyArray) ElementType() reflect.Type

func (PolicyArray) ToPolicyArrayOutput added in v3.25.0 

func (i PolicyArray) ToPolicyArrayOutput() PolicyArrayOutput

func (PolicyArray) ToPolicyArrayOutputWithContext added in v3.25.0 

func (i PolicyArray) ToPolicyArrayOutputWithContext(ctx context.Context) PolicyArrayOutput

type PolicyArrayInput added in v3.25.0 

type PolicyArrayInput interface {
	pulumi.Input

	ToPolicyArrayOutput() PolicyArrayOutput
	ToPolicyArrayOutputWithContext(context.Context) PolicyArrayOutput
}

PolicyArrayInput is an input type that accepts PolicyArray and PolicyArrayOutput values. You can construct a concrete instance of `PolicyArrayInput` via: 

PolicyArray{ PolicyArgs{...} }

type PolicyArrayOutput added in v3.25.0 

type PolicyArrayOutput struct{ *pulumi.OutputState }

func (PolicyArrayOutput) ElementType added in v3.25.0 

func (PolicyArrayOutput) ElementType() reflect.Type

func (PolicyArrayOutput) Index added in v3.25.0 

func (o PolicyArrayOutput) Index(i pulumi.IntInput) PolicyOutput

func (PolicyArrayOutput) ToPolicyArrayOutput added in v3.25.0 

func (o PolicyArrayOutput) ToPolicyArrayOutput() PolicyArrayOutput

func (PolicyArrayOutput) ToPolicyArrayOutputWithContext added in v3.25.0 

func (o PolicyArrayOutput) ToPolicyArrayOutputWithContext(ctx context.Context) PolicyArrayOutput

type PolicyAttachment 

type PolicyAttachment struct {
	pulumi.CustomResourceState

	// The group(s) the policy should be applied to
	Groups pulumi.StringArrayOutput `pulumi:"groups"`
	// The name of the attachment. This cannot be an empty string.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ARN of the policy you want to apply
	PolicyArn pulumi.StringOutput `pulumi:"policyArn"`
	// The role(s) the policy should be applied to
	Roles pulumi.StringArrayOutput `pulumi:"roles"`
	// The user(s) the policy should be applied to
	Users pulumi.StringArrayOutput `pulumi:"users"`
}

Attaches a Managed IAM Policy to user(s), role(s), and/or group(s)

!> **WARNING:** The iam.PolicyAttachment resource creates **exclusive** attachments of IAM policies. Across the entire AWS account, all of the users/roles/groups to which a single policy is attached must be declared by a single iam.PolicyAttachment resource. This means that even any users/roles/groups that have the attached policy via any other mechanism (including other resources managed by this provider) will have that attached policy revoked by this resource. Consider `iam.RolePolicyAttachment`, `iam.UserPolicyAttachment`, or `iam.GroupPolicyAttachment` instead. These resources do not enforce exclusive attachment of an IAM policy.

> **NOTE:** The usage of this resource conflicts with the `iam.GroupPolicyAttachment`, `iam.RolePolicyAttachment`, and `iam.UserPolicyAttachment` resources and will permanently show a difference if both are defined.

> **NOTE:** For a given role, this resource is incompatible with using the `iam.Role` resource `managedPolicyArns` argument. When using that argument and this resource, both will attempt to manage the role's managed policy attachments and the provider will show a permanent difference.

## Example Usage

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		user, err := iam.NewUser(ctx, "user", nil)
		if err != nil {
			return err
		}
		role, err := iam.NewRole(ctx, "role", &iam.RoleArgs{
			AssumeRolePolicy: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "  \"Version\": \"2012-10-17\",\n", "  \"Statement\": [\n", "    {\n", "      \"Action\": \"sts:AssumeRole\",\n", "      \"Principal\": {\n", "        \"Service\": \"ec2.amazonaws.com\"\n", "      },\n", "      \"Effect\": \"Allow\",\n", "      \"Sid\": \"\"\n", "    }\n", "  ]\n", "}\n")),
		})
		if err != nil {
			return err
		}
		group, err := iam.NewGroup(ctx, "group", nil)
		if err != nil {
			return err
		}
		policy, err := iam.NewPolicy(ctx, "policy", &iam.PolicyArgs{
			Description: pulumi.String("A test policy"),
			Policy:      pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "  \"Version\": \"2012-10-17\",\n", "  \"Statement\": [\n", "    {\n", "      \"Action\": [\n", "        \"ec2:Describe*\"\n", "      ],\n", "      \"Effect\": \"Allow\",\n", "      \"Resource\": \"*\"\n", "    }\n", "  ]\n", "}\n")),
		})
		if err != nil {
			return err
		}
		_, err = iam.NewPolicyAttachment(ctx, "test_attach", &iam.PolicyAttachmentArgs{
			Users: pulumi.StringArray{
				user.Name,
			},
			Roles: pulumi.StringArray{
				role.Name,
			},
			Groups: pulumi.StringArray{
				group.Name,
			},
			PolicyArn: policy.Arn,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetPolicyAttachment 

func GetPolicyAttachment(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *PolicyAttachmentState, opts ...pulumi.ResourceOption) (*PolicyAttachment, error)

GetPolicyAttachment gets an existing PolicyAttachment resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewPolicyAttachment 

func NewPolicyAttachment(ctx *pulumi.Context,
	name string, args *PolicyAttachmentArgs, opts ...pulumi.ResourceOption) (*PolicyAttachment, error)

NewPolicyAttachment registers a new resource with the given unique name, arguments, and options.

func (*PolicyAttachment) ElementType added in v3.13.0 

func (*PolicyAttachment) ElementType() reflect.Type

func (*PolicyAttachment) ToPolicyAttachmentOutput added in v3.13.0 

func (i *PolicyAttachment) ToPolicyAttachmentOutput() PolicyAttachmentOutput

func (*PolicyAttachment) ToPolicyAttachmentOutputWithContext added in v3.13.0 

func (i *PolicyAttachment) ToPolicyAttachmentOutputWithContext(ctx context.Context) PolicyAttachmentOutput

func (*PolicyAttachment) ToPolicyAttachmentPtrOutput added in v3.25.0 

func (i *PolicyAttachment) ToPolicyAttachmentPtrOutput() PolicyAttachmentPtrOutput

func (*PolicyAttachment) ToPolicyAttachmentPtrOutputWithContext added in v3.25.0 

func (i *PolicyAttachment) ToPolicyAttachmentPtrOutputWithContext(ctx context.Context) PolicyAttachmentPtrOutput

type PolicyAttachmentArgs 

type PolicyAttachmentArgs struct {
	// The group(s) the policy should be applied to
	Groups pulumi.ArrayInput
	// The name of the attachment. This cannot be an empty string.
	Name pulumi.StringPtrInput
	// The ARN of the policy you want to apply
	PolicyArn pulumi.StringInput
	// The role(s) the policy should be applied to
	Roles pulumi.ArrayInput
	// The user(s) the policy should be applied to
	Users pulumi.ArrayInput
}

The set of arguments for constructing a PolicyAttachment resource.

func (PolicyAttachmentArgs) ElementType 

func (PolicyAttachmentArgs) ElementType() reflect.Type

type PolicyAttachmentArray added in v3.25.0 

type PolicyAttachmentArray []PolicyAttachmentInput

func (PolicyAttachmentArray) ElementType added in v3.25.0 

func (PolicyAttachmentArray) ElementType() reflect.Type

func (PolicyAttachmentArray) ToPolicyAttachmentArrayOutput added in v3.25.0 

func (i PolicyAttachmentArray) ToPolicyAttachmentArrayOutput() PolicyAttachmentArrayOutput

func (PolicyAttachmentArray) ToPolicyAttachmentArrayOutputWithContext added in v3.25.0 

func (i PolicyAttachmentArray) ToPolicyAttachmentArrayOutputWithContext(ctx context.Context) PolicyAttachmentArrayOutput

type PolicyAttachmentArrayInput added in v3.25.0 

type PolicyAttachmentArrayInput interface {
	pulumi.Input

	ToPolicyAttachmentArrayOutput() PolicyAttachmentArrayOutput
	ToPolicyAttachmentArrayOutputWithContext(context.Context) PolicyAttachmentArrayOutput
}

PolicyAttachmentArrayInput is an input type that accepts PolicyAttachmentArray and PolicyAttachmentArrayOutput values. You can construct a concrete instance of `PolicyAttachmentArrayInput` via: 

PolicyAttachmentArray{ PolicyAttachmentArgs{...} }

type PolicyAttachmentArrayOutput added in v3.25.0 

type PolicyAttachmentArrayOutput struct{ *pulumi.OutputState }

func (PolicyAttachmentArrayOutput) ElementType added in v3.25.0 

func (PolicyAttachmentArrayOutput) ElementType() reflect.Type

func (PolicyAttachmentArrayOutput) Index added in v3.25.0 

func (o PolicyAttachmentArrayOutput) Index(i pulumi.IntInput) PolicyAttachmentOutput

func (PolicyAttachmentArrayOutput) ToPolicyAttachmentArrayOutput added in v3.25.0 

func (o PolicyAttachmentArrayOutput) ToPolicyAttachmentArrayOutput() PolicyAttachmentArrayOutput

func (PolicyAttachmentArrayOutput) ToPolicyAttachmentArrayOutputWithContext added in v3.25.0 

func (o PolicyAttachmentArrayOutput) ToPolicyAttachmentArrayOutputWithContext(ctx context.Context) PolicyAttachmentArrayOutput

type PolicyAttachmentInput added in v3.13.0 

type PolicyAttachmentInput interface {
	pulumi.Input

	ToPolicyAttachmentOutput() PolicyAttachmentOutput
	ToPolicyAttachmentOutputWithContext(ctx context.Context) PolicyAttachmentOutput
}

type PolicyAttachmentMap added in v3.25.0 

type PolicyAttachmentMap map[string]PolicyAttachmentInput

func (PolicyAttachmentMap) ElementType added in v3.25.0 

func (PolicyAttachmentMap) ElementType() reflect.Type

func (PolicyAttachmentMap) ToPolicyAttachmentMapOutput added in v3.25.0 

func (i PolicyAttachmentMap) ToPolicyAttachmentMapOutput() PolicyAttachmentMapOutput

func (PolicyAttachmentMap) ToPolicyAttachmentMapOutputWithContext added in v3.25.0 

func (i PolicyAttachmentMap) ToPolicyAttachmentMapOutputWithContext(ctx context.Context) PolicyAttachmentMapOutput

type PolicyAttachmentMapInput added in v3.25.0 

type PolicyAttachmentMapInput interface {
	pulumi.Input

	ToPolicyAttachmentMapOutput() PolicyAttachmentMapOutput
	ToPolicyAttachmentMapOutputWithContext(context.Context) PolicyAttachmentMapOutput
}

PolicyAttachmentMapInput is an input type that accepts PolicyAttachmentMap and PolicyAttachmentMapOutput values. You can construct a concrete instance of `PolicyAttachmentMapInput` via: 

PolicyAttachmentMap{ "key": PolicyAttachmentArgs{...} }

type PolicyAttachmentMapOutput added in v3.25.0 

type PolicyAttachmentMapOutput struct{ *pulumi.OutputState }

func (PolicyAttachmentMapOutput) ElementType added in v3.25.0 

func (PolicyAttachmentMapOutput) ElementType() reflect.Type

func (PolicyAttachmentMapOutput) MapIndex added in v3.25.0 

func (o PolicyAttachmentMapOutput) MapIndex(k pulumi.StringInput) PolicyAttachmentOutput

func (PolicyAttachmentMapOutput) ToPolicyAttachmentMapOutput added in v3.25.0 

func (o PolicyAttachmentMapOutput) ToPolicyAttachmentMapOutput() PolicyAttachmentMapOutput

func (PolicyAttachmentMapOutput) ToPolicyAttachmentMapOutputWithContext added in v3.25.0 

func (o PolicyAttachmentMapOutput) ToPolicyAttachmentMapOutputWithContext(ctx context.Context) PolicyAttachmentMapOutput

type PolicyAttachmentOutput added in v3.13.0 

type PolicyAttachmentOutput struct {
	*pulumi.OutputState
}

func (PolicyAttachmentOutput) ElementType added in v3.13.0 

func (PolicyAttachmentOutput) ElementType() reflect.Type

func (PolicyAttachmentOutput) ToPolicyAttachmentOutput added in v3.13.0 

func (o PolicyAttachmentOutput) ToPolicyAttachmentOutput() PolicyAttachmentOutput

func (PolicyAttachmentOutput) ToPolicyAttachmentOutputWithContext added in v3.13.0 

func (o PolicyAttachmentOutput) ToPolicyAttachmentOutputWithContext(ctx context.Context) PolicyAttachmentOutput

func (PolicyAttachmentOutput) ToPolicyAttachmentPtrOutput added in v3.25.0 

func (o PolicyAttachmentOutput) ToPolicyAttachmentPtrOutput() PolicyAttachmentPtrOutput

func (PolicyAttachmentOutput) ToPolicyAttachmentPtrOutputWithContext added in v3.25.0 

func (o PolicyAttachmentOutput) ToPolicyAttachmentPtrOutputWithContext(ctx context.Context) PolicyAttachmentPtrOutput

type PolicyAttachmentPtrInput added in v3.25.0 

type PolicyAttachmentPtrInput interface {
	pulumi.Input

	ToPolicyAttachmentPtrOutput() PolicyAttachmentPtrOutput
	ToPolicyAttachmentPtrOutputWithContext(ctx context.Context) PolicyAttachmentPtrOutput
}

type PolicyAttachmentPtrOutput added in v3.25.0 

type PolicyAttachmentPtrOutput struct {
	*pulumi.OutputState
}

func (PolicyAttachmentPtrOutput) ElementType added in v3.25.0 

func (PolicyAttachmentPtrOutput) ElementType() reflect.Type

func (PolicyAttachmentPtrOutput) ToPolicyAttachmentPtrOutput added in v3.25.0 

func (o PolicyAttachmentPtrOutput) ToPolicyAttachmentPtrOutput() PolicyAttachmentPtrOutput

func (PolicyAttachmentPtrOutput) ToPolicyAttachmentPtrOutputWithContext added in v3.25.0 

func (o PolicyAttachmentPtrOutput) ToPolicyAttachmentPtrOutputWithContext(ctx context.Context) PolicyAttachmentPtrOutput

type PolicyAttachmentState 

type PolicyAttachmentState struct {
	// The group(s) the policy should be applied to
	Groups pulumi.StringArrayInput
	// The name of the attachment. This cannot be an empty string.
	Name pulumi.StringPtrInput
	// The ARN of the policy you want to apply
	PolicyArn pulumi.StringPtrInput
	// The role(s) the policy should be applied to
	Roles pulumi.StringArrayInput
	// The user(s) the policy should be applied to
	Users pulumi.StringArrayInput
}

func (PolicyAttachmentState) ElementType 

func (PolicyAttachmentState) ElementType() reflect.Type

type PolicyInput added in v3.13.0 

type PolicyInput interface {
	pulumi.Input

	ToPolicyOutput() PolicyOutput
	ToPolicyOutputWithContext(ctx context.Context) PolicyOutput
}

type PolicyMap added in v3.25.0 

type PolicyMap map[string]PolicyInput

func (PolicyMap) ElementType added in v3.25.0 

func (PolicyMap) ElementType() reflect.Type

func (PolicyMap) ToPolicyMapOutput added in v3.25.0 

func (i PolicyMap) ToPolicyMapOutput() PolicyMapOutput

func (PolicyMap) ToPolicyMapOutputWithContext added in v3.25.0 

func (i PolicyMap) ToPolicyMapOutputWithContext(ctx context.Context) PolicyMapOutput

type PolicyMapInput added in v3.25.0 

type PolicyMapInput interface {
	pulumi.Input

	ToPolicyMapOutput() PolicyMapOutput
	ToPolicyMapOutputWithContext(context.Context) PolicyMapOutput
}

PolicyMapInput is an input type that accepts PolicyMap and PolicyMapOutput values. You can construct a concrete instance of `PolicyMapInput` via: 

PolicyMap{ "key": PolicyArgs{...} }

type PolicyMapOutput added in v3.25.0 

type PolicyMapOutput struct{ *pulumi.OutputState }

func (PolicyMapOutput) ElementType added in v3.25.0 

func (PolicyMapOutput) ElementType() reflect.Type

func (PolicyMapOutput) MapIndex added in v3.25.0 

func (o PolicyMapOutput) MapIndex(k pulumi.StringInput) PolicyOutput

func (PolicyMapOutput) ToPolicyMapOutput added in v3.25.0 

func (o PolicyMapOutput) ToPolicyMapOutput() PolicyMapOutput

func (PolicyMapOutput) ToPolicyMapOutputWithContext added in v3.25.0 

func (o PolicyMapOutput) ToPolicyMapOutputWithContext(ctx context.Context) PolicyMapOutput

type PolicyOutput added in v3.13.0 

type PolicyOutput struct {
	*pulumi.OutputState
}

func (PolicyOutput) ElementType added in v3.13.0 

func (PolicyOutput) ElementType() reflect.Type

func (PolicyOutput) ToPolicyOutput added in v3.13.0 

func (o PolicyOutput) ToPolicyOutput() PolicyOutput

func (PolicyOutput) ToPolicyOutputWithContext added in v3.13.0 

func (o PolicyOutput) ToPolicyOutputWithContext(ctx context.Context) PolicyOutput

func (PolicyOutput) ToPolicyPtrOutput added in v3.25.0 

func (o PolicyOutput) ToPolicyPtrOutput() PolicyPtrOutput

func (PolicyOutput) ToPolicyPtrOutputWithContext added in v3.25.0 

func (o PolicyOutput) ToPolicyPtrOutputWithContext(ctx context.Context) PolicyPtrOutput

type PolicyPtrInput added in v3.25.0 

type PolicyPtrInput interface {
	pulumi.Input

	ToPolicyPtrOutput() PolicyPtrOutput
	ToPolicyPtrOutputWithContext(ctx context.Context) PolicyPtrOutput
}

type PolicyPtrOutput added in v3.25.0 

type PolicyPtrOutput struct {
	*pulumi.OutputState
}

func (PolicyPtrOutput) ElementType added in v3.25.0 

func (PolicyPtrOutput) ElementType() reflect.Type

func (PolicyPtrOutput) ToPolicyPtrOutput added in v3.25.0 

func (o PolicyPtrOutput) ToPolicyPtrOutput() PolicyPtrOutput

func (PolicyPtrOutput) ToPolicyPtrOutputWithContext added in v3.25.0 

func (o PolicyPtrOutput) ToPolicyPtrOutputWithContext(ctx context.Context) PolicyPtrOutput

type PolicyState 

type PolicyState struct {
	// The ARN assigned by AWS to this policy.
	Arn pulumi.StringPtrInput
	// Description of the IAM policy.
	Description pulumi.StringPtrInput
	// The name of the policy. If omitted, this provider will assign a random, unique name.
	Name pulumi.StringPtrInput
	// Creates a unique name beginning with the specified prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrInput
	// Path in which to create the policy.
	// See [IAM Identifiers](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html) for more information.
	Path pulumi.StringPtrInput
	// The policy document. This is a JSON formatted string.
	Policy pulumi.StringPtrInput
	// The policy's ID.
	PolicyId pulumi.StringPtrInput
	// Map of resource tags for the IAM Policy
	Tags pulumi.StringMapInput
}

func (PolicyState) ElementType 

func (PolicyState) ElementType() reflect.Type

type Role 

type Role struct {
	pulumi.CustomResourceState

	// Amazon Resource Name (ARN) specifying the role.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// Policy that grants an entity permission to assume the role.
	AssumeRolePolicy pulumi.StringOutput `pulumi:"assumeRolePolicy"`
	// Creation date of the IAM role.
	CreateDate pulumi.StringOutput `pulumi:"createDate"`
	// Description of the role.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Whether to force detaching any policies the role has before destroying it. Defaults to `false`.
	ForceDetachPolicies pulumi.BoolPtrOutput `pulumi:"forceDetachPolicies"`
	// Configuration block defining an exclusive set of IAM inline policies associated with the IAM role. Defined below. If no blocks are configured, the provider will ignore any managing any inline policies in this resource. Configuring one empty block (i.e., `inlinePolicy {}`) will cause the provider to remove _all_ inline policies.
	InlinePolicies RoleInlinePolicyArrayOutput `pulumi:"inlinePolicies"`
	// Set of exclusive IAM managed policy ARNs to attach to the IAM role. If this attribute is not configured, the provider will ignore policy attachments to this resource. When configured, the provider will align the role's managed policy attachments with this set by attaching or detaching managed policies. Configuring an empty set (i.e., `managedPolicyArns = []`) will cause the provider to remove _all_ managed policy attachments.
	ManagedPolicyArns pulumi.StringArrayOutput `pulumi:"managedPolicyArns"`
	// Maximum session duration (in seconds) that you want to set for the specified role. If you do not specify a value for this setting, the default maximum of one hour is applied. This setting can have a value from 1 hour to 12 hours.
	MaxSessionDuration pulumi.IntPtrOutput `pulumi:"maxSessionDuration"`
	// Name of the role policy.
	Name pulumi.StringOutput `pulumi:"name"`
	// Creates a unique friendly name beginning with the specified prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrOutput `pulumi:"namePrefix"`
	// Path to the role. See [IAM Identifiers](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html) for more information.
	Path pulumi.StringPtrOutput `pulumi:"path"`
	// ARN of the policy that is used to set the permissions boundary for the role.
	PermissionsBoundary pulumi.StringPtrOutput `pulumi:"permissionsBoundary"`
	// Key-value mapping of tags for the IAM role
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// Stable and unique string identifying the role.
	UniqueId pulumi.StringOutput `pulumi:"uniqueId"`
}

Provides an IAM role.

> **NOTE:** If policies are attached to the role via the `iam.PolicyAttachment` resource and you are modifying the role `name` or `path`, the `forceDetachPolicies` argument must be set to `true` and applied before attempting the operation otherwise you will encounter a `DeleteConflict` error. The `iam.RolePolicyAttachment` resource does not have this requirement.

> **NOTE:** If you use this resource's `managedPolicyArns` argument or `inlinePolicy` configuration blocks, this resource will take over exclusive management of the role's respective policy types (e.g., both policy types if both arguments are used). These arguments are incompatible with other ways of managing a role's policies, such as `iam.PolicyAttachment`, `iam.RolePolicyAttachment`, and `iam.RolePolicy`. If you attempt to manage a role's policies by multiple means, you will get resource cycling and/or errors.

## Example Usage ### Basic Example

```go package main

import ( 

"encoding/json"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": []map[string]interface{}{
				map[string]interface{}{
					"Action": "sts:AssumeRole",
					"Effect": "Allow",
					"Sid":    "",
					"Principal": map[string]interface{}{
						"Service": "ec2.amazonaws.com",
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err := iam.NewRole(ctx, "testRole", &iam.RoleArgs{
			AssumeRolePolicy: pulumi.String(json0),
			Tags: pulumi.StringMap{
				"tag-key": pulumi.String("tag-value"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Example of Using Data Source for Assume Role Policy

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		instance_assume_role_policy, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
			Statements: []iam.GetPolicyDocumentStatement{
				iam.GetPolicyDocumentStatement{
					Actions: []string{
						"sts:AssumeRole",
					},
					Principals: []iam.GetPolicyDocumentStatementPrincipal{
						iam.GetPolicyDocumentStatementPrincipal{
							Type: "Service",
							Identifiers: []string{
								"ec2.amazonaws.com",
							},
						},
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = iam.NewRole(ctx, "instance", &iam.RoleArgs{
			Path:             pulumi.String("/system/"),
			AssumeRolePolicy: pulumi.String(instance_assume_role_policy.Json),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Example of Removing Inline Policies

This example creates an IAM role with what appears to be empty IAM `inlinePolicy` argument instead of using `inlinePolicy` as a configuration block. The result is that if someone were to add an inline policy out-of-band, on the next apply, the provider will remove that policy.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := iam.NewRole(ctx, "example", &iam.RoleArgs{
			AssumeRolePolicy: pulumi.Any(data.Aws_iam_policy_document.Instance_assume_role_policy.Json),
			InlinePolicies: iam.RoleInlinePolicyArray{
				nil,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Example of Exclusive Managed Policies

This example creates an IAM role and attaches two managed IAM policies. If someone attaches another managed policy out-of-band, on the next apply, the provider will detach that policy. If someone detaches these policies out-of-band, the provider will attach them again.

```go package main

import ( 

"encoding/json"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": []map[string]interface{}{
				map[string]interface{}{
					"Action": []string{
						"ec2:Describe*",
					},
					"Effect":   "Allow",
					"Resource": "*",
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		policyOne, err := iam.NewPolicy(ctx, "policyOne", &iam.PolicyArgs{
			Policy: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": []map[string]interface{}{
				map[string]interface{}{
					"Action": []string{
						"s3:ListAllMyBuckets",
						"s3:ListBucket",
						"s3:HeadBucket",
					},
					"Effect":   "Allow",
					"Resource": "*",
				},
			},
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		policyTwo, err := iam.NewPolicy(ctx, "policyTwo", &iam.PolicyArgs{
			Policy: pulumi.String(json1),
		})
		if err != nil {
			return err
		}
		_, err = iam.NewRole(ctx, "example", &iam.RoleArgs{
			AssumeRolePolicy: pulumi.Any(data.Aws_iam_policy_document.Instance_assume_role_policy.Json),
			ManagedPolicyArns: pulumi.StringArray{
				policyOne.Arn,
				policyTwo.Arn,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Example of Removing Managed Policies

This example creates an IAM role with an empty `managedPolicyArns` argument. If someone attaches a policy out-of-band, on the next apply, the provider will detach that policy.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := iam.NewRole(ctx, "example", &iam.RoleArgs{
			AssumeRolePolicy:  pulumi.Any(data.Aws_iam_policy_document.Instance_assume_role_policy.Json),
			ManagedPolicyArns: []interface{}{},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IAM Roles can be imported using the `name`, e.g.

```sh 

$ pulumi import aws:iam/role:Role developer developer_name

```

func GetRole 

func GetRole(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RoleState, opts ...pulumi.ResourceOption) (*Role, error)

GetRole gets an existing Role resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewRole 

func NewRole(ctx *pulumi.Context,
	name string, args *RoleArgs, opts ...pulumi.ResourceOption) (*Role, error)

NewRole registers a new resource with the given unique name, arguments, and options.

func (*Role) ElementType added in v3.13.0 

func (*Role) ElementType() reflect.Type

func (*Role) ToRoleOutput added in v3.13.0 

func (i *Role) ToRoleOutput() RoleOutput

func (*Role) ToRoleOutputWithContext added in v3.13.0 

func (i *Role) ToRoleOutputWithContext(ctx context.Context) RoleOutput

func (*Role) ToRolePtrOutput added in v3.25.0 

func (i *Role) ToRolePtrOutput() RolePtrOutput

func (*Role) ToRolePtrOutputWithContext added in v3.25.0 

func (i *Role) ToRolePtrOutputWithContext(ctx context.Context) RolePtrOutput

type RoleArgs 

type RoleArgs struct {
	// Policy that grants an entity permission to assume the role.
	AssumeRolePolicy pulumi.Input
	// Description of the role.
	Description pulumi.StringPtrInput
	// Whether to force detaching any policies the role has before destroying it. Defaults to `false`.
	ForceDetachPolicies pulumi.BoolPtrInput
	// Configuration block defining an exclusive set of IAM inline policies associated with the IAM role. Defined below. If no blocks are configured, the provider will ignore any managing any inline policies in this resource. Configuring one empty block (i.e., `inlinePolicy {}`) will cause the provider to remove _all_ inline policies.
	InlinePolicies RoleInlinePolicyArrayInput
	// Set of exclusive IAM managed policy ARNs to attach to the IAM role. If this attribute is not configured, the provider will ignore policy attachments to this resource. When configured, the provider will align the role's managed policy attachments with this set by attaching or detaching managed policies. Configuring an empty set (i.e., `managedPolicyArns = []`) will cause the provider to remove _all_ managed policy attachments.
	ManagedPolicyArns pulumi.StringArrayInput
	// Maximum session duration (in seconds) that you want to set for the specified role. If you do not specify a value for this setting, the default maximum of one hour is applied. This setting can have a value from 1 hour to 12 hours.
	MaxSessionDuration pulumi.IntPtrInput
	// Name of the role policy.
	Name pulumi.StringPtrInput
	// Creates a unique friendly name beginning with the specified prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrInput
	// Path to the role. See [IAM Identifiers](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html) for more information.
	Path pulumi.StringPtrInput
	// ARN of the policy that is used to set the permissions boundary for the role.
	PermissionsBoundary pulumi.StringPtrInput
	// Key-value mapping of tags for the IAM role
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a Role resource.

func (RoleArgs) ElementType 

func (RoleArgs) ElementType() reflect.Type

type RoleArray added in v3.25.0 

type RoleArray []RoleInput

func (RoleArray) ElementType added in v3.25.0 

func (RoleArray) ElementType() reflect.Type

func (RoleArray) ToRoleArrayOutput added in v3.25.0 

func (i RoleArray) ToRoleArrayOutput() RoleArrayOutput

func (RoleArray) ToRoleArrayOutputWithContext added in v3.25.0 

func (i RoleArray) ToRoleArrayOutputWithContext(ctx context.Context) RoleArrayOutput

type RoleArrayInput added in v3.25.0 

type RoleArrayInput interface {
	pulumi.Input

	ToRoleArrayOutput() RoleArrayOutput
	ToRoleArrayOutputWithContext(context.Context) RoleArrayOutput
}

RoleArrayInput is an input type that accepts RoleArray and RoleArrayOutput values. You can construct a concrete instance of `RoleArrayInput` via: 

RoleArray{ RoleArgs{...} }

type RoleArrayOutput added in v3.25.0 

type RoleArrayOutput struct{ *pulumi.OutputState }

func (RoleArrayOutput) ElementType added in v3.25.0 

func (RoleArrayOutput) ElementType() reflect.Type

func (RoleArrayOutput) Index added in v3.25.0 

func (o RoleArrayOutput) Index(i pulumi.IntInput) RoleOutput

func (RoleArrayOutput) ToRoleArrayOutput added in v3.25.0 

func (o RoleArrayOutput) ToRoleArrayOutput() RoleArrayOutput

func (RoleArrayOutput) ToRoleArrayOutputWithContext added in v3.25.0 

func (o RoleArrayOutput) ToRoleArrayOutputWithContext(ctx context.Context) RoleArrayOutput

type RoleInlinePolicy added in v3.30.1 

type RoleInlinePolicy struct {
	// Name of the role policy.
	Name *string `pulumi:"name"`
	// Policy document as a JSON formatted string.
	Policy *string `pulumi:"policy"`
}

type RoleInlinePolicyArgs added in v3.30.1 

type RoleInlinePolicyArgs struct {
	// Name of the role policy.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// Policy document as a JSON formatted string.
	Policy pulumi.StringPtrInput `pulumi:"policy"`
}

func (RoleInlinePolicyArgs) ElementType added in v3.30.1 

func (RoleInlinePolicyArgs) ElementType() reflect.Type

func (RoleInlinePolicyArgs) ToRoleInlinePolicyOutput added in v3.30.1 

func (i RoleInlinePolicyArgs) ToRoleInlinePolicyOutput() RoleInlinePolicyOutput

func (RoleInlinePolicyArgs) ToRoleInlinePolicyOutputWithContext added in v3.30.1 

func (i RoleInlinePolicyArgs) ToRoleInlinePolicyOutputWithContext(ctx context.Context) RoleInlinePolicyOutput

type RoleInlinePolicyArray added in v3.30.1 

type RoleInlinePolicyArray []RoleInlinePolicyInput

func (RoleInlinePolicyArray) ElementType added in v3.30.1 

func (RoleInlinePolicyArray) ElementType() reflect.Type

func (RoleInlinePolicyArray) ToRoleInlinePolicyArrayOutput added in v3.30.1 

func (i RoleInlinePolicyArray) ToRoleInlinePolicyArrayOutput() RoleInlinePolicyArrayOutput

func (RoleInlinePolicyArray) ToRoleInlinePolicyArrayOutputWithContext added in v3.30.1 

func (i RoleInlinePolicyArray) ToRoleInlinePolicyArrayOutputWithContext(ctx context.Context) RoleInlinePolicyArrayOutput

type RoleInlinePolicyArrayInput added in v3.30.1 

type RoleInlinePolicyArrayInput interface {
	pulumi.Input

	ToRoleInlinePolicyArrayOutput() RoleInlinePolicyArrayOutput
	ToRoleInlinePolicyArrayOutputWithContext(context.Context) RoleInlinePolicyArrayOutput
}

RoleInlinePolicyArrayInput is an input type that accepts RoleInlinePolicyArray and RoleInlinePolicyArrayOutput values. You can construct a concrete instance of `RoleInlinePolicyArrayInput` via: 

RoleInlinePolicyArray{ RoleInlinePolicyArgs{...} }

type RoleInlinePolicyArrayOutput added in v3.30.1 

type RoleInlinePolicyArrayOutput struct{ *pulumi.OutputState }

func (RoleInlinePolicyArrayOutput) ElementType added in v3.30.1 

func (RoleInlinePolicyArrayOutput) ElementType() reflect.Type

func (RoleInlinePolicyArrayOutput) Index added in v3.30.1 

func (o RoleInlinePolicyArrayOutput) Index(i pulumi.IntInput) RoleInlinePolicyOutput

func (RoleInlinePolicyArrayOutput) ToRoleInlinePolicyArrayOutput added in v3.30.1 

func (o RoleInlinePolicyArrayOutput) ToRoleInlinePolicyArrayOutput() RoleInlinePolicyArrayOutput

func (RoleInlinePolicyArrayOutput) ToRoleInlinePolicyArrayOutputWithContext added in v3.30.1 

func (o RoleInlinePolicyArrayOutput) ToRoleInlinePolicyArrayOutputWithContext(ctx context.Context) RoleInlinePolicyArrayOutput

type RoleInlinePolicyInput added in v3.30.1 

type RoleInlinePolicyInput interface {
	pulumi.Input

	ToRoleInlinePolicyOutput() RoleInlinePolicyOutput
	ToRoleInlinePolicyOutputWithContext(context.Context) RoleInlinePolicyOutput
}

RoleInlinePolicyInput is an input type that accepts RoleInlinePolicyArgs and RoleInlinePolicyOutput values. You can construct a concrete instance of `RoleInlinePolicyInput` via: 

RoleInlinePolicyArgs{...}

type RoleInlinePolicyOutput added in v3.30.1 

type RoleInlinePolicyOutput struct{ *pulumi.OutputState }

func (RoleInlinePolicyOutput) ElementType added in v3.30.1 

func (RoleInlinePolicyOutput) ElementType() reflect.Type

func (RoleInlinePolicyOutput) Name added in v3.30.1 

func (o RoleInlinePolicyOutput) Name() pulumi.StringPtrOutput

Name of the role policy.

func (RoleInlinePolicyOutput) Policy added in v3.30.1 

func (o RoleInlinePolicyOutput) Policy() pulumi.StringPtrOutput

Policy document as a JSON formatted string.

func (RoleInlinePolicyOutput) ToRoleInlinePolicyOutput added in v3.30.1 

func (o RoleInlinePolicyOutput) ToRoleInlinePolicyOutput() RoleInlinePolicyOutput

func (RoleInlinePolicyOutput) ToRoleInlinePolicyOutputWithContext added in v3.30.1 

func (o RoleInlinePolicyOutput) ToRoleInlinePolicyOutputWithContext(ctx context.Context) RoleInlinePolicyOutput

type RoleInput added in v3.13.0 

type RoleInput interface {
	pulumi.Input

	ToRoleOutput() RoleOutput
	ToRoleOutputWithContext(ctx context.Context) RoleOutput
}

type RoleMap added in v3.25.0 

type RoleMap map[string]RoleInput

func (RoleMap) ElementType added in v3.25.0 

func (RoleMap) ElementType() reflect.Type

func (RoleMap) ToRoleMapOutput added in v3.25.0 

func (i RoleMap) ToRoleMapOutput() RoleMapOutput

func (RoleMap) ToRoleMapOutputWithContext added in v3.25.0 

func (i RoleMap) ToRoleMapOutputWithContext(ctx context.Context) RoleMapOutput

type RoleMapInput added in v3.25.0 

type RoleMapInput interface {
	pulumi.Input

	ToRoleMapOutput() RoleMapOutput
	ToRoleMapOutputWithContext(context.Context) RoleMapOutput
}

RoleMapInput is an input type that accepts RoleMap and RoleMapOutput values. You can construct a concrete instance of `RoleMapInput` via: 

RoleMap{ "key": RoleArgs{...} }

type RoleMapOutput added in v3.25.0 

type RoleMapOutput struct{ *pulumi.OutputState }

func (RoleMapOutput) ElementType added in v3.25.0 

func (RoleMapOutput) ElementType() reflect.Type

func (RoleMapOutput) MapIndex added in v3.25.0 

func (o RoleMapOutput) MapIndex(k pulumi.StringInput) RoleOutput

func (RoleMapOutput) ToRoleMapOutput added in v3.25.0 

func (o RoleMapOutput) ToRoleMapOutput() RoleMapOutput

func (RoleMapOutput) ToRoleMapOutputWithContext added in v3.25.0 

func (o RoleMapOutput) ToRoleMapOutputWithContext(ctx context.Context) RoleMapOutput

type RoleOutput added in v3.13.0 

type RoleOutput struct {
	*pulumi.OutputState
}

func (RoleOutput) ElementType added in v3.13.0 

func (RoleOutput) ElementType() reflect.Type

func (RoleOutput) ToRoleOutput added in v3.13.0 

func (o RoleOutput) ToRoleOutput() RoleOutput

func (RoleOutput) ToRoleOutputWithContext added in v3.13.0 

func (o RoleOutput) ToRoleOutputWithContext(ctx context.Context) RoleOutput

func (RoleOutput) ToRolePtrOutput added in v3.25.0 

func (o RoleOutput) ToRolePtrOutput() RolePtrOutput

func (RoleOutput) ToRolePtrOutputWithContext added in v3.25.0 

func (o RoleOutput) ToRolePtrOutputWithContext(ctx context.Context) RolePtrOutput

type RolePolicy 

type RolePolicy struct {
	pulumi.CustomResourceState

	// The name of the role policy. If omitted, this provider will
	// assign a random, unique name.
	Name pulumi.StringOutput `pulumi:"name"`
	// Creates a unique name beginning with the specified
	// prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrOutput `pulumi:"namePrefix"`
	// The policy document. This is a JSON formatted string.
	Policy pulumi.StringOutput `pulumi:"policy"`
	// The IAM role to attach to the policy.
	Role pulumi.StringOutput `pulumi:"role"`
}

Provides an IAM role inline policy.

> **NOTE:** For a given role, this resource is incompatible with using the `iam.Role` resource `inlinePolicy` argument. When using that argument and this resource, both will attempt to manage the role's inline policies and the provider will show a permanent difference.

## Example Usage

```go package main

import ( 

"encoding/json"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": []map[string]interface{}{
				map[string]interface{}{
					"Action": "sts:AssumeRole",
					"Effect": "Allow",
					"Sid":    "",
					"Principal": map[string]interface{}{
						"Service": "ec2.amazonaws.com",
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		testRole, err := iam.NewRole(ctx, "testRole", &iam.RoleArgs{
			AssumeRolePolicy: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": []map[string]interface{}{
				map[string]interface{}{
					"Action": []string{
						"ec2:Describe*",
					},
					"Effect":   "Allow",
					"Resource": "*",
				},
			},
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		_, err = iam.NewRolePolicy(ctx, "testPolicy", &iam.RolePolicyArgs{
			Role:   testRole.ID(),
			Policy: pulumi.String(json1),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IAM Role Policies can be imported using the `role_name:role_policy_name`, e.g.

```sh 

$ pulumi import aws:iam/rolePolicy:RolePolicy mypolicy role_of_mypolicy_name:mypolicy_name

```

func GetRolePolicy 

func GetRolePolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RolePolicyState, opts ...pulumi.ResourceOption) (*RolePolicy, error)

GetRolePolicy gets an existing RolePolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewRolePolicy 

func NewRolePolicy(ctx *pulumi.Context,
	name string, args *RolePolicyArgs, opts ...pulumi.ResourceOption) (*RolePolicy, error)

NewRolePolicy registers a new resource with the given unique name, arguments, and options.

func (*RolePolicy) ElementType added in v3.13.0 

func (*RolePolicy) ElementType() reflect.Type

func (*RolePolicy) ToRolePolicyOutput added in v3.13.0 

func (i *RolePolicy) ToRolePolicyOutput() RolePolicyOutput

func (*RolePolicy) ToRolePolicyOutputWithContext added in v3.13.0 

func (i *RolePolicy) ToRolePolicyOutputWithContext(ctx context.Context) RolePolicyOutput

func (*RolePolicy) ToRolePolicyPtrOutput added in v3.25.0 

func (i *RolePolicy) ToRolePolicyPtrOutput() RolePolicyPtrOutput

func (*RolePolicy) ToRolePolicyPtrOutputWithContext added in v3.25.0 

func (i *RolePolicy) ToRolePolicyPtrOutputWithContext(ctx context.Context) RolePolicyPtrOutput

type RolePolicyArgs 

type RolePolicyArgs struct {
	// The name of the role policy. If omitted, this provider will
	// assign a random, unique name.
	Name pulumi.StringPtrInput
	// Creates a unique name beginning with the specified
	// prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrInput
	// The policy document. This is a JSON formatted string.
	Policy pulumi.Input
	// The IAM role to attach to the policy.
	Role pulumi.Input
}

The set of arguments for constructing a RolePolicy resource.

func (RolePolicyArgs) ElementType 

func (RolePolicyArgs) ElementType() reflect.Type

type RolePolicyArray added in v3.25.0 

type RolePolicyArray []RolePolicyInput

func (RolePolicyArray) ElementType added in v3.25.0 

func (RolePolicyArray) ElementType() reflect.Type

func (RolePolicyArray) ToRolePolicyArrayOutput added in v3.25.0 

func (i RolePolicyArray) ToRolePolicyArrayOutput() RolePolicyArrayOutput

func (RolePolicyArray) ToRolePolicyArrayOutputWithContext added in v3.25.0 

func (i RolePolicyArray) ToRolePolicyArrayOutputWithContext(ctx context.Context) RolePolicyArrayOutput

type RolePolicyArrayInput added in v3.25.0 

type RolePolicyArrayInput interface {
	pulumi.Input

	ToRolePolicyArrayOutput() RolePolicyArrayOutput
	ToRolePolicyArrayOutputWithContext(context.Context) RolePolicyArrayOutput
}

RolePolicyArrayInput is an input type that accepts RolePolicyArray and RolePolicyArrayOutput values. You can construct a concrete instance of `RolePolicyArrayInput` via: 

RolePolicyArray{ RolePolicyArgs{...} }

type RolePolicyArrayOutput added in v3.25.0 

type RolePolicyArrayOutput struct{ *pulumi.OutputState }

func (RolePolicyArrayOutput) ElementType added in v3.25.0 

func (RolePolicyArrayOutput) ElementType() reflect.Type

func (RolePolicyArrayOutput) Index added in v3.25.0 

func (o RolePolicyArrayOutput) Index(i pulumi.IntInput) RolePolicyOutput

func (RolePolicyArrayOutput) ToRolePolicyArrayOutput added in v3.25.0 

func (o RolePolicyArrayOutput) ToRolePolicyArrayOutput() RolePolicyArrayOutput

func (RolePolicyArrayOutput) ToRolePolicyArrayOutputWithContext added in v3.25.0 

func (o RolePolicyArrayOutput) ToRolePolicyArrayOutputWithContext(ctx context.Context) RolePolicyArrayOutput

type RolePolicyAttachment 

type RolePolicyAttachment struct {
	pulumi.CustomResourceState

	// The ARN of the policy you want to apply
	PolicyArn pulumi.StringOutput `pulumi:"policyArn"`
	// The name of the IAM role to which the policy should be applied
	Role pulumi.StringOutput `pulumi:"role"`
}

Attaches a Managed IAM Policy to an IAM role

> **NOTE:** The usage of this resource conflicts with the `iam.PolicyAttachment` resource and will permanently show a difference if both are defined.

> **NOTE:** For a given role, this resource is incompatible with using the `iam.Role` resource `managedPolicyArns` argument. When using that argument and this resource, both will attempt to manage the role's managed policy attachments and the provider will show a permanent difference.

## Example Usage

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		role, err := iam.NewRole(ctx, "role", &iam.RoleArgs{
			AssumeRolePolicy: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "  \"Version\": \"2012-10-17\",\n", "  \"Statement\": [\n", "    {\n", "      \"Action\": \"sts:AssumeRole\",\n", "      \"Principal\": {\n", "        \"Service\": \"ec2.amazonaws.com\"\n", "      },\n", "      \"Effect\": \"Allow\",\n", "      \"Sid\": \"\"\n", "    }\n", "  ]\n", "}\n")),
		})
		if err != nil {
			return err
		}
		policy, err := iam.NewPolicy(ctx, "policy", &iam.PolicyArgs{
			Description: pulumi.String("A test policy"),
			Policy:      pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "  \"Version\": \"2012-10-17\",\n", "  \"Statement\": [\n", "    {\n", "      \"Action\": [\n", "        \"ec2:Describe*\"\n", "      ],\n", "      \"Effect\": \"Allow\",\n", "      \"Resource\": \"*\"\n", "    }\n", "  ]\n", "}\n")),
		})
		if err != nil {
			return err
		}
		_, err = iam.NewRolePolicyAttachment(ctx, "test_attach", &iam.RolePolicyAttachmentArgs{
			Role:      role.Name,
			PolicyArn: policy.Arn,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IAM role policy attachments can be imported using the role name and policy arn separated by `/`.

```sh 

$ pulumi import aws:iam/rolePolicyAttachment:RolePolicyAttachment test-attach test-role/arn:aws:iam::xxxxxxxxxxxx:policy/test-policy

```

func GetRolePolicyAttachment 

func GetRolePolicyAttachment(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RolePolicyAttachmentState, opts ...pulumi.ResourceOption) (*RolePolicyAttachment, error)

GetRolePolicyAttachment gets an existing RolePolicyAttachment resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewRolePolicyAttachment 

func NewRolePolicyAttachment(ctx *pulumi.Context,
	name string, args *RolePolicyAttachmentArgs, opts ...pulumi.ResourceOption) (*RolePolicyAttachment, error)

NewRolePolicyAttachment registers a new resource with the given unique name, arguments, and options.

func (*RolePolicyAttachment) ElementType added in v3.13.0 

func (*RolePolicyAttachment) ElementType() reflect.Type

func (*RolePolicyAttachment) ToRolePolicyAttachmentOutput added in v3.13.0 

func (i *RolePolicyAttachment) ToRolePolicyAttachmentOutput() RolePolicyAttachmentOutput

func (*RolePolicyAttachment) ToRolePolicyAttachmentOutputWithContext added in v3.13.0 

func (i *RolePolicyAttachment) ToRolePolicyAttachmentOutputWithContext(ctx context.Context) RolePolicyAttachmentOutput

func (*RolePolicyAttachment) ToRolePolicyAttachmentPtrOutput added in v3.25.0 

func (i *RolePolicyAttachment) ToRolePolicyAttachmentPtrOutput() RolePolicyAttachmentPtrOutput

func (*RolePolicyAttachment) ToRolePolicyAttachmentPtrOutputWithContext added in v3.25.0 

func (i *RolePolicyAttachment) ToRolePolicyAttachmentPtrOutputWithContext(ctx context.Context) RolePolicyAttachmentPtrOutput

type RolePolicyAttachmentArgs 

type RolePolicyAttachmentArgs struct {
	// The ARN of the policy you want to apply
	PolicyArn pulumi.StringInput
	// The name of the IAM role to which the policy should be applied
	Role pulumi.Input
}

The set of arguments for constructing a RolePolicyAttachment resource.

func (RolePolicyAttachmentArgs) ElementType 

func (RolePolicyAttachmentArgs) ElementType() reflect.Type

type RolePolicyAttachmentArray added in v3.25.0 

type RolePolicyAttachmentArray []RolePolicyAttachmentInput

func (RolePolicyAttachmentArray) ElementType added in v3.25.0 

func (RolePolicyAttachmentArray) ElementType() reflect.Type

func (RolePolicyAttachmentArray) ToRolePolicyAttachmentArrayOutput added in v3.25.0 

func (i RolePolicyAttachmentArray) ToRolePolicyAttachmentArrayOutput() RolePolicyAttachmentArrayOutput

func (RolePolicyAttachmentArray) ToRolePolicyAttachmentArrayOutputWithContext added in v3.25.0 

func (i RolePolicyAttachmentArray) ToRolePolicyAttachmentArrayOutputWithContext(ctx context.Context) RolePolicyAttachmentArrayOutput

type RolePolicyAttachmentArrayInput added in v3.25.0 

type RolePolicyAttachmentArrayInput interface {
	pulumi.Input

	ToRolePolicyAttachmentArrayOutput() RolePolicyAttachmentArrayOutput
	ToRolePolicyAttachmentArrayOutputWithContext(context.Context) RolePolicyAttachmentArrayOutput
}

RolePolicyAttachmentArrayInput is an input type that accepts RolePolicyAttachmentArray and RolePolicyAttachmentArrayOutput values. You can construct a concrete instance of `RolePolicyAttachmentArrayInput` via: 

RolePolicyAttachmentArray{ RolePolicyAttachmentArgs{...} }

type RolePolicyAttachmentArrayOutput added in v3.25.0 

type RolePolicyAttachmentArrayOutput struct{ *pulumi.OutputState }

func (RolePolicyAttachmentArrayOutput) ElementType added in v3.25.0 

func (RolePolicyAttachmentArrayOutput) ElementType() reflect.Type

func (RolePolicyAttachmentArrayOutput) Index added in v3.25.0 

func (o RolePolicyAttachmentArrayOutput) Index(i pulumi.IntInput) RolePolicyAttachmentOutput

func (RolePolicyAttachmentArrayOutput) ToRolePolicyAttachmentArrayOutput added in v3.25.0 

func (o RolePolicyAttachmentArrayOutput) ToRolePolicyAttachmentArrayOutput() RolePolicyAttachmentArrayOutput

func (RolePolicyAttachmentArrayOutput) ToRolePolicyAttachmentArrayOutputWithContext added in v3.25.0 

func (o RolePolicyAttachmentArrayOutput) ToRolePolicyAttachmentArrayOutputWithContext(ctx context.Context) RolePolicyAttachmentArrayOutput

type RolePolicyAttachmentInput added in v3.13.0 

type RolePolicyAttachmentInput interface {
	pulumi.Input

	ToRolePolicyAttachmentOutput() RolePolicyAttachmentOutput
	ToRolePolicyAttachmentOutputWithContext(ctx context.Context) RolePolicyAttachmentOutput
}

type RolePolicyAttachmentMap added in v3.25.0 

type RolePolicyAttachmentMap map[string]RolePolicyAttachmentInput

func (RolePolicyAttachmentMap) ElementType added in v3.25.0 

func (RolePolicyAttachmentMap) ElementType() reflect.Type

func (RolePolicyAttachmentMap) ToRolePolicyAttachmentMapOutput added in v3.25.0 

func (i RolePolicyAttachmentMap) ToRolePolicyAttachmentMapOutput() RolePolicyAttachmentMapOutput

func (RolePolicyAttachmentMap) ToRolePolicyAttachmentMapOutputWithContext added in v3.25.0 

func (i RolePolicyAttachmentMap) ToRolePolicyAttachmentMapOutputWithContext(ctx context.Context) RolePolicyAttachmentMapOutput

type RolePolicyAttachmentMapInput added in v3.25.0 

type RolePolicyAttachmentMapInput interface {
	pulumi.Input

	ToRolePolicyAttachmentMapOutput() RolePolicyAttachmentMapOutput
	ToRolePolicyAttachmentMapOutputWithContext(context.Context) RolePolicyAttachmentMapOutput
}

RolePolicyAttachmentMapInput is an input type that accepts RolePolicyAttachmentMap and RolePolicyAttachmentMapOutput values. You can construct a concrete instance of `RolePolicyAttachmentMapInput` via: 

RolePolicyAttachmentMap{ "key": RolePolicyAttachmentArgs{...} }

type RolePolicyAttachmentMapOutput added in v3.25.0 

type RolePolicyAttachmentMapOutput struct{ *pulumi.OutputState }

func (RolePolicyAttachmentMapOutput) ElementType added in v3.25.0 

func (RolePolicyAttachmentMapOutput) ElementType() reflect.Type

func (RolePolicyAttachmentMapOutput) MapIndex added in v3.25.0 

func (o RolePolicyAttachmentMapOutput) MapIndex(k pulumi.StringInput) RolePolicyAttachmentOutput

func (RolePolicyAttachmentMapOutput) ToRolePolicyAttachmentMapOutput added in v3.25.0 

func (o RolePolicyAttachmentMapOutput) ToRolePolicyAttachmentMapOutput() RolePolicyAttachmentMapOutput

func (RolePolicyAttachmentMapOutput) ToRolePolicyAttachmentMapOutputWithContext added in v3.25.0 

func (o RolePolicyAttachmentMapOutput) ToRolePolicyAttachmentMapOutputWithContext(ctx context.Context) RolePolicyAttachmentMapOutput

type RolePolicyAttachmentOutput added in v3.13.0 

type RolePolicyAttachmentOutput struct {
	*pulumi.OutputState
}

func (RolePolicyAttachmentOutput) ElementType added in v3.13.0 

func (RolePolicyAttachmentOutput) ElementType() reflect.Type

func (RolePolicyAttachmentOutput) ToRolePolicyAttachmentOutput added in v3.13.0 

func (o RolePolicyAttachmentOutput) ToRolePolicyAttachmentOutput() RolePolicyAttachmentOutput

func (RolePolicyAttachmentOutput) ToRolePolicyAttachmentOutputWithContext added in v3.13.0 

func (o RolePolicyAttachmentOutput) ToRolePolicyAttachmentOutputWithContext(ctx context.Context) RolePolicyAttachmentOutput

func (RolePolicyAttachmentOutput) ToRolePolicyAttachmentPtrOutput added in v3.25.0 

func (o RolePolicyAttachmentOutput) ToRolePolicyAttachmentPtrOutput() RolePolicyAttachmentPtrOutput

func (RolePolicyAttachmentOutput) ToRolePolicyAttachmentPtrOutputWithContext added in v3.25.0 

func (o RolePolicyAttachmentOutput) ToRolePolicyAttachmentPtrOutputWithContext(ctx context.Context) RolePolicyAttachmentPtrOutput

type RolePolicyAttachmentPtrInput added in v3.25.0 

type RolePolicyAttachmentPtrInput interface {
	pulumi.Input

	ToRolePolicyAttachmentPtrOutput() RolePolicyAttachmentPtrOutput
	ToRolePolicyAttachmentPtrOutputWithContext(ctx context.Context) RolePolicyAttachmentPtrOutput
}

type RolePolicyAttachmentPtrOutput added in v3.25.0 

type RolePolicyAttachmentPtrOutput struct {
	*pulumi.OutputState
}

func (RolePolicyAttachmentPtrOutput) ElementType added in v3.25.0 

func (RolePolicyAttachmentPtrOutput) ElementType() reflect.Type

func (RolePolicyAttachmentPtrOutput) ToRolePolicyAttachmentPtrOutput added in v3.25.0 

func (o RolePolicyAttachmentPtrOutput) ToRolePolicyAttachmentPtrOutput() RolePolicyAttachmentPtrOutput

func (RolePolicyAttachmentPtrOutput) ToRolePolicyAttachmentPtrOutputWithContext added in v3.25.0 

func (o RolePolicyAttachmentPtrOutput) ToRolePolicyAttachmentPtrOutputWithContext(ctx context.Context) RolePolicyAttachmentPtrOutput

type RolePolicyAttachmentState 

type RolePolicyAttachmentState struct {
	// The ARN of the policy you want to apply
	PolicyArn pulumi.StringPtrInput
	// The name of the IAM role to which the policy should be applied
	Role pulumi.StringPtrInput
}

func (RolePolicyAttachmentState) ElementType 

func (RolePolicyAttachmentState) ElementType() reflect.Type

type RolePolicyInput added in v3.13.0 

type RolePolicyInput interface {
	pulumi.Input

	ToRolePolicyOutput() RolePolicyOutput
	ToRolePolicyOutputWithContext(ctx context.Context) RolePolicyOutput
}

type RolePolicyMap added in v3.25.0 

type RolePolicyMap map[string]RolePolicyInput

func (RolePolicyMap) ElementType added in v3.25.0 

func (RolePolicyMap) ElementType() reflect.Type

func (RolePolicyMap) ToRolePolicyMapOutput added in v3.25.0 

func (i RolePolicyMap) ToRolePolicyMapOutput() RolePolicyMapOutput

func (RolePolicyMap) ToRolePolicyMapOutputWithContext added in v3.25.0 

func (i RolePolicyMap) ToRolePolicyMapOutputWithContext(ctx context.Context) RolePolicyMapOutput

type RolePolicyMapInput added in v3.25.0 

type RolePolicyMapInput interface {
	pulumi.Input

	ToRolePolicyMapOutput() RolePolicyMapOutput
	ToRolePolicyMapOutputWithContext(context.Context) RolePolicyMapOutput
}

RolePolicyMapInput is an input type that accepts RolePolicyMap and RolePolicyMapOutput values. You can construct a concrete instance of `RolePolicyMapInput` via: 

RolePolicyMap{ "key": RolePolicyArgs{...} }

type RolePolicyMapOutput added in v3.25.0 

type RolePolicyMapOutput struct{ *pulumi.OutputState }

func (RolePolicyMapOutput) ElementType added in v3.25.0 

func (RolePolicyMapOutput) ElementType() reflect.Type

func (RolePolicyMapOutput) MapIndex added in v3.25.0 

func (o RolePolicyMapOutput) MapIndex(k pulumi.StringInput) RolePolicyOutput

func (RolePolicyMapOutput) ToRolePolicyMapOutput added in v3.25.0 

func (o RolePolicyMapOutput) ToRolePolicyMapOutput() RolePolicyMapOutput

func (RolePolicyMapOutput) ToRolePolicyMapOutputWithContext added in v3.25.0 

func (o RolePolicyMapOutput) ToRolePolicyMapOutputWithContext(ctx context.Context) RolePolicyMapOutput

type RolePolicyOutput added in v3.13.0 

type RolePolicyOutput struct {
	*pulumi.OutputState
}

func (RolePolicyOutput) ElementType added in v3.13.0 

func (RolePolicyOutput) ElementType() reflect.Type

func (RolePolicyOutput) ToRolePolicyOutput added in v3.13.0 

func (o RolePolicyOutput) ToRolePolicyOutput() RolePolicyOutput

func (RolePolicyOutput) ToRolePolicyOutputWithContext added in v3.13.0 

func (o RolePolicyOutput) ToRolePolicyOutputWithContext(ctx context.Context) RolePolicyOutput

func (RolePolicyOutput) ToRolePolicyPtrOutput added in v3.25.0 

func (o RolePolicyOutput) ToRolePolicyPtrOutput() RolePolicyPtrOutput

func (RolePolicyOutput) ToRolePolicyPtrOutputWithContext added in v3.25.0 

func (o RolePolicyOutput) ToRolePolicyPtrOutputWithContext(ctx context.Context) RolePolicyPtrOutput

type RolePolicyPtrInput added in v3.25.0 

type RolePolicyPtrInput interface {
	pulumi.Input

	ToRolePolicyPtrOutput() RolePolicyPtrOutput
	ToRolePolicyPtrOutputWithContext(ctx context.Context) RolePolicyPtrOutput
}

type RolePolicyPtrOutput added in v3.25.0 

type RolePolicyPtrOutput struct {
	*pulumi.OutputState
}

func (RolePolicyPtrOutput) ElementType added in v3.25.0 

func (RolePolicyPtrOutput) ElementType() reflect.Type

func (RolePolicyPtrOutput) ToRolePolicyPtrOutput added in v3.25.0 

func (o RolePolicyPtrOutput) ToRolePolicyPtrOutput() RolePolicyPtrOutput

func (RolePolicyPtrOutput) ToRolePolicyPtrOutputWithContext added in v3.25.0 

func (o RolePolicyPtrOutput) ToRolePolicyPtrOutputWithContext(ctx context.Context) RolePolicyPtrOutput

type RolePolicyState 

type RolePolicyState struct {
	// The name of the role policy. If omitted, this provider will
	// assign a random, unique name.
	Name pulumi.StringPtrInput
	// Creates a unique name beginning with the specified
	// prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrInput
	// The policy document. This is a JSON formatted string.
	Policy pulumi.StringPtrInput
	// The IAM role to attach to the policy.
	Role pulumi.StringPtrInput
}

func (RolePolicyState) ElementType 

func (RolePolicyState) ElementType() reflect.Type

type RolePtrInput added in v3.25.0 

type RolePtrInput interface {
	pulumi.Input

	ToRolePtrOutput() RolePtrOutput
	ToRolePtrOutputWithContext(ctx context.Context) RolePtrOutput
}

type RolePtrOutput added in v3.25.0 

type RolePtrOutput struct {
	*pulumi.OutputState
}

func (RolePtrOutput) ElementType added in v3.25.0 

func (RolePtrOutput) ElementType() reflect.Type

func (RolePtrOutput) ToRolePtrOutput added in v3.25.0 

func (o RolePtrOutput) ToRolePtrOutput() RolePtrOutput

func (RolePtrOutput) ToRolePtrOutputWithContext added in v3.25.0 

func (o RolePtrOutput) ToRolePtrOutputWithContext(ctx context.Context) RolePtrOutput

type RoleState 

type RoleState struct {
	// Amazon Resource Name (ARN) specifying the role.
	Arn pulumi.StringPtrInput
	// Policy that grants an entity permission to assume the role.
	AssumeRolePolicy pulumi.StringPtrInput
	// Creation date of the IAM role.
	CreateDate pulumi.StringPtrInput
	// Description of the role.
	Description pulumi.StringPtrInput
	// Whether to force detaching any policies the role has before destroying it. Defaults to `false`.
	ForceDetachPolicies pulumi.BoolPtrInput
	// Configuration block defining an exclusive set of IAM inline policies associated with the IAM role. Defined below. If no blocks are configured, the provider will ignore any managing any inline policies in this resource. Configuring one empty block (i.e., `inlinePolicy {}`) will cause the provider to remove _all_ inline policies.
	InlinePolicies RoleInlinePolicyArrayInput
	// Set of exclusive IAM managed policy ARNs to attach to the IAM role. If this attribute is not configured, the provider will ignore policy attachments to this resource. When configured, the provider will align the role's managed policy attachments with this set by attaching or detaching managed policies. Configuring an empty set (i.e., `managedPolicyArns = []`) will cause the provider to remove _all_ managed policy attachments.
	ManagedPolicyArns pulumi.StringArrayInput
	// Maximum session duration (in seconds) that you want to set for the specified role. If you do not specify a value for this setting, the default maximum of one hour is applied. This setting can have a value from 1 hour to 12 hours.
	MaxSessionDuration pulumi.IntPtrInput
	// Name of the role policy.
	Name pulumi.StringPtrInput
	// Creates a unique friendly name beginning with the specified prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrInput
	// Path to the role. See [IAM Identifiers](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html) for more information.
	Path pulumi.StringPtrInput
	// ARN of the policy that is used to set the permissions boundary for the role.
	PermissionsBoundary pulumi.StringPtrInput
	// Key-value mapping of tags for the IAM role
	Tags pulumi.StringMapInput
	// Stable and unique string identifying the role.
	UniqueId pulumi.StringPtrInput
}

func (RoleState) ElementType 

func (RoleState) ElementType() reflect.Type

type SamlProvider 

type SamlProvider struct {
	pulumi.CustomResourceState

	// The ARN assigned by AWS for this provider.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The name of the provider to create.
	Name pulumi.StringOutput `pulumi:"name"`
	// An XML document generated by an identity provider that supports SAML 2.0.
	SamlMetadataDocument pulumi.StringOutput `pulumi:"samlMetadataDocument"`
	// Map of resource tags for the IAM SAML provider.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// The expiration date and time for the SAML provider in RFC1123 format, e.g. `Mon, 02 Jan 2006 15:04:05 MST`.
	ValidUntil pulumi.StringOutput `pulumi:"validUntil"`
}

Provides an IAM SAML provider.

## Import

IAM SAML Providers can be imported using the `arn`, e.g.

```sh 

$ pulumi import aws:iam/samlProvider:SamlProvider default arn:aws:iam::123456789012:saml-provider/SAMLADFS

```

func GetSamlProvider 

func GetSamlProvider(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *SamlProviderState, opts ...pulumi.ResourceOption) (*SamlProvider, error)

GetSamlProvider gets an existing SamlProvider resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewSamlProvider 

func NewSamlProvider(ctx *pulumi.Context,
	name string, args *SamlProviderArgs, opts ...pulumi.ResourceOption) (*SamlProvider, error)

NewSamlProvider registers a new resource with the given unique name, arguments, and options.

func (*SamlProvider) ElementType added in v3.13.0 

func (*SamlProvider) ElementType() reflect.Type

func (*SamlProvider) ToSamlProviderOutput added in v3.13.0 

func (i *SamlProvider) ToSamlProviderOutput() SamlProviderOutput

func (*SamlProvider) ToSamlProviderOutputWithContext added in v3.13.0 

func (i *SamlProvider) ToSamlProviderOutputWithContext(ctx context.Context) SamlProviderOutput

func (*SamlProvider) ToSamlProviderPtrOutput added in v3.25.0 

func (i *SamlProvider) ToSamlProviderPtrOutput() SamlProviderPtrOutput

func (*SamlProvider) ToSamlProviderPtrOutputWithContext added in v3.25.0 

func (i *SamlProvider) ToSamlProviderPtrOutputWithContext(ctx context.Context) SamlProviderPtrOutput

type SamlProviderArgs 

type SamlProviderArgs struct {
	// The name of the provider to create.
	Name pulumi.StringPtrInput
	// An XML document generated by an identity provider that supports SAML 2.0.
	SamlMetadataDocument pulumi.StringInput
	// Map of resource tags for the IAM SAML provider.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a SamlProvider resource.

func (SamlProviderArgs) ElementType 

func (SamlProviderArgs) ElementType() reflect.Type

type SamlProviderArray added in v3.25.0 

type SamlProviderArray []SamlProviderInput

func (SamlProviderArray) ElementType added in v3.25.0 

func (SamlProviderArray) ElementType() reflect.Type

func (SamlProviderArray) ToSamlProviderArrayOutput added in v3.25.0 

func (i SamlProviderArray) ToSamlProviderArrayOutput() SamlProviderArrayOutput

func (SamlProviderArray) ToSamlProviderArrayOutputWithContext added in v3.25.0 

func (i SamlProviderArray) ToSamlProviderArrayOutputWithContext(ctx context.Context) SamlProviderArrayOutput

type SamlProviderArrayInput added in v3.25.0 

type SamlProviderArrayInput interface {
	pulumi.Input

	ToSamlProviderArrayOutput() SamlProviderArrayOutput
	ToSamlProviderArrayOutputWithContext(context.Context) SamlProviderArrayOutput
}

SamlProviderArrayInput is an input type that accepts SamlProviderArray and SamlProviderArrayOutput values. You can construct a concrete instance of `SamlProviderArrayInput` via: 

SamlProviderArray{ SamlProviderArgs{...} }

type SamlProviderArrayOutput added in v3.25.0 

type SamlProviderArrayOutput struct{ *pulumi.OutputState }

func (SamlProviderArrayOutput) ElementType added in v3.25.0 

func (SamlProviderArrayOutput) ElementType() reflect.Type

func (SamlProviderArrayOutput) Index added in v3.25.0 

func (o SamlProviderArrayOutput) Index(i pulumi.IntInput) SamlProviderOutput

func (SamlProviderArrayOutput) ToSamlProviderArrayOutput added in v3.25.0 

func (o SamlProviderArrayOutput) ToSamlProviderArrayOutput() SamlProviderArrayOutput

func (SamlProviderArrayOutput) ToSamlProviderArrayOutputWithContext added in v3.25.0 

func (o SamlProviderArrayOutput) ToSamlProviderArrayOutputWithContext(ctx context.Context) SamlProviderArrayOutput

type SamlProviderInput added in v3.13.0 

type SamlProviderInput interface {
	pulumi.Input

	ToSamlProviderOutput() SamlProviderOutput
	ToSamlProviderOutputWithContext(ctx context.Context) SamlProviderOutput
}

type SamlProviderMap added in v3.25.0 

type SamlProviderMap map[string]SamlProviderInput

func (SamlProviderMap) ElementType added in v3.25.0 

func (SamlProviderMap) ElementType() reflect.Type

func (SamlProviderMap) ToSamlProviderMapOutput added in v3.25.0 

func (i SamlProviderMap) ToSamlProviderMapOutput() SamlProviderMapOutput

func (SamlProviderMap) ToSamlProviderMapOutputWithContext added in v3.25.0 

func (i SamlProviderMap) ToSamlProviderMapOutputWithContext(ctx context.Context) SamlProviderMapOutput

type SamlProviderMapInput added in v3.25.0 

type SamlProviderMapInput interface {
	pulumi.Input

	ToSamlProviderMapOutput() SamlProviderMapOutput
	ToSamlProviderMapOutputWithContext(context.Context) SamlProviderMapOutput
}

SamlProviderMapInput is an input type that accepts SamlProviderMap and SamlProviderMapOutput values. You can construct a concrete instance of `SamlProviderMapInput` via: 

SamlProviderMap{ "key": SamlProviderArgs{...} }

type SamlProviderMapOutput added in v3.25.0 

type SamlProviderMapOutput struct{ *pulumi.OutputState }

func (SamlProviderMapOutput) ElementType added in v3.25.0 

func (SamlProviderMapOutput) ElementType() reflect.Type

func (SamlProviderMapOutput) MapIndex added in v3.25.0 

func (o SamlProviderMapOutput) MapIndex(k pulumi.StringInput) SamlProviderOutput

func (SamlProviderMapOutput) ToSamlProviderMapOutput added in v3.25.0 

func (o SamlProviderMapOutput) ToSamlProviderMapOutput() SamlProviderMapOutput

func (SamlProviderMapOutput) ToSamlProviderMapOutputWithContext added in v3.25.0 

func (o SamlProviderMapOutput) ToSamlProviderMapOutputWithContext(ctx context.Context) SamlProviderMapOutput

type SamlProviderOutput added in v3.13.0 

type SamlProviderOutput struct {
	*pulumi.OutputState
}

func (SamlProviderOutput) ElementType added in v3.13.0 

func (SamlProviderOutput) ElementType() reflect.Type

func (SamlProviderOutput) ToSamlProviderOutput added in v3.13.0 

func (o SamlProviderOutput) ToSamlProviderOutput() SamlProviderOutput

func (SamlProviderOutput) ToSamlProviderOutputWithContext added in v3.13.0 

func (o SamlProviderOutput) ToSamlProviderOutputWithContext(ctx context.Context) SamlProviderOutput

func (SamlProviderOutput) ToSamlProviderPtrOutput added in v3.25.0 

func (o SamlProviderOutput) ToSamlProviderPtrOutput() SamlProviderPtrOutput

func (SamlProviderOutput) ToSamlProviderPtrOutputWithContext added in v3.25.0 

func (o SamlProviderOutput) ToSamlProviderPtrOutputWithContext(ctx context.Context) SamlProviderPtrOutput

type SamlProviderPtrInput added in v3.25.0 

type SamlProviderPtrInput interface {
	pulumi.Input

	ToSamlProviderPtrOutput() SamlProviderPtrOutput
	ToSamlProviderPtrOutputWithContext(ctx context.Context) SamlProviderPtrOutput
}

type SamlProviderPtrOutput added in v3.25.0 

type SamlProviderPtrOutput struct {
	*pulumi.OutputState
}

func (SamlProviderPtrOutput) ElementType added in v3.25.0 

func (SamlProviderPtrOutput) ElementType() reflect.Type

func (SamlProviderPtrOutput) ToSamlProviderPtrOutput added in v3.25.0 

func (o SamlProviderPtrOutput) ToSamlProviderPtrOutput() SamlProviderPtrOutput

func (SamlProviderPtrOutput) ToSamlProviderPtrOutputWithContext added in v3.25.0 

func (o SamlProviderPtrOutput) ToSamlProviderPtrOutputWithContext(ctx context.Context) SamlProviderPtrOutput

type SamlProviderState 

type SamlProviderState struct {
	// The ARN assigned by AWS for this provider.
	Arn pulumi.StringPtrInput
	// The name of the provider to create.
	Name pulumi.StringPtrInput
	// An XML document generated by an identity provider that supports SAML 2.0.
	SamlMetadataDocument pulumi.StringPtrInput
	// Map of resource tags for the IAM SAML provider.
	Tags pulumi.StringMapInput
	// The expiration date and time for the SAML provider in RFC1123 format, e.g. `Mon, 02 Jan 2006 15:04:05 MST`.
	ValidUntil pulumi.StringPtrInput
}

func (SamlProviderState) ElementType 

func (SamlProviderState) ElementType() reflect.Type

type ServerCertificate 

type ServerCertificate struct {
	pulumi.CustomResourceState

	// The Amazon Resource Name (ARN) specifying the server certificate.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The contents of the public key certificate in
	// PEM-encoded format.
	CertificateBody pulumi.StringOutput `pulumi:"certificateBody"`
	// The contents of the certificate chain.
	// This is typically a concatenation of the PEM-encoded public key certificates
	// of the chain.
	CertificateChain pulumi.StringPtrOutput `pulumi:"certificateChain"`
	// Date and time in [RFC3339 format](https://tools.ietf.org/html/rfc3339#section-5.8) on which the certificate is set to expire.
	Expiration pulumi.StringOutput `pulumi:"expiration"`
	// The name of the Server Certificate. Do not include the
	// path in this value. If omitted, this provider will assign a random, unique name.
	Name pulumi.StringOutput `pulumi:"name"`
	// Creates a unique name beginning with the specified
	// prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrOutput `pulumi:"namePrefix"`
	// The IAM path for the server certificate.  If it is not
	// included, it defaults to a slash (/). If this certificate is for use with
	// AWS CloudFront, the path must be in format `/cloudfront/your_path_here`.
	// See [IAM Identifiers](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html) for more details on IAM Paths.
	Path pulumi.StringPtrOutput `pulumi:"path"`
	// The contents of the private key in PEM-encoded format.
	PrivateKey pulumi.StringOutput `pulumi:"privateKey"`
	// Map of resource tags for the server certificate.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// Date and time in [RFC3339 format](https://tools.ietf.org/html/rfc3339#section-5.8) when the server certificate was uploaded.
	UploadDate pulumi.StringOutput `pulumi:"uploadDate"`
}

Provides an IAM Server Certificate resource to upload Server Certificates. Certs uploaded to IAM can easily work with other AWS services such as:

- AWS Elastic Beanstalk - Elastic Load Balancing - CloudFront - AWS OpsWorks

For information about server certificates in IAM, see [Managing Server Certificates][2] in AWS Documentation.

## Import

IAM Server Certificates can be imported using the `name`, e.g.

```sh 

$ pulumi import aws:iam/serverCertificate:ServerCertificate certificate example.com-certificate-until-2018

``` 

[1]https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html [2]https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingServerCerts.html [lifecycle]/docs/configuration/resources.html

func GetServerCertificate 

func GetServerCertificate(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ServerCertificateState, opts ...pulumi.ResourceOption) (*ServerCertificate, error)

GetServerCertificate gets an existing ServerCertificate resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewServerCertificate 

func NewServerCertificate(ctx *pulumi.Context,
	name string, args *ServerCertificateArgs, opts ...pulumi.ResourceOption) (*ServerCertificate, error)

NewServerCertificate registers a new resource with the given unique name, arguments, and options.

func (*ServerCertificate) ElementType added in v3.13.0 

func (*ServerCertificate) ElementType() reflect.Type

func (*ServerCertificate) ToServerCertificateOutput added in v3.13.0 

func (i *ServerCertificate) ToServerCertificateOutput() ServerCertificateOutput

func (*ServerCertificate) ToServerCertificateOutputWithContext added in v3.13.0 

func (i *ServerCertificate) ToServerCertificateOutputWithContext(ctx context.Context) ServerCertificateOutput

func (*ServerCertificate) ToServerCertificatePtrOutput added in v3.25.0 

func (i *ServerCertificate) ToServerCertificatePtrOutput() ServerCertificatePtrOutput

func (*ServerCertificate) ToServerCertificatePtrOutputWithContext added in v3.25.0 

func (i *ServerCertificate) ToServerCertificatePtrOutputWithContext(ctx context.Context) ServerCertificatePtrOutput

type ServerCertificateArgs 

type ServerCertificateArgs struct {
	// The contents of the public key certificate in
	// PEM-encoded format.
	CertificateBody pulumi.StringInput
	// The contents of the certificate chain.
	// This is typically a concatenation of the PEM-encoded public key certificates
	// of the chain.
	CertificateChain pulumi.StringPtrInput
	// The name of the Server Certificate. Do not include the
	// path in this value. If omitted, this provider will assign a random, unique name.
	Name pulumi.StringPtrInput
	// Creates a unique name beginning with the specified
	// prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrInput
	// The IAM path for the server certificate.  If it is not
	// included, it defaults to a slash (/). If this certificate is for use with
	// AWS CloudFront, the path must be in format `/cloudfront/your_path_here`.
	// See [IAM Identifiers](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html) for more details on IAM Paths.
	Path pulumi.StringPtrInput
	// The contents of the private key in PEM-encoded format.
	PrivateKey pulumi.StringInput
	// Map of resource tags for the server certificate.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a ServerCertificate resource.

func (ServerCertificateArgs) ElementType 

func (ServerCertificateArgs) ElementType() reflect.Type

type ServerCertificateArray added in v3.25.0 

type ServerCertificateArray []ServerCertificateInput

func (ServerCertificateArray) ElementType added in v3.25.0 

func (ServerCertificateArray) ElementType() reflect.Type

func (ServerCertificateArray) ToServerCertificateArrayOutput added in v3.25.0 

func (i ServerCertificateArray) ToServerCertificateArrayOutput() ServerCertificateArrayOutput

func (ServerCertificateArray) ToServerCertificateArrayOutputWithContext added in v3.25.0 

func (i ServerCertificateArray) ToServerCertificateArrayOutputWithContext(ctx context.Context) ServerCertificateArrayOutput

type ServerCertificateArrayInput added in v3.25.0 

type ServerCertificateArrayInput interface {
	pulumi.Input

	ToServerCertificateArrayOutput() ServerCertificateArrayOutput
	ToServerCertificateArrayOutputWithContext(context.Context) ServerCertificateArrayOutput
}

ServerCertificateArrayInput is an input type that accepts ServerCertificateArray and ServerCertificateArrayOutput values. You can construct a concrete instance of `ServerCertificateArrayInput` via: 

ServerCertificateArray{ ServerCertificateArgs{...} }

type ServerCertificateArrayOutput added in v3.25.0 

type ServerCertificateArrayOutput struct{ *pulumi.OutputState }

func (ServerCertificateArrayOutput) ElementType added in v3.25.0 

func (ServerCertificateArrayOutput) ElementType() reflect.Type

func (ServerCertificateArrayOutput) Index added in v3.25.0 

func (o ServerCertificateArrayOutput) Index(i pulumi.IntInput) ServerCertificateOutput

func (ServerCertificateArrayOutput) ToServerCertificateArrayOutput added in v3.25.0 

func (o ServerCertificateArrayOutput) ToServerCertificateArrayOutput() ServerCertificateArrayOutput

func (ServerCertificateArrayOutput) ToServerCertificateArrayOutputWithContext added in v3.25.0 

func (o ServerCertificateArrayOutput) ToServerCertificateArrayOutputWithContext(ctx context.Context) ServerCertificateArrayOutput

type ServerCertificateInput added in v3.13.0 

type ServerCertificateInput interface {
	pulumi.Input

	ToServerCertificateOutput() ServerCertificateOutput
	ToServerCertificateOutputWithContext(ctx context.Context) ServerCertificateOutput
}

type ServerCertificateMap added in v3.25.0 

type ServerCertificateMap map[string]ServerCertificateInput

func (ServerCertificateMap) ElementType added in v3.25.0 

func (ServerCertificateMap) ElementType() reflect.Type

func (ServerCertificateMap) ToServerCertificateMapOutput added in v3.25.0 

func (i ServerCertificateMap) ToServerCertificateMapOutput() ServerCertificateMapOutput

func (ServerCertificateMap) ToServerCertificateMapOutputWithContext added in v3.25.0 

func (i ServerCertificateMap) ToServerCertificateMapOutputWithContext(ctx context.Context) ServerCertificateMapOutput

type ServerCertificateMapInput added in v3.25.0 

type ServerCertificateMapInput interface {
	pulumi.Input

	ToServerCertificateMapOutput() ServerCertificateMapOutput
	ToServerCertificateMapOutputWithContext(context.Context) ServerCertificateMapOutput
}

ServerCertificateMapInput is an input type that accepts ServerCertificateMap and ServerCertificateMapOutput values. You can construct a concrete instance of `ServerCertificateMapInput` via: 

ServerCertificateMap{ "key": ServerCertificateArgs{...} }

type ServerCertificateMapOutput added in v3.25.0 

type ServerCertificateMapOutput struct{ *pulumi.OutputState }

func (ServerCertificateMapOutput) ElementType added in v3.25.0 

func (ServerCertificateMapOutput) ElementType() reflect.Type

func (ServerCertificateMapOutput) MapIndex added in v3.25.0 

func (o ServerCertificateMapOutput) MapIndex(k pulumi.StringInput) ServerCertificateOutput

func (ServerCertificateMapOutput) ToServerCertificateMapOutput added in v3.25.0 

func (o ServerCertificateMapOutput) ToServerCertificateMapOutput() ServerCertificateMapOutput

func (ServerCertificateMapOutput) ToServerCertificateMapOutputWithContext added in v3.25.0 

func (o ServerCertificateMapOutput) ToServerCertificateMapOutputWithContext(ctx context.Context) ServerCertificateMapOutput

type ServerCertificateOutput added in v3.13.0 

type ServerCertificateOutput struct {
	*pulumi.OutputState
}

func (ServerCertificateOutput) ElementType added in v3.13.0 

func (ServerCertificateOutput) ElementType() reflect.Type

func (ServerCertificateOutput) ToServerCertificateOutput added in v3.13.0 

func (o ServerCertificateOutput) ToServerCertificateOutput() ServerCertificateOutput

func (ServerCertificateOutput) ToServerCertificateOutputWithContext added in v3.13.0 

func (o ServerCertificateOutput) ToServerCertificateOutputWithContext(ctx context.Context) ServerCertificateOutput

func (ServerCertificateOutput) ToServerCertificatePtrOutput added in v3.25.0 

func (o ServerCertificateOutput) ToServerCertificatePtrOutput() ServerCertificatePtrOutput

func (ServerCertificateOutput) ToServerCertificatePtrOutputWithContext added in v3.25.0 

func (o ServerCertificateOutput) ToServerCertificatePtrOutputWithContext(ctx context.Context) ServerCertificatePtrOutput

type ServerCertificatePtrInput added in v3.25.0 

type ServerCertificatePtrInput interface {
	pulumi.Input

	ToServerCertificatePtrOutput() ServerCertificatePtrOutput
	ToServerCertificatePtrOutputWithContext(ctx context.Context) ServerCertificatePtrOutput
}

type ServerCertificatePtrOutput added in v3.25.0 

type ServerCertificatePtrOutput struct {
	*pulumi.OutputState
}

func (ServerCertificatePtrOutput) ElementType added in v3.25.0 

func (ServerCertificatePtrOutput) ElementType() reflect.Type

func (ServerCertificatePtrOutput) ToServerCertificatePtrOutput added in v3.25.0 

func (o ServerCertificatePtrOutput) ToServerCertificatePtrOutput() ServerCertificatePtrOutput

func (ServerCertificatePtrOutput) ToServerCertificatePtrOutputWithContext added in v3.25.0 

func (o ServerCertificatePtrOutput) ToServerCertificatePtrOutputWithContext(ctx context.Context) ServerCertificatePtrOutput

type ServerCertificateState 

type ServerCertificateState struct {
	// The Amazon Resource Name (ARN) specifying the server certificate.
	Arn pulumi.StringPtrInput
	// The contents of the public key certificate in
	// PEM-encoded format.
	CertificateBody pulumi.StringPtrInput
	// The contents of the certificate chain.
	// This is typically a concatenation of the PEM-encoded public key certificates
	// of the chain.
	CertificateChain pulumi.StringPtrInput
	// Date and time in [RFC3339 format](https://tools.ietf.org/html/rfc3339#section-5.8) on which the certificate is set to expire.
	Expiration pulumi.StringPtrInput
	// The name of the Server Certificate. Do not include the
	// path in this value. If omitted, this provider will assign a random, unique name.
	Name pulumi.StringPtrInput
	// Creates a unique name beginning with the specified
	// prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrInput
	// The IAM path for the server certificate.  If it is not
	// included, it defaults to a slash (/). If this certificate is for use with
	// AWS CloudFront, the path must be in format `/cloudfront/your_path_here`.
	// See [IAM Identifiers](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html) for more details on IAM Paths.
	Path pulumi.StringPtrInput
	// The contents of the private key in PEM-encoded format.
	PrivateKey pulumi.StringPtrInput
	// Map of resource tags for the server certificate.
	Tags pulumi.StringMapInput
	// Date and time in [RFC3339 format](https://tools.ietf.org/html/rfc3339#section-5.8) when the server certificate was uploaded.
	UploadDate pulumi.StringPtrInput
}

func (ServerCertificateState) ElementType 

func (ServerCertificateState) ElementType() reflect.Type

type ServiceLinkedRole 

type ServiceLinkedRole struct {
	pulumi.CustomResourceState

	// The Amazon Resource Name (ARN) specifying the role.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The AWS service to which this role is attached. You use a string similar to a URL but without the `http://` in front. For example: `elasticbeanstalk.amazonaws.com`. To find the full list of services that support service-linked roles, check [the docs](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html).
	AwsServiceName pulumi.StringOutput `pulumi:"awsServiceName"`
	// The creation date of the IAM role.
	CreateDate pulumi.StringOutput `pulumi:"createDate"`
	// Additional string appended to the role name. Not all AWS services support custom suffixes.
	CustomSuffix pulumi.StringPtrOutput `pulumi:"customSuffix"`
	// The description of the role.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// The name of the role.
	Name pulumi.StringOutput `pulumi:"name"`
	// The path of the role.
	Path pulumi.StringOutput `pulumi:"path"`
	// The stable and unique string identifying the role.
	UniqueId pulumi.StringOutput `pulumi:"uniqueId"`
}

Provides an [IAM service-linked role](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html).

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := iam.NewServiceLinkedRole(ctx, "elasticbeanstalk", &iam.ServiceLinkedRoleArgs{
			AwsServiceName: pulumi.String("elasticbeanstalk.amazonaws.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IAM service-linked roles can be imported using role ARN, e.g.

```sh 

$ pulumi import aws:iam/serviceLinkedRole:ServiceLinkedRole elasticbeanstalk arn:aws:iam::123456789012:role/aws-service-role/elasticbeanstalk.amazonaws.com/AWSServiceRoleForElasticBeanstalk

```

func GetServiceLinkedRole 

func GetServiceLinkedRole(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ServiceLinkedRoleState, opts ...pulumi.ResourceOption) (*ServiceLinkedRole, error)

GetServiceLinkedRole gets an existing ServiceLinkedRole resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewServiceLinkedRole 

func NewServiceLinkedRole(ctx *pulumi.Context,
	name string, args *ServiceLinkedRoleArgs, opts ...pulumi.ResourceOption) (*ServiceLinkedRole, error)

NewServiceLinkedRole registers a new resource with the given unique name, arguments, and options.

func (*ServiceLinkedRole) ElementType added in v3.13.0 

func (*ServiceLinkedRole) ElementType() reflect.Type

func (*ServiceLinkedRole) ToServiceLinkedRoleOutput added in v3.13.0 

func (i *ServiceLinkedRole) ToServiceLinkedRoleOutput() ServiceLinkedRoleOutput

func (*ServiceLinkedRole) ToServiceLinkedRoleOutputWithContext added in v3.13.0 

func (i *ServiceLinkedRole) ToServiceLinkedRoleOutputWithContext(ctx context.Context) ServiceLinkedRoleOutput

func (*ServiceLinkedRole) ToServiceLinkedRolePtrOutput added in v3.25.0 

func (i *ServiceLinkedRole) ToServiceLinkedRolePtrOutput() ServiceLinkedRolePtrOutput

func (*ServiceLinkedRole) ToServiceLinkedRolePtrOutputWithContext added in v3.25.0 

func (i *ServiceLinkedRole) ToServiceLinkedRolePtrOutputWithContext(ctx context.Context) ServiceLinkedRolePtrOutput

type ServiceLinkedRoleArgs 

type ServiceLinkedRoleArgs struct {
	// The AWS service to which this role is attached. You use a string similar to a URL but without the `http://` in front. For example: `elasticbeanstalk.amazonaws.com`. To find the full list of services that support service-linked roles, check [the docs](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html).
	AwsServiceName pulumi.StringInput
	// Additional string appended to the role name. Not all AWS services support custom suffixes.
	CustomSuffix pulumi.StringPtrInput
	// The description of the role.
	Description pulumi.StringPtrInput
}

The set of arguments for constructing a ServiceLinkedRole resource.

func (ServiceLinkedRoleArgs) ElementType 

func (ServiceLinkedRoleArgs) ElementType() reflect.Type

type ServiceLinkedRoleArray added in v3.25.0 

type ServiceLinkedRoleArray []ServiceLinkedRoleInput

func (ServiceLinkedRoleArray) ElementType added in v3.25.0 

func (ServiceLinkedRoleArray) ElementType() reflect.Type

func (ServiceLinkedRoleArray) ToServiceLinkedRoleArrayOutput added in v3.25.0 

func (i ServiceLinkedRoleArray) ToServiceLinkedRoleArrayOutput() ServiceLinkedRoleArrayOutput

func (ServiceLinkedRoleArray) ToServiceLinkedRoleArrayOutputWithContext added in v3.25.0 

func (i ServiceLinkedRoleArray) ToServiceLinkedRoleArrayOutputWithContext(ctx context.Context) ServiceLinkedRoleArrayOutput

type ServiceLinkedRoleArrayInput added in v3.25.0 

type ServiceLinkedRoleArrayInput interface {
	pulumi.Input

	ToServiceLinkedRoleArrayOutput() ServiceLinkedRoleArrayOutput
	ToServiceLinkedRoleArrayOutputWithContext(context.Context) ServiceLinkedRoleArrayOutput
}

ServiceLinkedRoleArrayInput is an input type that accepts ServiceLinkedRoleArray and ServiceLinkedRoleArrayOutput values. You can construct a concrete instance of `ServiceLinkedRoleArrayInput` via: 

ServiceLinkedRoleArray{ ServiceLinkedRoleArgs{...} }

type ServiceLinkedRoleArrayOutput added in v3.25.0 

type ServiceLinkedRoleArrayOutput struct{ *pulumi.OutputState }

func (ServiceLinkedRoleArrayOutput) ElementType added in v3.25.0 

func (ServiceLinkedRoleArrayOutput) ElementType() reflect.Type

func (ServiceLinkedRoleArrayOutput) Index added in v3.25.0 

func (o ServiceLinkedRoleArrayOutput) Index(i pulumi.IntInput) ServiceLinkedRoleOutput

func (ServiceLinkedRoleArrayOutput) ToServiceLinkedRoleArrayOutput added in v3.25.0 

func (o ServiceLinkedRoleArrayOutput) ToServiceLinkedRoleArrayOutput() ServiceLinkedRoleArrayOutput

func (ServiceLinkedRoleArrayOutput) ToServiceLinkedRoleArrayOutputWithContext added in v3.25.0 

func (o ServiceLinkedRoleArrayOutput) ToServiceLinkedRoleArrayOutputWithContext(ctx context.Context) ServiceLinkedRoleArrayOutput

type ServiceLinkedRoleInput added in v3.13.0 

type ServiceLinkedRoleInput interface {
	pulumi.Input

	ToServiceLinkedRoleOutput() ServiceLinkedRoleOutput
	ToServiceLinkedRoleOutputWithContext(ctx context.Context) ServiceLinkedRoleOutput
}

type ServiceLinkedRoleMap added in v3.25.0 

type ServiceLinkedRoleMap map[string]ServiceLinkedRoleInput

func (ServiceLinkedRoleMap) ElementType added in v3.25.0 

func (ServiceLinkedRoleMap) ElementType() reflect.Type

func (ServiceLinkedRoleMap) ToServiceLinkedRoleMapOutput added in v3.25.0 

func (i ServiceLinkedRoleMap) ToServiceLinkedRoleMapOutput() ServiceLinkedRoleMapOutput

func (ServiceLinkedRoleMap) ToServiceLinkedRoleMapOutputWithContext added in v3.25.0 

func (i ServiceLinkedRoleMap) ToServiceLinkedRoleMapOutputWithContext(ctx context.Context) ServiceLinkedRoleMapOutput

type ServiceLinkedRoleMapInput added in v3.25.0 

type ServiceLinkedRoleMapInput interface {
	pulumi.Input

	ToServiceLinkedRoleMapOutput() ServiceLinkedRoleMapOutput
	ToServiceLinkedRoleMapOutputWithContext(context.Context) ServiceLinkedRoleMapOutput
}

ServiceLinkedRoleMapInput is an input type that accepts ServiceLinkedRoleMap and ServiceLinkedRoleMapOutput values. You can construct a concrete instance of `ServiceLinkedRoleMapInput` via: 

ServiceLinkedRoleMap{ "key": ServiceLinkedRoleArgs{...} }

type ServiceLinkedRoleMapOutput added in v3.25.0 

type ServiceLinkedRoleMapOutput struct{ *pulumi.OutputState }

func (ServiceLinkedRoleMapOutput) ElementType added in v3.25.0 

func (ServiceLinkedRoleMapOutput) ElementType() reflect.Type

func (ServiceLinkedRoleMapOutput) MapIndex added in v3.25.0 

func (o ServiceLinkedRoleMapOutput) MapIndex(k pulumi.StringInput) ServiceLinkedRoleOutput

func (ServiceLinkedRoleMapOutput) ToServiceLinkedRoleMapOutput added in v3.25.0 

func (o ServiceLinkedRoleMapOutput) ToServiceLinkedRoleMapOutput() ServiceLinkedRoleMapOutput

func (ServiceLinkedRoleMapOutput) ToServiceLinkedRoleMapOutputWithContext added in v3.25.0 

func (o ServiceLinkedRoleMapOutput) ToServiceLinkedRoleMapOutputWithContext(ctx context.Context) ServiceLinkedRoleMapOutput

type ServiceLinkedRoleOutput added in v3.13.0 

type ServiceLinkedRoleOutput struct {
	*pulumi.OutputState
}

func (ServiceLinkedRoleOutput) ElementType added in v3.13.0 

func (ServiceLinkedRoleOutput) ElementType() reflect.Type

func (ServiceLinkedRoleOutput) ToServiceLinkedRoleOutput added in v3.13.0 

func (o ServiceLinkedRoleOutput) ToServiceLinkedRoleOutput() ServiceLinkedRoleOutput

func (ServiceLinkedRoleOutput) ToServiceLinkedRoleOutputWithContext added in v3.13.0 

func (o ServiceLinkedRoleOutput) ToServiceLinkedRoleOutputWithContext(ctx context.Context) ServiceLinkedRoleOutput

func (ServiceLinkedRoleOutput) ToServiceLinkedRolePtrOutput added in v3.25.0 

func (o ServiceLinkedRoleOutput) ToServiceLinkedRolePtrOutput() ServiceLinkedRolePtrOutput

func (ServiceLinkedRoleOutput) ToServiceLinkedRolePtrOutputWithContext added in v3.25.0 

func (o ServiceLinkedRoleOutput) ToServiceLinkedRolePtrOutputWithContext(ctx context.Context) ServiceLinkedRolePtrOutput

type ServiceLinkedRolePtrInput added in v3.25.0 

type ServiceLinkedRolePtrInput interface {
	pulumi.Input

	ToServiceLinkedRolePtrOutput() ServiceLinkedRolePtrOutput
	ToServiceLinkedRolePtrOutputWithContext(ctx context.Context) ServiceLinkedRolePtrOutput
}

type ServiceLinkedRolePtrOutput added in v3.25.0 

type ServiceLinkedRolePtrOutput struct {
	*pulumi.OutputState
}

func (ServiceLinkedRolePtrOutput) ElementType added in v3.25.0 

func (ServiceLinkedRolePtrOutput) ElementType() reflect.Type

func (ServiceLinkedRolePtrOutput) ToServiceLinkedRolePtrOutput added in v3.25.0 

func (o ServiceLinkedRolePtrOutput) ToServiceLinkedRolePtrOutput() ServiceLinkedRolePtrOutput

func (ServiceLinkedRolePtrOutput) ToServiceLinkedRolePtrOutputWithContext added in v3.25.0 

func (o ServiceLinkedRolePtrOutput) ToServiceLinkedRolePtrOutputWithContext(ctx context.Context) ServiceLinkedRolePtrOutput

type ServiceLinkedRoleState 

type ServiceLinkedRoleState struct {
	// The Amazon Resource Name (ARN) specifying the role.
	Arn pulumi.StringPtrInput
	// The AWS service to which this role is attached. You use a string similar to a URL but without the `http://` in front. For example: `elasticbeanstalk.amazonaws.com`. To find the full list of services that support service-linked roles, check [the docs](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html).
	AwsServiceName pulumi.StringPtrInput
	// The creation date of the IAM role.
	CreateDate pulumi.StringPtrInput
	// Additional string appended to the role name. Not all AWS services support custom suffixes.
	CustomSuffix pulumi.StringPtrInput
	// The description of the role.
	Description pulumi.StringPtrInput
	// The name of the role.
	Name pulumi.StringPtrInput
	// The path of the role.
	Path pulumi.StringPtrInput
	// The stable and unique string identifying the role.
	UniqueId pulumi.StringPtrInput
}

func (ServiceLinkedRoleState) ElementType 

func (ServiceLinkedRoleState) ElementType() reflect.Type

type SshKey 

type SshKey struct {
	pulumi.CustomResourceState

	// Specifies the public key encoding format to use in the response. To retrieve the public key in ssh-rsa format, use `SSH`. To retrieve the public key in PEM format, use `PEM`.
	Encoding pulumi.StringOutput `pulumi:"encoding"`
	// The MD5 message digest of the SSH public key.
	Fingerprint pulumi.StringOutput `pulumi:"fingerprint"`
	// The SSH public key. The public key must be encoded in ssh-rsa format or PEM format.
	PublicKey pulumi.StringOutput `pulumi:"publicKey"`
	// The unique identifier for the SSH public key.
	SshPublicKeyId pulumi.StringOutput `pulumi:"sshPublicKeyId"`
	// The status to assign to the SSH public key. Active means the key can be used for authentication with an AWS CodeCommit repository. Inactive means the key cannot be used. Default is `active`.
	Status pulumi.StringOutput `pulumi:"status"`
	// The name of the IAM user to associate the SSH public key with.
	Username pulumi.StringOutput `pulumi:"username"`
}

Uploads an SSH public key and associates it with the specified IAM user.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		userUser, err := iam.NewUser(ctx, "userUser", &iam.UserArgs{
			Path: pulumi.String("/"),
		})
		if err != nil {
			return err
		}
		_, err = iam.NewSshKey(ctx, "userSshKey", &iam.SshKeyArgs{
			Username:  userUser.Name,
			Encoding:  pulumi.String("SSH"),
			PublicKey: pulumi.String("ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQD3F6tyPEFEzV0LX3X8BsXdMsQz1x2cEikKDEY0aIj41qgxMCP/iteneqXSIFZBp5vizPvaoIR3Um9xK7PGoW8giupGn+EPuxIA4cDM4vzOqOkiMPhz5XK0whEjkVzTo4+S0puvDZuwIsdiW9mxhJc7tgBNL0cYlWSYVkz4G/fslNfRPW5mYAM49f4fhtxPb5ok4Q2Lg9dPKVHO/Bgeu5woMc7RY0p1ej6D4CKFE6lymSDJpW0YHX/wqE9+cfEauh7xZcG0q9t2ta6F6fmX0agvpFyZo8aFbXeUBr7osSCJNgvavWbM/06niWrOvYX2xwWdhXmXSrbX8ZbabVohBK41 mytest@mydomain.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

SSH public keys can be imported using the `username`, `ssh_public_key_id`, and `encoding` e.g.

```sh 

$ pulumi import aws:iam/sshKey:SshKey user user:APKAJNCNNJICVN7CFKCA:SSH

```

func GetSshKey 

func GetSshKey(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *SshKeyState, opts ...pulumi.ResourceOption) (*SshKey, error)

GetSshKey gets an existing SshKey resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewSshKey 

func NewSshKey(ctx *pulumi.Context,
	name string, args *SshKeyArgs, opts ...pulumi.ResourceOption) (*SshKey, error)

NewSshKey registers a new resource with the given unique name, arguments, and options.

func (*SshKey) ElementType added in v3.13.0 

func (*SshKey) ElementType() reflect.Type

func (*SshKey) ToSshKeyOutput added in v3.13.0 

func (i *SshKey) ToSshKeyOutput() SshKeyOutput

func (*SshKey) ToSshKeyOutputWithContext added in v3.13.0 

func (i *SshKey) ToSshKeyOutputWithContext(ctx context.Context) SshKeyOutput

func (*SshKey) ToSshKeyPtrOutput added in v3.25.0 

func (i *SshKey) ToSshKeyPtrOutput() SshKeyPtrOutput

func (*SshKey) ToSshKeyPtrOutputWithContext added in v3.25.0 

func (i *SshKey) ToSshKeyPtrOutputWithContext(ctx context.Context) SshKeyPtrOutput

type SshKeyArgs 

type SshKeyArgs struct {
	// Specifies the public key encoding format to use in the response. To retrieve the public key in ssh-rsa format, use `SSH`. To retrieve the public key in PEM format, use `PEM`.
	Encoding pulumi.StringInput
	// The SSH public key. The public key must be encoded in ssh-rsa format or PEM format.
	PublicKey pulumi.StringInput
	// The status to assign to the SSH public key. Active means the key can be used for authentication with an AWS CodeCommit repository. Inactive means the key cannot be used. Default is `active`.
	Status pulumi.StringPtrInput
	// The name of the IAM user to associate the SSH public key with.
	Username pulumi.StringInput
}

The set of arguments for constructing a SshKey resource.

func (SshKeyArgs) ElementType 

func (SshKeyArgs) ElementType() reflect.Type

type SshKeyArray added in v3.25.0 

type SshKeyArray []SshKeyInput

func (SshKeyArray) ElementType added in v3.25.0 

func (SshKeyArray) ElementType() reflect.Type

func (SshKeyArray) ToSshKeyArrayOutput added in v3.25.0 

func (i SshKeyArray) ToSshKeyArrayOutput() SshKeyArrayOutput

func (SshKeyArray) ToSshKeyArrayOutputWithContext added in v3.25.0 

func (i SshKeyArray) ToSshKeyArrayOutputWithContext(ctx context.Context) SshKeyArrayOutput

type SshKeyArrayInput added in v3.25.0 

type SshKeyArrayInput interface {
	pulumi.Input

	ToSshKeyArrayOutput() SshKeyArrayOutput
	ToSshKeyArrayOutputWithContext(context.Context) SshKeyArrayOutput
}

SshKeyArrayInput is an input type that accepts SshKeyArray and SshKeyArrayOutput values. You can construct a concrete instance of `SshKeyArrayInput` via: 

SshKeyArray{ SshKeyArgs{...} }

type SshKeyArrayOutput added in v3.25.0 

type SshKeyArrayOutput struct{ *pulumi.OutputState }

func (SshKeyArrayOutput) ElementType added in v3.25.0 

func (SshKeyArrayOutput) ElementType() reflect.Type

func (SshKeyArrayOutput) Index added in v3.25.0 

func (o SshKeyArrayOutput) Index(i pulumi.IntInput) SshKeyOutput

func (SshKeyArrayOutput) ToSshKeyArrayOutput added in v3.25.0 

func (o SshKeyArrayOutput) ToSshKeyArrayOutput() SshKeyArrayOutput

func (SshKeyArrayOutput) ToSshKeyArrayOutputWithContext added in v3.25.0 

func (o SshKeyArrayOutput) ToSshKeyArrayOutputWithContext(ctx context.Context) SshKeyArrayOutput

type SshKeyInput added in v3.13.0 

type SshKeyInput interface {
	pulumi.Input

	ToSshKeyOutput() SshKeyOutput
	ToSshKeyOutputWithContext(ctx context.Context) SshKeyOutput
}

type SshKeyMap added in v3.25.0 

type SshKeyMap map[string]SshKeyInput

func (SshKeyMap) ElementType added in v3.25.0 

func (SshKeyMap) ElementType() reflect.Type

func (SshKeyMap) ToSshKeyMapOutput added in v3.25.0 

func (i SshKeyMap) ToSshKeyMapOutput() SshKeyMapOutput

func (SshKeyMap) ToSshKeyMapOutputWithContext added in v3.25.0 

func (i SshKeyMap) ToSshKeyMapOutputWithContext(ctx context.Context) SshKeyMapOutput

type SshKeyMapInput added in v3.25.0 

type SshKeyMapInput interface {
	pulumi.Input

	ToSshKeyMapOutput() SshKeyMapOutput
	ToSshKeyMapOutputWithContext(context.Context) SshKeyMapOutput
}

SshKeyMapInput is an input type that accepts SshKeyMap and SshKeyMapOutput values. You can construct a concrete instance of `SshKeyMapInput` via: 

SshKeyMap{ "key": SshKeyArgs{...} }

type SshKeyMapOutput added in v3.25.0 

type SshKeyMapOutput struct{ *pulumi.OutputState }

func (SshKeyMapOutput) ElementType added in v3.25.0 

func (SshKeyMapOutput) ElementType() reflect.Type

func (SshKeyMapOutput) MapIndex added in v3.25.0 

func (o SshKeyMapOutput) MapIndex(k pulumi.StringInput) SshKeyOutput

func (SshKeyMapOutput) ToSshKeyMapOutput added in v3.25.0 

func (o SshKeyMapOutput) ToSshKeyMapOutput() SshKeyMapOutput

func (SshKeyMapOutput) ToSshKeyMapOutputWithContext added in v3.25.0 

func (o SshKeyMapOutput) ToSshKeyMapOutputWithContext(ctx context.Context) SshKeyMapOutput

type SshKeyOutput added in v3.13.0 

type SshKeyOutput struct {
	*pulumi.OutputState
}

func (SshKeyOutput) ElementType added in v3.13.0 

func (SshKeyOutput) ElementType() reflect.Type

func (SshKeyOutput) ToSshKeyOutput added in v3.13.0 

func (o SshKeyOutput) ToSshKeyOutput() SshKeyOutput

func (SshKeyOutput) ToSshKeyOutputWithContext added in v3.13.0 

func (o SshKeyOutput) ToSshKeyOutputWithContext(ctx context.Context) SshKeyOutput

func (SshKeyOutput) ToSshKeyPtrOutput added in v3.25.0 

func (o SshKeyOutput) ToSshKeyPtrOutput() SshKeyPtrOutput

func (SshKeyOutput) ToSshKeyPtrOutputWithContext added in v3.25.0 

func (o SshKeyOutput) ToSshKeyPtrOutputWithContext(ctx context.Context) SshKeyPtrOutput

type SshKeyPtrInput added in v3.25.0 

type SshKeyPtrInput interface {
	pulumi.Input

	ToSshKeyPtrOutput() SshKeyPtrOutput
	ToSshKeyPtrOutputWithContext(ctx context.Context) SshKeyPtrOutput
}

type SshKeyPtrOutput added in v3.25.0 

type SshKeyPtrOutput struct {
	*pulumi.OutputState
}

func (SshKeyPtrOutput) ElementType added in v3.25.0 

func (SshKeyPtrOutput) ElementType() reflect.Type

func (SshKeyPtrOutput) ToSshKeyPtrOutput added in v3.25.0 

func (o SshKeyPtrOutput) ToSshKeyPtrOutput() SshKeyPtrOutput

func (SshKeyPtrOutput) ToSshKeyPtrOutputWithContext added in v3.25.0 

func (o SshKeyPtrOutput) ToSshKeyPtrOutputWithContext(ctx context.Context) SshKeyPtrOutput

type SshKeyState 

type SshKeyState struct {
	// Specifies the public key encoding format to use in the response. To retrieve the public key in ssh-rsa format, use `SSH`. To retrieve the public key in PEM format, use `PEM`.
	Encoding pulumi.StringPtrInput
	// The MD5 message digest of the SSH public key.
	Fingerprint pulumi.StringPtrInput
	// The SSH public key. The public key must be encoded in ssh-rsa format or PEM format.
	PublicKey pulumi.StringPtrInput
	// The unique identifier for the SSH public key.
	SshPublicKeyId pulumi.StringPtrInput
	// The status to assign to the SSH public key. Active means the key can be used for authentication with an AWS CodeCommit repository. Inactive means the key cannot be used. Default is `active`.
	Status pulumi.StringPtrInput
	// The name of the IAM user to associate the SSH public key with.
	Username pulumi.StringPtrInput
}

func (SshKeyState) ElementType 

func (SshKeyState) ElementType() reflect.Type

type User 

type User struct {
	pulumi.CustomResourceState

	// The ARN assigned by AWS for this user.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// When destroying this user, destroy even if it
	// has non-provider-managed IAM access keys, login profile or MFA devices. Without `forceDestroy`
	// a user with non-provider-managed access keys and login profile will fail to be destroyed.
	ForceDestroy pulumi.BoolPtrOutput `pulumi:"forceDestroy"`
	// The user's name. The name must consist of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: `=,.@-_.`. User names are not distinguished by case. For example, you cannot create users named both "TESTUSER" and "testuser".
	Name pulumi.StringOutput `pulumi:"name"`
	// Path in which to create the user.
	Path pulumi.StringPtrOutput `pulumi:"path"`
	// The ARN of the policy that is used to set the permissions boundary for the user.
	PermissionsBoundary pulumi.StringPtrOutput `pulumi:"permissionsBoundary"`
	// Key-value mapping of tags for the IAM user
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// The [unique ID][1] assigned by AWS.
	UniqueId pulumi.StringOutput `pulumi:"uniqueId"`
}

Provides an IAM user.

> *NOTE:* If policies are attached to the user via the `iam.PolicyAttachment` resource and you are modifying the user `name` or `path`, the `forceDestroy` argument must be set to `true` and applied before attempting the operation otherwise you will encounter a `DeleteConflict` error. The `iam.UserPolicyAttachment` resource (recommended) does not have this requirement.

## Example Usage

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		lbUser, err := iam.NewUser(ctx, "lbUser", &iam.UserArgs{
			Path: pulumi.String("/system/"),
			Tags: pulumi.StringMap{
				"tag-key": pulumi.String("tag-value"),
			},
		})
		if err != nil {
			return err
		}
		_, err = iam.NewAccessKey(ctx, "lbAccessKey", &iam.AccessKeyArgs{
			User: lbUser.Name,
		})
		if err != nil {
			return err
		}
		_, err = iam.NewUserPolicy(ctx, "lbRo", &iam.UserPolicyArgs{
			User:   lbUser.Name,
			Policy: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "  \"Version\": \"2012-10-17\",\n", "  \"Statement\": [\n", "    {\n", "      \"Action\": [\n", "        \"ec2:Describe*\"\n", "      ],\n", "      \"Effect\": \"Allow\",\n", "      \"Resource\": \"*\"\n", "    }\n", "  ]\n", "}\n")),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IAM Users can be imported using the `name`, e.g.

```sh 

$ pulumi import aws:iam/user:User lb loadbalancer

```

func GetUser 

func GetUser(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *UserState, opts ...pulumi.ResourceOption) (*User, error)

GetUser gets an existing User resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewUser 

func NewUser(ctx *pulumi.Context,
	name string, args *UserArgs, opts ...pulumi.ResourceOption) (*User, error)

NewUser registers a new resource with the given unique name, arguments, and options.

func (*User) ElementType added in v3.13.0 

func (*User) ElementType() reflect.Type

func (*User) ToUserOutput added in v3.13.0 

func (i *User) ToUserOutput() UserOutput

func (*User) ToUserOutputWithContext added in v3.13.0 

func (i *User) ToUserOutputWithContext(ctx context.Context) UserOutput

func (*User) ToUserPtrOutput added in v3.25.0 

func (i *User) ToUserPtrOutput() UserPtrOutput

func (*User) ToUserPtrOutputWithContext added in v3.25.0 

func (i *User) ToUserPtrOutputWithContext(ctx context.Context) UserPtrOutput

type UserArgs 

type UserArgs struct {
	// When destroying this user, destroy even if it
	// has non-provider-managed IAM access keys, login profile or MFA devices. Without `forceDestroy`
	// a user with non-provider-managed access keys and login profile will fail to be destroyed.
	ForceDestroy pulumi.BoolPtrInput
	// The user's name. The name must consist of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: `=,.@-_.`. User names are not distinguished by case. For example, you cannot create users named both "TESTUSER" and "testuser".
	Name pulumi.StringPtrInput
	// Path in which to create the user.
	Path pulumi.StringPtrInput
	// The ARN of the policy that is used to set the permissions boundary for the user.
	PermissionsBoundary pulumi.StringPtrInput
	// Key-value mapping of tags for the IAM user
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a User resource.

func (UserArgs) ElementType 

func (UserArgs) ElementType() reflect.Type

type UserArray added in v3.25.0 

type UserArray []UserInput

func (UserArray) ElementType added in v3.25.0 

func (UserArray) ElementType() reflect.Type

func (UserArray) ToUserArrayOutput added in v3.25.0 

func (i UserArray) ToUserArrayOutput() UserArrayOutput

func (UserArray) ToUserArrayOutputWithContext added in v3.25.0 

func (i UserArray) ToUserArrayOutputWithContext(ctx context.Context) UserArrayOutput

type UserArrayInput added in v3.25.0 

type UserArrayInput interface {
	pulumi.Input

	ToUserArrayOutput() UserArrayOutput
	ToUserArrayOutputWithContext(context.Context) UserArrayOutput
}

UserArrayInput is an input type that accepts UserArray and UserArrayOutput values. You can construct a concrete instance of `UserArrayInput` via: 

UserArray{ UserArgs{...} }

type UserArrayOutput added in v3.25.0 

type UserArrayOutput struct{ *pulumi.OutputState }

func (UserArrayOutput) ElementType added in v3.25.0 

func (UserArrayOutput) ElementType() reflect.Type

func (UserArrayOutput) Index added in v3.25.0 

func (o UserArrayOutput) Index(i pulumi.IntInput) UserOutput

func (UserArrayOutput) ToUserArrayOutput added in v3.25.0 

func (o UserArrayOutput) ToUserArrayOutput() UserArrayOutput

func (UserArrayOutput) ToUserArrayOutputWithContext added in v3.25.0 

func (o UserArrayOutput) ToUserArrayOutputWithContext(ctx context.Context) UserArrayOutput

type UserGroupMembership 

type UserGroupMembership struct {
	pulumi.CustomResourceState

	// A list of IAM Groups to add the user to
	Groups pulumi.StringArrayOutput `pulumi:"groups"`
	// The name of the IAM User to add to groups
	User pulumi.StringOutput `pulumi:"user"`
}

Provides a resource for adding an IAM User to IAM Groups. This resource can be used multiple times with the same user for non-overlapping groups.

To exclusively manage the users in a group, see the `iam.GroupMembership` resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		user1, err := iam.NewUser(ctx, "user1", nil)
		if err != nil {
			return err
		}
		group1, err := iam.NewGroup(ctx, "group1", nil)
		if err != nil {
			return err
		}
		group2, err := iam.NewGroup(ctx, "group2", nil)
		if err != nil {
			return err
		}
		_, err = iam.NewUserGroupMembership(ctx, "example1", &iam.UserGroupMembershipArgs{
			User: user1.Name,
			Groups: pulumi.StringArray{
				group1.Name,
				group2.Name,
			},
		})
		if err != nil {
			return err
		}
		group3, err := iam.NewGroup(ctx, "group3", nil)
		if err != nil {
			return err
		}
		_, err = iam.NewUserGroupMembership(ctx, "example2", &iam.UserGroupMembershipArgs{
			User: user1.Name,
			Groups: pulumi.StringArray{
				group3.Name,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IAM user group membership can be imported using the user name and group names separated by `/`.

```sh 

$ pulumi import aws:iam/userGroupMembership:UserGroupMembership example1 user1/group1/group2

```

func GetUserGroupMembership 

func GetUserGroupMembership(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *UserGroupMembershipState, opts ...pulumi.ResourceOption) (*UserGroupMembership, error)

GetUserGroupMembership gets an existing UserGroupMembership resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewUserGroupMembership 

func NewUserGroupMembership(ctx *pulumi.Context,
	name string, args *UserGroupMembershipArgs, opts ...pulumi.ResourceOption) (*UserGroupMembership, error)

NewUserGroupMembership registers a new resource with the given unique name, arguments, and options.

func (*UserGroupMembership) ElementType added in v3.13.0 

func (*UserGroupMembership) ElementType() reflect.Type

func (*UserGroupMembership) ToUserGroupMembershipOutput added in v3.13.0 

func (i *UserGroupMembership) ToUserGroupMembershipOutput() UserGroupMembershipOutput

func (*UserGroupMembership) ToUserGroupMembershipOutputWithContext added in v3.13.0 

func (i *UserGroupMembership) ToUserGroupMembershipOutputWithContext(ctx context.Context) UserGroupMembershipOutput

func (*UserGroupMembership) ToUserGroupMembershipPtrOutput added in v3.25.0 

func (i *UserGroupMembership) ToUserGroupMembershipPtrOutput() UserGroupMembershipPtrOutput

func (*UserGroupMembership) ToUserGroupMembershipPtrOutputWithContext added in v3.25.0 

func (i *UserGroupMembership) ToUserGroupMembershipPtrOutputWithContext(ctx context.Context) UserGroupMembershipPtrOutput

type UserGroupMembershipArgs 

type UserGroupMembershipArgs struct {
	// A list of IAM Groups to add the user to
	Groups pulumi.StringArrayInput
	// The name of the IAM User to add to groups
	User pulumi.StringInput
}

The set of arguments for constructing a UserGroupMembership resource.

func (UserGroupMembershipArgs) ElementType 

func (UserGroupMembershipArgs) ElementType() reflect.Type

type UserGroupMembershipArray added in v3.25.0 

type UserGroupMembershipArray []UserGroupMembershipInput

func (UserGroupMembershipArray) ElementType added in v3.25.0 

func (UserGroupMembershipArray) ElementType() reflect.Type

func (UserGroupMembershipArray) ToUserGroupMembershipArrayOutput added in v3.25.0 

func (i UserGroupMembershipArray) ToUserGroupMembershipArrayOutput() UserGroupMembershipArrayOutput

func (UserGroupMembershipArray) ToUserGroupMembershipArrayOutputWithContext added in v3.25.0 

func (i UserGroupMembershipArray) ToUserGroupMembershipArrayOutputWithContext(ctx context.Context) UserGroupMembershipArrayOutput

type UserGroupMembershipArrayInput added in v3.25.0 

type UserGroupMembershipArrayInput interface {
	pulumi.Input

	ToUserGroupMembershipArrayOutput() UserGroupMembershipArrayOutput
	ToUserGroupMembershipArrayOutputWithContext(context.Context) UserGroupMembershipArrayOutput
}

UserGroupMembershipArrayInput is an input type that accepts UserGroupMembershipArray and UserGroupMembershipArrayOutput values. You can construct a concrete instance of `UserGroupMembershipArrayInput` via: 

UserGroupMembershipArray{ UserGroupMembershipArgs{...} }

type UserGroupMembershipArrayOutput added in v3.25.0 

type UserGroupMembershipArrayOutput struct{ *pulumi.OutputState }

func (UserGroupMembershipArrayOutput) ElementType added in v3.25.0 

func (UserGroupMembershipArrayOutput) ElementType() reflect.Type

func (UserGroupMembershipArrayOutput) Index added in v3.25.0 

func (o UserGroupMembershipArrayOutput) Index(i pulumi.IntInput) UserGroupMembershipOutput

func (UserGroupMembershipArrayOutput) ToUserGroupMembershipArrayOutput added in v3.25.0 

func (o UserGroupMembershipArrayOutput) ToUserGroupMembershipArrayOutput() UserGroupMembershipArrayOutput

func (UserGroupMembershipArrayOutput) ToUserGroupMembershipArrayOutputWithContext added in v3.25.0 

func (o UserGroupMembershipArrayOutput) ToUserGroupMembershipArrayOutputWithContext(ctx context.Context) UserGroupMembershipArrayOutput

type UserGroupMembershipInput added in v3.13.0 

type UserGroupMembershipInput interface {
	pulumi.Input

	ToUserGroupMembershipOutput() UserGroupMembershipOutput
	ToUserGroupMembershipOutputWithContext(ctx context.Context) UserGroupMembershipOutput
}

type UserGroupMembershipMap added in v3.25.0 

type UserGroupMembershipMap map[string]UserGroupMembershipInput

func (UserGroupMembershipMap) ElementType added in v3.25.0 

func (UserGroupMembershipMap) ElementType() reflect.Type

func (UserGroupMembershipMap) ToUserGroupMembershipMapOutput added in v3.25.0 

func (i UserGroupMembershipMap) ToUserGroupMembershipMapOutput() UserGroupMembershipMapOutput

func (UserGroupMembershipMap) ToUserGroupMembershipMapOutputWithContext added in v3.25.0 

func (i UserGroupMembershipMap) ToUserGroupMembershipMapOutputWithContext(ctx context.Context) UserGroupMembershipMapOutput

type UserGroupMembershipMapInput added in v3.25.0 

type UserGroupMembershipMapInput interface {
	pulumi.Input

	ToUserGroupMembershipMapOutput() UserGroupMembershipMapOutput
	ToUserGroupMembershipMapOutputWithContext(context.Context) UserGroupMembershipMapOutput
}

UserGroupMembershipMapInput is an input type that accepts UserGroupMembershipMap and UserGroupMembershipMapOutput values. You can construct a concrete instance of `UserGroupMembershipMapInput` via: 

UserGroupMembershipMap{ "key": UserGroupMembershipArgs{...} }

type UserGroupMembershipMapOutput added in v3.25.0 

type UserGroupMembershipMapOutput struct{ *pulumi.OutputState }

func (UserGroupMembershipMapOutput) ElementType added in v3.25.0 

func (UserGroupMembershipMapOutput) ElementType() reflect.Type

func (UserGroupMembershipMapOutput) MapIndex added in v3.25.0 

func (o UserGroupMembershipMapOutput) MapIndex(k pulumi.StringInput) UserGroupMembershipOutput

func (UserGroupMembershipMapOutput) ToUserGroupMembershipMapOutput added in v3.25.0 

func (o UserGroupMembershipMapOutput) ToUserGroupMembershipMapOutput() UserGroupMembershipMapOutput

func (UserGroupMembershipMapOutput) ToUserGroupMembershipMapOutputWithContext added in v3.25.0 

func (o UserGroupMembershipMapOutput) ToUserGroupMembershipMapOutputWithContext(ctx context.Context) UserGroupMembershipMapOutput

type UserGroupMembershipOutput added in v3.13.0 

type UserGroupMembershipOutput struct {
	*pulumi.OutputState
}

func (UserGroupMembershipOutput) ElementType added in v3.13.0 

func (UserGroupMembershipOutput) ElementType() reflect.Type

func (UserGroupMembershipOutput) ToUserGroupMembershipOutput added in v3.13.0 

func (o UserGroupMembershipOutput) ToUserGroupMembershipOutput() UserGroupMembershipOutput

func (UserGroupMembershipOutput) ToUserGroupMembershipOutputWithContext added in v3.13.0 

func (o UserGroupMembershipOutput) ToUserGroupMembershipOutputWithContext(ctx context.Context) UserGroupMembershipOutput

func (UserGroupMembershipOutput) ToUserGroupMembershipPtrOutput added in v3.25.0 

func (o UserGroupMembershipOutput) ToUserGroupMembershipPtrOutput() UserGroupMembershipPtrOutput

func (UserGroupMembershipOutput) ToUserGroupMembershipPtrOutputWithContext added in v3.25.0 

func (o UserGroupMembershipOutput) ToUserGroupMembershipPtrOutputWithContext(ctx context.Context) UserGroupMembershipPtrOutput

type UserGroupMembershipPtrInput added in v3.25.0 

type UserGroupMembershipPtrInput interface {
	pulumi.Input

	ToUserGroupMembershipPtrOutput() UserGroupMembershipPtrOutput
	ToUserGroupMembershipPtrOutputWithContext(ctx context.Context) UserGroupMembershipPtrOutput
}

type UserGroupMembershipPtrOutput added in v3.25.0 

type UserGroupMembershipPtrOutput struct {
	*pulumi.OutputState
}

func (UserGroupMembershipPtrOutput) ElementType added in v3.25.0 

func (UserGroupMembershipPtrOutput) ElementType() reflect.Type

func (UserGroupMembershipPtrOutput) ToUserGroupMembershipPtrOutput added in v3.25.0 

func (o UserGroupMembershipPtrOutput) ToUserGroupMembershipPtrOutput() UserGroupMembershipPtrOutput

func (UserGroupMembershipPtrOutput) ToUserGroupMembershipPtrOutputWithContext added in v3.25.0 

func (o UserGroupMembershipPtrOutput) ToUserGroupMembershipPtrOutputWithContext(ctx context.Context) UserGroupMembershipPtrOutput

type UserGroupMembershipState 

type UserGroupMembershipState struct {
	// A list of IAM Groups to add the user to
	Groups pulumi.StringArrayInput
	// The name of the IAM User to add to groups
	User pulumi.StringPtrInput
}

func (UserGroupMembershipState) ElementType 

func (UserGroupMembershipState) ElementType() reflect.Type

type UserInput added in v3.13.0 

type UserInput interface {
	pulumi.Input

	ToUserOutput() UserOutput
	ToUserOutputWithContext(ctx context.Context) UserOutput
}

type UserLoginProfile 

type UserLoginProfile struct {
	pulumi.CustomResourceState

	// The encrypted password, base64 encoded. Only available if password was handled on this provider resource creation, not import.
	EncryptedPassword pulumi.StringOutput `pulumi:"encryptedPassword"`
	// The fingerprint of the PGP key used to encrypt the password. Only available if password was handled on this provider resource creation, not import.
	KeyFingerprint pulumi.StringOutput `pulumi:"keyFingerprint"`
	// The length of the generated password on resource creation. Only applies on resource creation. Drift detection is not possible with this argument.
	PasswordLength pulumi.IntPtrOutput `pulumi:"passwordLength"`
	// Whether the user should be forced to reset the generated password on resource creation. Only applies on resource creation. Drift detection is not possible with this argument.
	PasswordResetRequired pulumi.BoolPtrOutput `pulumi:"passwordResetRequired"`
	// Either a base-64 encoded PGP public key, or a keybase username in the form `keybase:username`. Only applies on resource creation. Drift detection is not possible with this argument.
	PgpKey pulumi.StringOutput `pulumi:"pgpKey"`
	// The IAM user's name.
	User pulumi.StringOutput `pulumi:"user"`
}

Manages an IAM User Login Profile with limited support for password creation during this provider resource creation. Uses PGP to encrypt the password for safe transport to the user. PGP keys can be obtained from Keybase.

> To reset an IAM User login password via this provider, you can use delete and recreate this resource or change any of the arguments.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleUser, err := iam.NewUser(ctx, "exampleUser", &iam.UserArgs{
			Path:         pulumi.String("/"),
			ForceDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		exampleUserLoginProfile, err := iam.NewUserLoginProfile(ctx, "exampleUserLoginProfile", &iam.UserLoginProfileArgs{
			User:   exampleUser.Name,
			PgpKey: pulumi.String("keybase:some_person_that_exists"),
		})
		if err != nil {
			return err
		}
		ctx.Export("password", exampleUserLoginProfile.EncryptedPassword)
		return nil
	})
}

```

## Import

IAM User Login Profiles can be imported without password information support via the IAM User name, e.g.

```sh 

$ pulumi import aws:iam/userLoginProfile:UserLoginProfile example myusername

``` 

Since this provider has no method to read the PGP or password information during import, use [`ignore_changes` argument](https://www.pulumi.com/docs/intro/concepts/programming-model/#ignorechanges) to ignore them unless password recreation is desired. e.g. terraform resource "aws_iam_user_login_profile" "example" {

... other configuration ... 

lifecycle {

ignore_changes = [

password_length,

password_reset_required,

pgp_key,

]

} }

func GetUserLoginProfile 

func GetUserLoginProfile(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *UserLoginProfileState, opts ...pulumi.ResourceOption) (*UserLoginProfile, error)

GetUserLoginProfile gets an existing UserLoginProfile resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewUserLoginProfile 

func NewUserLoginProfile(ctx *pulumi.Context,
	name string, args *UserLoginProfileArgs, opts ...pulumi.ResourceOption) (*UserLoginProfile, error)

NewUserLoginProfile registers a new resource with the given unique name, arguments, and options.

func (*UserLoginProfile) ElementType added in v3.13.0 

func (*UserLoginProfile) ElementType() reflect.Type

func (*UserLoginProfile) ToUserLoginProfileOutput added in v3.13.0 

func (i *UserLoginProfile) ToUserLoginProfileOutput() UserLoginProfileOutput

func (*UserLoginProfile) ToUserLoginProfileOutputWithContext added in v3.13.0 

func (i *UserLoginProfile) ToUserLoginProfileOutputWithContext(ctx context.Context) UserLoginProfileOutput

func (*UserLoginProfile) ToUserLoginProfilePtrOutput added in v3.25.0 

func (i *UserLoginProfile) ToUserLoginProfilePtrOutput() UserLoginProfilePtrOutput

func (*UserLoginProfile) ToUserLoginProfilePtrOutputWithContext added in v3.25.0 

func (i *UserLoginProfile) ToUserLoginProfilePtrOutputWithContext(ctx context.Context) UserLoginProfilePtrOutput

type UserLoginProfileArgs 

type UserLoginProfileArgs struct {
	// The length of the generated password on resource creation. Only applies on resource creation. Drift detection is not possible with this argument.
	PasswordLength pulumi.IntPtrInput
	// Whether the user should be forced to reset the generated password on resource creation. Only applies on resource creation. Drift detection is not possible with this argument.
	PasswordResetRequired pulumi.BoolPtrInput
	// Either a base-64 encoded PGP public key, or a keybase username in the form `keybase:username`. Only applies on resource creation. Drift detection is not possible with this argument.
	PgpKey pulumi.StringInput
	// The IAM user's name.
	User pulumi.StringInput
}

The set of arguments for constructing a UserLoginProfile resource.

func (UserLoginProfileArgs) ElementType 

func (UserLoginProfileArgs) ElementType() reflect.Type

type UserLoginProfileArray added in v3.25.0 

type UserLoginProfileArray []UserLoginProfileInput

func (UserLoginProfileArray) ElementType added in v3.25.0 

func (UserLoginProfileArray) ElementType() reflect.Type

func (UserLoginProfileArray) ToUserLoginProfileArrayOutput added in v3.25.0 

func (i UserLoginProfileArray) ToUserLoginProfileArrayOutput() UserLoginProfileArrayOutput

func (UserLoginProfileArray) ToUserLoginProfileArrayOutputWithContext added in v3.25.0 

func (i UserLoginProfileArray) ToUserLoginProfileArrayOutputWithContext(ctx context.Context) UserLoginProfileArrayOutput

type UserLoginProfileArrayInput added in v3.25.0 

type UserLoginProfileArrayInput interface {
	pulumi.Input

	ToUserLoginProfileArrayOutput() UserLoginProfileArrayOutput
	ToUserLoginProfileArrayOutputWithContext(context.Context) UserLoginProfileArrayOutput
}

UserLoginProfileArrayInput is an input type that accepts UserLoginProfileArray and UserLoginProfileArrayOutput values. You can construct a concrete instance of `UserLoginProfileArrayInput` via: 

UserLoginProfileArray{ UserLoginProfileArgs{...} }

type UserLoginProfileArrayOutput added in v3.25.0 

type UserLoginProfileArrayOutput struct{ *pulumi.OutputState }

func (UserLoginProfileArrayOutput) ElementType added in v3.25.0 

func (UserLoginProfileArrayOutput) ElementType() reflect.Type

func (UserLoginProfileArrayOutput) Index added in v3.25.0 

func (o UserLoginProfileArrayOutput) Index(i pulumi.IntInput) UserLoginProfileOutput

func (UserLoginProfileArrayOutput) ToUserLoginProfileArrayOutput added in v3.25.0 

func (o UserLoginProfileArrayOutput) ToUserLoginProfileArrayOutput() UserLoginProfileArrayOutput

func (UserLoginProfileArrayOutput) ToUserLoginProfileArrayOutputWithContext added in v3.25.0 

func (o UserLoginProfileArrayOutput) ToUserLoginProfileArrayOutputWithContext(ctx context.Context) UserLoginProfileArrayOutput

type UserLoginProfileInput added in v3.13.0 

type UserLoginProfileInput interface {
	pulumi.Input

	ToUserLoginProfileOutput() UserLoginProfileOutput
	ToUserLoginProfileOutputWithContext(ctx context.Context) UserLoginProfileOutput
}

type UserLoginProfileMap added in v3.25.0 

type UserLoginProfileMap map[string]UserLoginProfileInput

func (UserLoginProfileMap) ElementType added in v3.25.0 

func (UserLoginProfileMap) ElementType() reflect.Type

func (UserLoginProfileMap) ToUserLoginProfileMapOutput added in v3.25.0 

func (i UserLoginProfileMap) ToUserLoginProfileMapOutput() UserLoginProfileMapOutput

func (UserLoginProfileMap) ToUserLoginProfileMapOutputWithContext added in v3.25.0 

func (i UserLoginProfileMap) ToUserLoginProfileMapOutputWithContext(ctx context.Context) UserLoginProfileMapOutput

type UserLoginProfileMapInput added in v3.25.0 

type UserLoginProfileMapInput interface {
	pulumi.Input

	ToUserLoginProfileMapOutput() UserLoginProfileMapOutput
	ToUserLoginProfileMapOutputWithContext(context.Context) UserLoginProfileMapOutput
}

UserLoginProfileMapInput is an input type that accepts UserLoginProfileMap and UserLoginProfileMapOutput values. You can construct a concrete instance of `UserLoginProfileMapInput` via: 

UserLoginProfileMap{ "key": UserLoginProfileArgs{...} }

type UserLoginProfileMapOutput added in v3.25.0 

type UserLoginProfileMapOutput struct{ *pulumi.OutputState }

func (UserLoginProfileMapOutput) ElementType added in v3.25.0 

func (UserLoginProfileMapOutput) ElementType() reflect.Type

func (UserLoginProfileMapOutput) MapIndex added in v3.25.0 

func (o UserLoginProfileMapOutput) MapIndex(k pulumi.StringInput) UserLoginProfileOutput

func (UserLoginProfileMapOutput) ToUserLoginProfileMapOutput added in v3.25.0 

func (o UserLoginProfileMapOutput) ToUserLoginProfileMapOutput() UserLoginProfileMapOutput

func (UserLoginProfileMapOutput) ToUserLoginProfileMapOutputWithContext added in v3.25.0 

func (o UserLoginProfileMapOutput) ToUserLoginProfileMapOutputWithContext(ctx context.Context) UserLoginProfileMapOutput

type UserLoginProfileOutput added in v3.13.0 

type UserLoginProfileOutput struct {
	*pulumi.OutputState
}

func (UserLoginProfileOutput) ElementType added in v3.13.0 

func (UserLoginProfileOutput) ElementType() reflect.Type

func (UserLoginProfileOutput) ToUserLoginProfileOutput added in v3.13.0 

func (o UserLoginProfileOutput) ToUserLoginProfileOutput() UserLoginProfileOutput

func (UserLoginProfileOutput) ToUserLoginProfileOutputWithContext added in v3.13.0 

func (o UserLoginProfileOutput) ToUserLoginProfileOutputWithContext(ctx context.Context) UserLoginProfileOutput

func (UserLoginProfileOutput) ToUserLoginProfilePtrOutput added in v3.25.0 

func (o UserLoginProfileOutput) ToUserLoginProfilePtrOutput() UserLoginProfilePtrOutput

func (UserLoginProfileOutput) ToUserLoginProfilePtrOutputWithContext added in v3.25.0 

func (o UserLoginProfileOutput) ToUserLoginProfilePtrOutputWithContext(ctx context.Context) UserLoginProfilePtrOutput

type UserLoginProfilePtrInput added in v3.25.0 

type UserLoginProfilePtrInput interface {
	pulumi.Input

	ToUserLoginProfilePtrOutput() UserLoginProfilePtrOutput
	ToUserLoginProfilePtrOutputWithContext(ctx context.Context) UserLoginProfilePtrOutput
}

type UserLoginProfilePtrOutput added in v3.25.0 

type UserLoginProfilePtrOutput struct {
	*pulumi.OutputState
}

func (UserLoginProfilePtrOutput) ElementType added in v3.25.0 

func (UserLoginProfilePtrOutput) ElementType() reflect.Type

func (UserLoginProfilePtrOutput) ToUserLoginProfilePtrOutput added in v3.25.0 

func (o UserLoginProfilePtrOutput) ToUserLoginProfilePtrOutput() UserLoginProfilePtrOutput

func (UserLoginProfilePtrOutput) ToUserLoginProfilePtrOutputWithContext added in v3.25.0 

func (o UserLoginProfilePtrOutput) ToUserLoginProfilePtrOutputWithContext(ctx context.Context) UserLoginProfilePtrOutput

type UserLoginProfileState 

type UserLoginProfileState struct {
	// The encrypted password, base64 encoded. Only available if password was handled on this provider resource creation, not import.
	EncryptedPassword pulumi.StringPtrInput
	// The fingerprint of the PGP key used to encrypt the password. Only available if password was handled on this provider resource creation, not import.
	KeyFingerprint pulumi.StringPtrInput
	// The length of the generated password on resource creation. Only applies on resource creation. Drift detection is not possible with this argument.
	PasswordLength pulumi.IntPtrInput
	// Whether the user should be forced to reset the generated password on resource creation. Only applies on resource creation. Drift detection is not possible with this argument.
	PasswordResetRequired pulumi.BoolPtrInput
	// Either a base-64 encoded PGP public key, or a keybase username in the form `keybase:username`. Only applies on resource creation. Drift detection is not possible with this argument.
	PgpKey pulumi.StringPtrInput
	// The IAM user's name.
	User pulumi.StringPtrInput
}

func (UserLoginProfileState) ElementType 

func (UserLoginProfileState) ElementType() reflect.Type

type UserMap added in v3.25.0 

type UserMap map[string]UserInput

func (UserMap) ElementType added in v3.25.0 

func (UserMap) ElementType() reflect.Type

func (UserMap) ToUserMapOutput added in v3.25.0 

func (i UserMap) ToUserMapOutput() UserMapOutput

func (UserMap) ToUserMapOutputWithContext added in v3.25.0 

func (i UserMap) ToUserMapOutputWithContext(ctx context.Context) UserMapOutput

type UserMapInput added in v3.25.0 

type UserMapInput interface {
	pulumi.Input

	ToUserMapOutput() UserMapOutput
	ToUserMapOutputWithContext(context.Context) UserMapOutput
}

UserMapInput is an input type that accepts UserMap and UserMapOutput values. You can construct a concrete instance of `UserMapInput` via: 

UserMap{ "key": UserArgs{...} }

type UserMapOutput added in v3.25.0 

type UserMapOutput struct{ *pulumi.OutputState }

func (UserMapOutput) ElementType added in v3.25.0 

func (UserMapOutput) ElementType() reflect.Type

func (UserMapOutput) MapIndex added in v3.25.0 

func (o UserMapOutput) MapIndex(k pulumi.StringInput) UserOutput

func (UserMapOutput) ToUserMapOutput added in v3.25.0 

func (o UserMapOutput) ToUserMapOutput() UserMapOutput

func (UserMapOutput) ToUserMapOutputWithContext added in v3.25.0 

func (o UserMapOutput) ToUserMapOutputWithContext(ctx context.Context) UserMapOutput

type UserOutput added in v3.13.0 

type UserOutput struct {
	*pulumi.OutputState
}

func (UserOutput) ElementType added in v3.13.0 

func (UserOutput) ElementType() reflect.Type

func (UserOutput) ToUserOutput added in v3.13.0 

func (o UserOutput) ToUserOutput() UserOutput

func (UserOutput) ToUserOutputWithContext added in v3.13.0 

func (o UserOutput) ToUserOutputWithContext(ctx context.Context) UserOutput

func (UserOutput) ToUserPtrOutput added in v3.25.0 

func (o UserOutput) ToUserPtrOutput() UserPtrOutput

func (UserOutput) ToUserPtrOutputWithContext added in v3.25.0 

func (o UserOutput) ToUserPtrOutputWithContext(ctx context.Context) UserPtrOutput

type UserPolicy 

type UserPolicy struct {
	pulumi.CustomResourceState

	// The name of the policy. If omitted, this provider will assign a random, unique name.
	Name pulumi.StringOutput `pulumi:"name"`
	// Creates a unique name beginning with the specified prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrOutput `pulumi:"namePrefix"`
	// The policy document. This is a JSON formatted string.
	Policy pulumi.StringOutput `pulumi:"policy"`
	// IAM user to which to attach this policy.
	User pulumi.StringOutput `pulumi:"user"`
}

Provides an IAM policy attached to a user.

## Example Usage

```go package main

import ( 

"encoding/json"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		lbUser, err := iam.NewUser(ctx, "lbUser", &iam.UserArgs{
			Path: pulumi.String("/system/"),
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": []map[string]interface{}{
				map[string]interface{}{
					"Action": []string{
						"ec2:Describe*",
					},
					"Effect":   "Allow",
					"Resource": "*",
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = iam.NewUserPolicy(ctx, "lbRo", &iam.UserPolicyArgs{
			User:   lbUser.Name,
			Policy: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		_, err = iam.NewAccessKey(ctx, "lbAccessKey", &iam.AccessKeyArgs{
			User: lbUser.Name,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IAM User Policies can be imported using the `user_name:user_policy_name`, e.g.

```sh 

$ pulumi import aws:iam/userPolicy:UserPolicy mypolicy user_of_mypolicy_name:mypolicy_name

```

func GetUserPolicy 

func GetUserPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *UserPolicyState, opts ...pulumi.ResourceOption) (*UserPolicy, error)

GetUserPolicy gets an existing UserPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewUserPolicy 

func NewUserPolicy(ctx *pulumi.Context,
	name string, args *UserPolicyArgs, opts ...pulumi.ResourceOption) (*UserPolicy, error)

NewUserPolicy registers a new resource with the given unique name, arguments, and options.

func (*UserPolicy) ElementType added in v3.13.0 

func (*UserPolicy) ElementType() reflect.Type

func (*UserPolicy) ToUserPolicyOutput added in v3.13.0 

func (i *UserPolicy) ToUserPolicyOutput() UserPolicyOutput

func (*UserPolicy) ToUserPolicyOutputWithContext added in v3.13.0 

func (i *UserPolicy) ToUserPolicyOutputWithContext(ctx context.Context) UserPolicyOutput

func (*UserPolicy) ToUserPolicyPtrOutput added in v3.25.0 

func (i *UserPolicy) ToUserPolicyPtrOutput() UserPolicyPtrOutput

func (*UserPolicy) ToUserPolicyPtrOutputWithContext added in v3.25.0 

func (i *UserPolicy) ToUserPolicyPtrOutputWithContext(ctx context.Context) UserPolicyPtrOutput

type UserPolicyArgs 

type UserPolicyArgs struct {
	// The name of the policy. If omitted, this provider will assign a random, unique name.
	Name pulumi.StringPtrInput
	// Creates a unique name beginning with the specified prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrInput
	// The policy document. This is a JSON formatted string.
	Policy pulumi.Input
	// IAM user to which to attach this policy.
	User pulumi.StringInput
}

The set of arguments for constructing a UserPolicy resource.

func (UserPolicyArgs) ElementType 

func (UserPolicyArgs) ElementType() reflect.Type

type UserPolicyArray added in v3.25.0 

type UserPolicyArray []UserPolicyInput

func (UserPolicyArray) ElementType added in v3.25.0 

func (UserPolicyArray) ElementType() reflect.Type

func (UserPolicyArray) ToUserPolicyArrayOutput added in v3.25.0 

func (i UserPolicyArray) ToUserPolicyArrayOutput() UserPolicyArrayOutput

func (UserPolicyArray) ToUserPolicyArrayOutputWithContext added in v3.25.0 

func (i UserPolicyArray) ToUserPolicyArrayOutputWithContext(ctx context.Context) UserPolicyArrayOutput

type UserPolicyArrayInput added in v3.25.0 

type UserPolicyArrayInput interface {
	pulumi.Input

	ToUserPolicyArrayOutput() UserPolicyArrayOutput
	ToUserPolicyArrayOutputWithContext(context.Context) UserPolicyArrayOutput
}

UserPolicyArrayInput is an input type that accepts UserPolicyArray and UserPolicyArrayOutput values. You can construct a concrete instance of `UserPolicyArrayInput` via: 

UserPolicyArray{ UserPolicyArgs{...} }

type UserPolicyArrayOutput added in v3.25.0 

type UserPolicyArrayOutput struct{ *pulumi.OutputState }

func (UserPolicyArrayOutput) ElementType added in v3.25.0 

func (UserPolicyArrayOutput) ElementType() reflect.Type

func (UserPolicyArrayOutput) Index added in v3.25.0 

func (o UserPolicyArrayOutput) Index(i pulumi.IntInput) UserPolicyOutput

func (UserPolicyArrayOutput) ToUserPolicyArrayOutput added in v3.25.0 

func (o UserPolicyArrayOutput) ToUserPolicyArrayOutput() UserPolicyArrayOutput

func (UserPolicyArrayOutput) ToUserPolicyArrayOutputWithContext added in v3.25.0 

func (o UserPolicyArrayOutput) ToUserPolicyArrayOutputWithContext(ctx context.Context) UserPolicyArrayOutput

type UserPolicyAttachment 

type UserPolicyAttachment struct {
	pulumi.CustomResourceState

	// The ARN of the policy you want to apply
	PolicyArn pulumi.StringOutput `pulumi:"policyArn"`
	// The user the policy should be applied to
	User pulumi.StringOutput `pulumi:"user"`
}

Attaches a Managed IAM Policy to an IAM user

> **NOTE:** The usage of this resource conflicts with the `iam.PolicyAttachment` resource and will permanently show a difference if both are defined.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		user, err := iam.NewUser(ctx, "user", nil)
		if err != nil {
			return err
		}
		policy, err := iam.NewPolicy(ctx, "policy", &iam.PolicyArgs{
			Description: pulumi.String("A test policy"),
			Policy:      pulumi.String("{ ... policy JSON ... }"),
		})
		if err != nil {
			return err
		}
		_, err = iam.NewUserPolicyAttachment(ctx, "test_attach", &iam.UserPolicyAttachmentArgs{
			User:      user.Name,
			PolicyArn: policy.Arn,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IAM user policy attachments can be imported using the user name and policy arn separated by `/`.

```sh 

$ pulumi import aws:iam/userPolicyAttachment:UserPolicyAttachment test-attach test-user/arn:aws:iam::xxxxxxxxxxxx:policy/test-policy

```

func GetUserPolicyAttachment 

func GetUserPolicyAttachment(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *UserPolicyAttachmentState, opts ...pulumi.ResourceOption) (*UserPolicyAttachment, error)

GetUserPolicyAttachment gets an existing UserPolicyAttachment resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewUserPolicyAttachment 

func NewUserPolicyAttachment(ctx *pulumi.Context,
	name string, args *UserPolicyAttachmentArgs, opts ...pulumi.ResourceOption) (*UserPolicyAttachment, error)

NewUserPolicyAttachment registers a new resource with the given unique name, arguments, and options.

func (*UserPolicyAttachment) ElementType added in v3.13.0 

func (*UserPolicyAttachment) ElementType() reflect.Type

func (*UserPolicyAttachment) ToUserPolicyAttachmentOutput added in v3.13.0 

func (i *UserPolicyAttachment) ToUserPolicyAttachmentOutput() UserPolicyAttachmentOutput

func (*UserPolicyAttachment) ToUserPolicyAttachmentOutputWithContext added in v3.13.0 

func (i *UserPolicyAttachment) ToUserPolicyAttachmentOutputWithContext(ctx context.Context) UserPolicyAttachmentOutput

func (*UserPolicyAttachment) ToUserPolicyAttachmentPtrOutput added in v3.25.0 

func (i *UserPolicyAttachment) ToUserPolicyAttachmentPtrOutput() UserPolicyAttachmentPtrOutput

func (*UserPolicyAttachment) ToUserPolicyAttachmentPtrOutputWithContext added in v3.25.0 

func (i *UserPolicyAttachment) ToUserPolicyAttachmentPtrOutputWithContext(ctx context.Context) UserPolicyAttachmentPtrOutput

type UserPolicyAttachmentArgs 

type UserPolicyAttachmentArgs struct {
	// The ARN of the policy you want to apply
	PolicyArn pulumi.StringInput
	// The user the policy should be applied to
	User pulumi.Input
}

The set of arguments for constructing a UserPolicyAttachment resource.

func (UserPolicyAttachmentArgs) ElementType 

func (UserPolicyAttachmentArgs) ElementType() reflect.Type

type UserPolicyAttachmentArray added in v3.25.0 

type UserPolicyAttachmentArray []UserPolicyAttachmentInput

func (UserPolicyAttachmentArray) ElementType added in v3.25.0 

func (UserPolicyAttachmentArray) ElementType() reflect.Type

func (UserPolicyAttachmentArray) ToUserPolicyAttachmentArrayOutput added in v3.25.0 

func (i UserPolicyAttachmentArray) ToUserPolicyAttachmentArrayOutput() UserPolicyAttachmentArrayOutput

func (UserPolicyAttachmentArray) ToUserPolicyAttachmentArrayOutputWithContext added in v3.25.0 

func (i UserPolicyAttachmentArray) ToUserPolicyAttachmentArrayOutputWithContext(ctx context.Context) UserPolicyAttachmentArrayOutput

type UserPolicyAttachmentArrayInput added in v3.25.0 

type UserPolicyAttachmentArrayInput interface {
	pulumi.Input

	ToUserPolicyAttachmentArrayOutput() UserPolicyAttachmentArrayOutput
	ToUserPolicyAttachmentArrayOutputWithContext(context.Context) UserPolicyAttachmentArrayOutput
}

UserPolicyAttachmentArrayInput is an input type that accepts UserPolicyAttachmentArray and UserPolicyAttachmentArrayOutput values. You can construct a concrete instance of `UserPolicyAttachmentArrayInput` via: 

UserPolicyAttachmentArray{ UserPolicyAttachmentArgs{...} }

type UserPolicyAttachmentArrayOutput added in v3.25.0 

type UserPolicyAttachmentArrayOutput struct{ *pulumi.OutputState }

func (UserPolicyAttachmentArrayOutput) ElementType added in v3.25.0 

func (UserPolicyAttachmentArrayOutput) ElementType() reflect.Type

func (UserPolicyAttachmentArrayOutput) Index added in v3.25.0 

func (o UserPolicyAttachmentArrayOutput) Index(i pulumi.IntInput) UserPolicyAttachmentOutput

func (UserPolicyAttachmentArrayOutput) ToUserPolicyAttachmentArrayOutput added in v3.25.0 

func (o UserPolicyAttachmentArrayOutput) ToUserPolicyAttachmentArrayOutput() UserPolicyAttachmentArrayOutput

func (UserPolicyAttachmentArrayOutput) ToUserPolicyAttachmentArrayOutputWithContext added in v3.25.0 

func (o UserPolicyAttachmentArrayOutput) ToUserPolicyAttachmentArrayOutputWithContext(ctx context.Context) UserPolicyAttachmentArrayOutput

type UserPolicyAttachmentInput added in v3.13.0 

type UserPolicyAttachmentInput interface {
	pulumi.Input

	ToUserPolicyAttachmentOutput() UserPolicyAttachmentOutput
	ToUserPolicyAttachmentOutputWithContext(ctx context.Context) UserPolicyAttachmentOutput
}

type UserPolicyAttachmentMap added in v3.25.0 

type UserPolicyAttachmentMap map[string]UserPolicyAttachmentInput

func (UserPolicyAttachmentMap) ElementType added in v3.25.0 

func (UserPolicyAttachmentMap) ElementType() reflect.Type

func (UserPolicyAttachmentMap) ToUserPolicyAttachmentMapOutput added in v3.25.0 

func (i UserPolicyAttachmentMap) ToUserPolicyAttachmentMapOutput() UserPolicyAttachmentMapOutput

func (UserPolicyAttachmentMap) ToUserPolicyAttachmentMapOutputWithContext added in v3.25.0 

func (i UserPolicyAttachmentMap) ToUserPolicyAttachmentMapOutputWithContext(ctx context.Context) UserPolicyAttachmentMapOutput

type UserPolicyAttachmentMapInput added in v3.25.0 

type UserPolicyAttachmentMapInput interface {
	pulumi.Input

	ToUserPolicyAttachmentMapOutput() UserPolicyAttachmentMapOutput
	ToUserPolicyAttachmentMapOutputWithContext(context.Context) UserPolicyAttachmentMapOutput
}

UserPolicyAttachmentMapInput is an input type that accepts UserPolicyAttachmentMap and UserPolicyAttachmentMapOutput values. You can construct a concrete instance of `UserPolicyAttachmentMapInput` via: 

UserPolicyAttachmentMap{ "key": UserPolicyAttachmentArgs{...} }

type UserPolicyAttachmentMapOutput added in v3.25.0 

type UserPolicyAttachmentMapOutput struct{ *pulumi.OutputState }

func (UserPolicyAttachmentMapOutput) ElementType added in v3.25.0 

func (UserPolicyAttachmentMapOutput) ElementType() reflect.Type

func (UserPolicyAttachmentMapOutput) MapIndex added in v3.25.0 

func (o UserPolicyAttachmentMapOutput) MapIndex(k pulumi.StringInput) UserPolicyAttachmentOutput

func (UserPolicyAttachmentMapOutput) ToUserPolicyAttachmentMapOutput added in v3.25.0 

func (o UserPolicyAttachmentMapOutput) ToUserPolicyAttachmentMapOutput() UserPolicyAttachmentMapOutput

func (UserPolicyAttachmentMapOutput) ToUserPolicyAttachmentMapOutputWithContext added in v3.25.0 

func (o UserPolicyAttachmentMapOutput) ToUserPolicyAttachmentMapOutputWithContext(ctx context.Context) UserPolicyAttachmentMapOutput

type UserPolicyAttachmentOutput added in v3.13.0 

type UserPolicyAttachmentOutput struct {
	*pulumi.OutputState
}

func (UserPolicyAttachmentOutput) ElementType added in v3.13.0 

func (UserPolicyAttachmentOutput) ElementType() reflect.Type

func (UserPolicyAttachmentOutput) ToUserPolicyAttachmentOutput added in v3.13.0 

func (o UserPolicyAttachmentOutput) ToUserPolicyAttachmentOutput() UserPolicyAttachmentOutput

func (UserPolicyAttachmentOutput) ToUserPolicyAttachmentOutputWithContext added in v3.13.0 

func (o UserPolicyAttachmentOutput) ToUserPolicyAttachmentOutputWithContext(ctx context.Context) UserPolicyAttachmentOutput

func (UserPolicyAttachmentOutput) ToUserPolicyAttachmentPtrOutput added in v3.25.0 

func (o UserPolicyAttachmentOutput) ToUserPolicyAttachmentPtrOutput() UserPolicyAttachmentPtrOutput

func (UserPolicyAttachmentOutput) ToUserPolicyAttachmentPtrOutputWithContext added in v3.25.0 

func (o UserPolicyAttachmentOutput) ToUserPolicyAttachmentPtrOutputWithContext(ctx context.Context) UserPolicyAttachmentPtrOutput

type UserPolicyAttachmentPtrInput added in v3.25.0 

type UserPolicyAttachmentPtrInput interface {
	pulumi.Input

	ToUserPolicyAttachmentPtrOutput() UserPolicyAttachmentPtrOutput
	ToUserPolicyAttachmentPtrOutputWithContext(ctx context.Context) UserPolicyAttachmentPtrOutput
}

type UserPolicyAttachmentPtrOutput added in v3.25.0 

type UserPolicyAttachmentPtrOutput struct {
	*pulumi.OutputState
}

func (UserPolicyAttachmentPtrOutput) ElementType added in v3.25.0 

func (UserPolicyAttachmentPtrOutput) ElementType() reflect.Type

func (UserPolicyAttachmentPtrOutput) ToUserPolicyAttachmentPtrOutput added in v3.25.0 

func (o UserPolicyAttachmentPtrOutput) ToUserPolicyAttachmentPtrOutput() UserPolicyAttachmentPtrOutput

func (UserPolicyAttachmentPtrOutput) ToUserPolicyAttachmentPtrOutputWithContext added in v3.25.0 

func (o UserPolicyAttachmentPtrOutput) ToUserPolicyAttachmentPtrOutputWithContext(ctx context.Context) UserPolicyAttachmentPtrOutput

type UserPolicyAttachmentState 

type UserPolicyAttachmentState struct {
	// The ARN of the policy you want to apply
	PolicyArn pulumi.StringPtrInput
	// The user the policy should be applied to
	User pulumi.StringPtrInput
}

func (UserPolicyAttachmentState) ElementType 

func (UserPolicyAttachmentState) ElementType() reflect.Type

type UserPolicyInput added in v3.13.0 

type UserPolicyInput interface {
	pulumi.Input

	ToUserPolicyOutput() UserPolicyOutput
	ToUserPolicyOutputWithContext(ctx context.Context) UserPolicyOutput
}

type UserPolicyMap added in v3.25.0 

type UserPolicyMap map[string]UserPolicyInput

func (UserPolicyMap) ElementType added in v3.25.0 

func (UserPolicyMap) ElementType() reflect.Type

func (UserPolicyMap) ToUserPolicyMapOutput added in v3.25.0 

func (i UserPolicyMap) ToUserPolicyMapOutput() UserPolicyMapOutput

func (UserPolicyMap) ToUserPolicyMapOutputWithContext added in v3.25.0 

func (i UserPolicyMap) ToUserPolicyMapOutputWithContext(ctx context.Context) UserPolicyMapOutput

type UserPolicyMapInput added in v3.25.0 

type UserPolicyMapInput interface {
	pulumi.Input

	ToUserPolicyMapOutput() UserPolicyMapOutput
	ToUserPolicyMapOutputWithContext(context.Context) UserPolicyMapOutput
}

UserPolicyMapInput is an input type that accepts UserPolicyMap and UserPolicyMapOutput values. You can construct a concrete instance of `UserPolicyMapInput` via: 

UserPolicyMap{ "key": UserPolicyArgs{...} }

type UserPolicyMapOutput added in v3.25.0 

type UserPolicyMapOutput struct{ *pulumi.OutputState }

func (UserPolicyMapOutput) ElementType added in v3.25.0 

func (UserPolicyMapOutput) ElementType() reflect.Type

func (UserPolicyMapOutput) MapIndex added in v3.25.0 

func (o UserPolicyMapOutput) MapIndex(k pulumi.StringInput) UserPolicyOutput

func (UserPolicyMapOutput) ToUserPolicyMapOutput added in v3.25.0 

func (o UserPolicyMapOutput) ToUserPolicyMapOutput() UserPolicyMapOutput

func (UserPolicyMapOutput) ToUserPolicyMapOutputWithContext added in v3.25.0 

func (o UserPolicyMapOutput) ToUserPolicyMapOutputWithContext(ctx context.Context) UserPolicyMapOutput

type UserPolicyOutput added in v3.13.0 

type UserPolicyOutput struct {
	*pulumi.OutputState
}

func (UserPolicyOutput) ElementType added in v3.13.0 

func (UserPolicyOutput) ElementType() reflect.Type

func (UserPolicyOutput) ToUserPolicyOutput added in v3.13.0 

func (o UserPolicyOutput) ToUserPolicyOutput() UserPolicyOutput

func (UserPolicyOutput) ToUserPolicyOutputWithContext added in v3.13.0 

func (o UserPolicyOutput) ToUserPolicyOutputWithContext(ctx context.Context) UserPolicyOutput

func (UserPolicyOutput) ToUserPolicyPtrOutput added in v3.25.0 

func (o UserPolicyOutput) ToUserPolicyPtrOutput() UserPolicyPtrOutput

func (UserPolicyOutput) ToUserPolicyPtrOutputWithContext added in v3.25.0 

func (o UserPolicyOutput) ToUserPolicyPtrOutputWithContext(ctx context.Context) UserPolicyPtrOutput

type UserPolicyPtrInput added in v3.25.0 

type UserPolicyPtrInput interface {
	pulumi.Input

	ToUserPolicyPtrOutput() UserPolicyPtrOutput
	ToUserPolicyPtrOutputWithContext(ctx context.Context) UserPolicyPtrOutput
}

type UserPolicyPtrOutput added in v3.25.0 

type UserPolicyPtrOutput struct {
	*pulumi.OutputState
}

func (UserPolicyPtrOutput) ElementType added in v3.25.0 

func (UserPolicyPtrOutput) ElementType() reflect.Type

func (UserPolicyPtrOutput) ToUserPolicyPtrOutput added in v3.25.0 

func (o UserPolicyPtrOutput) ToUserPolicyPtrOutput() UserPolicyPtrOutput

func (UserPolicyPtrOutput) ToUserPolicyPtrOutputWithContext added in v3.25.0 

func (o UserPolicyPtrOutput) ToUserPolicyPtrOutputWithContext(ctx context.Context) UserPolicyPtrOutput

type UserPolicyState 

type UserPolicyState struct {
	// The name of the policy. If omitted, this provider will assign a random, unique name.
	Name pulumi.StringPtrInput
	// Creates a unique name beginning with the specified prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrInput
	// The policy document. This is a JSON formatted string.
	Policy pulumi.StringPtrInput
	// IAM user to which to attach this policy.
	User pulumi.StringPtrInput
}

func (UserPolicyState) ElementType 

func (UserPolicyState) ElementType() reflect.Type

type UserPtrInput added in v3.25.0 

type UserPtrInput interface {
	pulumi.Input

	ToUserPtrOutput() UserPtrOutput
	ToUserPtrOutputWithContext(ctx context.Context) UserPtrOutput
}

type UserPtrOutput added in v3.25.0 

type UserPtrOutput struct {
	*pulumi.OutputState
}

func (UserPtrOutput) ElementType added in v3.25.0 

func (UserPtrOutput) ElementType() reflect.Type

func (UserPtrOutput) ToUserPtrOutput added in v3.25.0 

func (o UserPtrOutput) ToUserPtrOutput() UserPtrOutput

func (UserPtrOutput) ToUserPtrOutputWithContext added in v3.25.0 

func (o UserPtrOutput) ToUserPtrOutputWithContext(ctx context.Context) UserPtrOutput

type UserState 

type UserState struct {
	// The ARN assigned by AWS for this user.
	Arn pulumi.StringPtrInput
	// When destroying this user, destroy even if it
	// has non-provider-managed IAM access keys, login profile or MFA devices. Without `forceDestroy`
	// a user with non-provider-managed access keys and login profile will fail to be destroyed.
	ForceDestroy pulumi.BoolPtrInput
	// The user's name. The name must consist of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: `=,.@-_.`. User names are not distinguished by case. For example, you cannot create users named both "TESTUSER" and "testuser".
	Name pulumi.StringPtrInput
	// Path in which to create the user.
	Path pulumi.StringPtrInput
	// The ARN of the policy that is used to set the permissions boundary for the user.
	PermissionsBoundary pulumi.StringPtrInput
	// Key-value mapping of tags for the IAM user
	Tags pulumi.StringMapInput
	// The [unique ID][1] assigned by AWS.
	UniqueId pulumi.StringPtrInput
}

func (UserState) ElementType 

func (UserState) ElementType() reflect.Type

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.