@aws-cdk/aws-cognito
Advanced tools
| Features | Stability |
|---|---|
| CFN Resources |  |
| Higher level constructs for User Pools |  |
| Higher level constructs for Identity Pools |  |
CFN Resources: All classes with the
Cfnprefix in this module (CFN Resources) are always stable and safe to use.
Developer Preview: Higher level constructs in this module that are marked as developer preview have completed their phase of active development and are looking for adoption and feedback. While the same caveats around non-backward compatible as Experimental constructs apply, they will undergo fewer breaking changes. Just as with Experimental constructs, these are not subject to the Semantic Versioning model and breaking changes will be announced in the release notes.
Amazon Cognito provides authentication, authorization, and user management for your web and mobile apps. Your users can sign in directly with a user name and password, or through a third party such as Facebook, Amazon, Google or Apple.
The two main components of Amazon Cognito are user pools and identity pools. User pools are user directories that provide sign-up and sign-in options for your app users. Identity pools enable you to grant your users access to other AWS services.
This module is part of the AWS Cloud Development Kit project.
User pools allow creating and managing your own directory of users that can sign up and sign in. They enable easy integration with social identity providers such as Facebook, Google, Amazon, Microsoft Active Directory, etc. through SAML.
Using the CDK, a new user pool can be created as part of the stack using the construct's constructor. You may specify
the userPoolName to give your own identifier to the user pool. If not, CloudFormation will generate a name.
new UserPool(this, 'myuserpool', {
userPoolName: 'myawesomeapp-userpool',
});
Users can either be signed up by the app's administrators or can sign themselves up. Once a user has signed up, their account needs to be confirmed. Cognito provides several ways to sign users up and confirm their accounts. Learn more about user sign up here.
When a user signs up, email and SMS messages are used to verify their account and contact methods. The following code snippet configures a user pool with properties relevant to these verification messages -
new UserPool(this, 'myuserpool', {
// ...
selfSignUpEnabled: true,
userVerification: {
emailSubject: 'Verify your email for our awesome app!',
emailBody: 'Hello {username}, Thanks for signing up to our awesome app! Your verification code is {####}',
emailStyle: VerificationEmailStyle.CODE,
smsMessage: 'Hello {username}, Thanks for signing up to our awesome app! Your verification code is {####}',
}
});
By default, self sign up is disabled. Learn more about email and SMS verification messages here.
Besides users signing themselves up, an administrator of any user pool can sign users up. The user then receives an invitation to join the user pool. The following code snippet configures a user pool with properties relevant to the invitation messages -
new UserPool(this, 'myuserpool', {
// ...
userInvitation: {
emailSubject: 'Invite to join our awesome app!',
emailBody: 'Hello {username}, you have been invited to join our awesome app! Your temporary password is {####}',
smsMessage: 'Your temporary password for our awesome app is {####}'
}
});
All email subjects, bodies and SMS messages for both invitation and verification support Cognito's message templating. Learn more about message templates here.
Users registering or signing in into your application can do so with multiple identifiers. There are 4 options available:
username: Allow signing in using the one time immutable user name that the user chose at the time of sign up.email: Allow signing in using the email address that is associated with the account.phone: Allow signing in using the phone number that is associated with the account.preferredUsername: Allow signing in with an alternate user name that the user can change at any time. However, this
is not available if the username option is not chosen.The following code sets up a user pool so that the user can sign in with either their username or their email address -
new UserPool(this, 'myuserpool', {
// ...
// ...
signInAliases: {
username: true,
email: true
},
});
User pools can either be configured so that user name is primary sign in form, but also allows for the other three to be used additionally; or it can be configured so that email and/or phone numbers are the only ways a user can register and sign in. Read more about this here.
To match with 'Option 1' in the above link, with a verified email, signInAliases should be set to
{ username: true, email: true }. To match with 'Option 2' in the above link with both a verified
email and phone number, this property should be set to { email: true, phone: true }.
Cognito recommends that email and phone number be automatically verified, if they are one of the sign in methods for
the user pool. Read more about that
here.
The CDK does this by default, when email and/or phone number are specified as part of signInAliases. This can be
overridden by specifying the autoVerify property.
The following code snippet sets up only email as a sign in alias, but both email and phone number to be auto-verified.
new UserPool(this, 'myuserpool', {
// ...
// ...
signInAliases: { username: true, email: true },
autoVerify: { email: true, phone: true }
});
A user pool can optionally ignore case when evaluating sign-ins. When signInCaseSensitive is false, Cognito will not
check the capitalization of the alias when signing in. Default is true.
Attributes represent the various properties of each user that's collected and stored in the user pool. Cognito provides a set of standard attributes that are available for all user pools. Users are allowed to select any of these standard attributes to be required. Users will not be able to sign up to the user pool without providing the required attributes. Besides these, additional attributes can be further defined, and are known as custom attributes.
Learn more on attributes in Cognito's documentation.
The following code configures a user pool with two standard attributes (name and address) as required and mutable, and adds four custom attributes.
new UserPool(this, 'myuserpool', {
// ...
standardAttributes: {
fullname: {
required: true,
mutable: false,
},
address: {
required: false,
mutable: true,
},
},
customAttributes: {
'myappid': new StringAttribute({ minLen: 5, maxLen: 15, mutable: false }),
'callingcode': new NumberAttribute({ min: 1, max: 3, mutable: true }),
'isEmployee': new BooleanAttribute({ mutable: true }),
'joinedOn': new DateTimeAttribute(),
},
});
As shown in the code snippet, there are data types that are available for custom attributes. The 'String' and 'Number' data types allow for further constraints on their length and values, respectively.
Custom attributes cannot be marked as required.
All custom attributes share the property mutable that specifies whether the value of the attribute can be changed.
The default value is false.
Cognito sends various messages to its users via SMS, for different actions, ranging from account verification to marketing. In order to send SMS messages, Cognito needs an IAM role that it can assume, with permissions that allow it to send SMS messages.
By default, the CDK looks at all of the specified properties (and their defaults when not explicitly specified) and
automatically creates an SMS role, when needed. For example, if MFA second factor by SMS is enabled, the CDK will
create a new role. The smsRole property can be used to specify the user supplied role that should be used instead.
Additionally, the property enableSmsRole can be used to override the CDK's default behaviour to either enable or
suppress automatic role creation.
import { Role } from '@aws-cdk/aws-iam';
const poolSmsRole = new Role(this, 'userpoolsmsrole', { /* ... */ });
new UserPool(this, 'myuserpool', {
// ...
smsRole: poolSmsRole,
smsRoleExternalId: 'c87467be-4f34-11ea-b77f-2e728ce88125'
});
When the smsRole property is specified, the smsRoleExternalId may also be specified. The value of
smsRoleExternalId will be used as the sts:ExternalId when the Cognito service assumes the role. In turn, the role's
assume role policy should be configured to accept this value as the ExternalId. Learn more about ExternalId
here.
User pools can be configured to enable multi-factor authentication (MFA). It can either be turned off, set to optional or made required. Setting MFA to optional means that individual users can choose to enable it. Additionally, the MFA code can be sent either via SMS text message or via a time-based software token. See the documentation on MFA to learn more.
The following code snippet marks MFA for the user pool as required. This means that all users are required to configure an MFA token and use it for sign in. It also allows for the users to use both SMS based MFA, as well, time-based one time password (TOTP).
new UserPool(this, 'myuserpool', {
// ...
mfa: Mfa.REQUIRED,
mfaSecondFactor: {
sms: true,
otp: true,
},
});
User pools can be configured with policies around a user's password. This includes the password length and the character sets that they must contain.
Further to this, it can also be configured with the validity of the auto-generated temporary password. A temporary password is generated by the user pool either when an admin signs up a user or when a password reset is requested. The validity of this password dictates how long to give the user to use this password before expiring it.
The following code snippet configures these properties -
new UserPool(this, 'myuserpool', {
// ...
passwordPolicy: {
minLength: 12,
requireLowercase: true,
requireUppercase: true,
requireDigits: true,
requireSymbols: true,
tempPasswordValidity: Duration.days(3),
},
});
Note that, tempPasswordValidity can be specified only in whole days. Specifying fractional days would throw an error.
User pools can be configured on which method a user should use when recovering the password for their account. This can either be email and/or SMS. Read more at Recovering User Accounts
new UserPool(this, 'UserPool', {
...,
accountRecovery: AccountRecovery.EMAIL_ONLY,
})
Cognito sends emails to users in the user pool, when particular actions take place, such as welcome emails, invitation emails, password resets, etc. The address from which these emails are sent can be configured on the user pool. Read more about email settings here.
new UserPool(this, 'myuserpool', {
// ...
emailSettings: {
from: 'noreply@myawesomeapp.com',
replyTo: 'support@myawesomeapp.com',
},
});
By default, user pools are configured to use Cognito's built-in email capability, but it can also be configured to use Amazon SES, however, support for Amazon SES is not available in the CDK yet. If you would like this to be implemented, give this issue a +1. Until then, you can use the cfn layer to configure this.
User pools can be configured such that AWS Lambda functions can be triggered when certain user operations or actions occur, such as, sign up, user confirmation, sign in, etc. They can also be used to add custom authentication challenges, user migrations and custom verification messages. Learn more about triggers at User Pool Workflows with Triggers.
Lambda triggers can either be specified as part of the UserPool initialization, or it can be added later, via methods
on the construct, as so -
const authChallengeFn = new lambda.Function(this, 'authChallengeFn', {
// ...
});
const userpool = new UserPool(this, 'myuserpool', {
// ...
triggers: {
createAuthChallenge: authChallengeFn,
// ...
}
});
userpool.addTrigger(UserPoolOperation.USER_MIGRATION, new lambda.Function(this, 'userMigrationFn', {
// ...
}));
The following table lists the set of triggers available, and their corresponding method to add it to the user pool. For more information on the function of these triggers and how to configure them, read User Pool Workflows with Triggers.
Any user pool that has been created outside of this stack, can be imported into the CDK app. Importing a user pool
allows for it to be used in other parts of the CDK app that reference an IUserPool. However, imported user pools have
limited configurability. As a rule of thumb, none of the properties that are part of the
AWS::Cognito::UserPool
CloudFormation resource can be configured.
User pools can be imported either using their id via the UserPool.fromUserPoolId(), or by using their ARN, via the
UserPool.fromUserPoolArn() API.
const stack = new Stack(app, 'my-stack');
const awesomePool = UserPool.fromUserPoolId(stack, 'awesome-user-pool', 'us-east-1_oiuR12Abd');
const otherAwesomePool = UserPool.fromUserPoolArn(stack, 'other-awesome-user-pool',
'arn:aws:cognito-idp:eu-west-1:123456789012:userpool/us-east-1_mtRyYQ14D');
Users that are part of a user pool can sign in either directly through a user pool, or federate through a third-party identity provider. Once configured, the Cognito backend will take care of integrating with the third-party provider. Read more about Adding User Pool Sign-in Through a Third Party.
The following third-party identity providers are currentlhy supported in the CDK -
The following code configures a user pool to federate with the third party provider, 'Login with Amazon'. The identity provider needs to be configured with a set of credentials that the Cognito backend can use to federate with the third-party identity provider.
const userpool = new UserPool(stack, 'Pool');
const provider = new UserPoolIdentityProviderAmazon(stack, 'Amazon', {
clientId: 'amzn-client-id',
clientSecret: 'amzn-client-secret',
userPool: userpool,
});
Attribute mapping allows mapping attributes provided by the third-party identity providers to standard and custom attributes of the user pool. Learn more about Specifying Identity Provider Attribute Mappings for Your User Pool.
The following code shows how different attributes provided by 'Login With Amazon' can be mapped to standard and custom user pool attributes.
new UserPoolIdentityProviderAmazon(stack, 'Amazon', {
// ...
attributeMapping: {
email: ProviderAttribute.AMAZON_EMAIL,
website: ProviderAttribute.other('url'), // use other() when an attribute is not pre-defined in the CDK
custom: {
// custom user pool attributes go here
uniqueId: ProviderAttribute.AMAZON_USER_ID,
}
}
});
An app is an entity within a user pool that has permission to call unauthenticated APIs (APIs that do not have an authenticated user), such as APIs to register, sign in, and handle forgotten passwords. To call these APIs, you need an app client ID and an optional client secret. Read Configuring a User Pool App Client to learn more.
The following code creates an app client and retrieves the client id -
const pool = new UserPool(this, 'pool');
const client = pool.addClient('customer-app-client');
const clientId = client.userPoolClientId;
Existing app clients can be imported into the CDK app using the UserPoolClient.fromUserPoolClientId() API. For new
and imported user pools, clients can also be created via the UserPoolClient constructor, as so -
const importedPool = UserPool.fromUserPoolId(this, 'imported-pool', 'us-east-1_oiuR12Abd');
new UserPoolClient(this, 'customer-app-client', {
userPool: importedPool
});
Clients can be configured with authentication flows. Authentication flows allow users on a client to be authenticated with a user pool. Cognito user pools provide several several different types of authentication, such as, SRP (Secure Remote Password) authentication, username-and-password authentication, etc. Learn more about this at UserPool Authentication Flow.
The following code configures a client to use both SRP and username-and-password authentication -
const pool = new UserPool(this, 'pool');
pool.addClient('app-client', {
authFlows: {
userPassword: true,
userSrp: true,
}
});
Custom authentication protocols can be configured by setting the custom property under authFlow and defining lambda
functions for the corresponding user pool triggers. Learn more at Custom Authentication
Flow.
In addition to these authentication mechanisms, Cognito user pools also support using OAuth 2.0 framework for authenticating users. User pool clients can be configured with OAuth 2.0 authorization flows and scopes. Learn more about the OAuth 2.0 authorization framework and Cognito user pool's implementation of OAuth2.0.
The following code configures an app client with the authorization code grant flow and registers the the app's welcome page as a callback (or redirect) URL. It also configures the access token scope to 'openid'. All of these concepts can be found in the OAuth 2.0 RFC.
const pool = new UserPool(this, 'Pool');
pool.addClient('app-client', {
oAuth: {
flows: {
authorizationCodeGrant: true,
},
scopes: [ OAuthScope.OPENID ],
callbackUrls: [ 'https://my-app-domain.com/welcome' ],
logoutUrls: [ 'https://my-app-domain.com/signin' ],
}
});
An app client can be configured to prevent user existence errors. This instructs the Cognito authentication API to return generic authentication failure responses instead of an UserNotFoundException. By default, the flag is not set, which means different things for existing and new stacks. See the documentation for the full details on the behavior of this flag.
const pool = new UserPool(this, 'Pool');
pool.addClient('app-client', {
preventUserExistenceErrors: true,
});
All identity providers created in the CDK app are automatically registered into the corresponding user pool. All app clients created in the CDK have all of the identity providers enabled by default. The 'Cognito' identity provider, that allows users to register and sign in directly with the Cognito user pool, is also enabled by default. Alternatively, the list of supported identity providers for a client can be explicitly specified -
const pool = new UserPool(this, 'Pool');
pool.addClient('app-client', {
// ...
supportedIdentityProviders: [
UserPoolClientIdentityProvider.AMAZON,
UserPoolClientIdentityProvider.COGNITO,
]
});
After setting up an app client, the address for the user pool's sign-up and sign-in webpages can be configured using domains. There are two ways to set up a domain - either the Amazon Cognito hosted domain can be chosen with an available domain prefix, or a custom domain name can be chosen. The custom domain must be one that is already owned, and whose certificate is registered in AWS Certificate Manager.
The following code sets up a user pool domain in Amazon Cognito hosted domain with the prefix 'my-awesome-app', and another domain with the custom domain 'user.myapp.com' -
const pool = new UserPool(this, 'Pool');
pool.addDomain('CognitoDomain', {
cognitoDomain: {
domainPrefix: 'my-awesome-app',
},
});
const domainCert = new acm.Certificate.fromCertificateArn(this, 'domainCert', certificateArn);
pool.addDomain('CustomDomain', {
customDomain: {
domainName: 'user.myapp.com',
certificate: domainCert,
},
});
Read more about Using the Amazon Cognito Domain and Using Your Own Domain.
The signInUrl() methods returns the fully qualified URL to the login page for the user pool. This page comes from the
hosted UI configured with Cognito. Learn more at Hosted UI with the Amazon Cognito
Console.
const userpool = new UserPool(this, 'UserPool', {
// ...
});
const client = userpool.addClient('Client', {
// ...
oAuth: {
flows: {
implicitCodeGrant: true,
},
callbackUrls: [
'https://myapp.com/home',
'https://myapp.com/users',
]
}
})
const domain = userpool.addDomain('Domain', {
// ...
});
const signInUrl = domain.signInUrl(client, {
redirectUrl: 'https://myapp.com/home', // must be a URL configured under 'callbackUrls' with the client
})
FAQs
The CDK Construct Library for AWS::Cognito
We found that @aws-cdk/aws-cognito demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 4 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Ransomware payment rates hit an all-time low in 2024 as law enforcement crackdowns, stronger defenses, and shifting policies make attacks riskier and less profitable.
Security News
require(esm) backported to Node.js 20, easing the transition to ESM-only packages and reducing complexity for developers as Node 18 nears end-of-life.
Security News
PyPI now supports iOS and Android wheels, making it easier for Python developers to distribute mobile packages.